Initial check-in for software m4v_h263 encoder

Change-Id: I4b49fa5c3a5e6e21cfd2419441d98dd784046367

40 files changed, 26358 insertions, 0 deletions

diff --git a/media/libstagefright/Android.mk b/media/libstagefright/Android.mk
index 49cf647..89bfc1f 100644
--- a/media/libstagefright/Android.mk
+++ b/media/libstagefright/Android.mk
@@ -68,6 +68,7 @@ LOCAL_STATIC_LIBRARIES := \
         libstagefright_avcdec \
         libstagefright_avcenc \
         libstagefright_m4vh263dec \
+        libstagefright_m4vh263enc \
         libstagefright_mp3dec \
         libstagefright_vorbisdec \
         libstagefright_matroska \
diff --git a/media/libstagefright/OMXCodec.cpp b/media/libstagefright/OMXCodec.cpp
index 157897b..7762bf4 100644
--- a/media/libstagefright/OMXCodec.cpp
+++ b/media/libstagefright/OMXCodec.cpp
@@ -27,6 +27,7 @@
 #include "include/AVCDecoder.h"
 #include "include/AVCEncoder.h"
 #include "include/M4vH263Decoder.h"
+#include "include/M4vH263Encoder.h"
 #include "include/MP3Decoder.h"
 #include "include/VorbisDecoder.h"
 #include "include/VPXDecoder.h"
@@ -83,6 +84,7 @@ FACTORY_CREATE_ENCODER(AMRNBEncoder)
 FACTORY_CREATE_ENCODER(AMRWBEncoder)
 FACTORY_CREATE_ENCODER(AACEncoder)
 FACTORY_CREATE_ENCODER(AVCEncoder)
+FACTORY_CREATE_ENCODER(M4vH263Encoder)
 
 static sp<MediaSource> InstantiateSoftwareEncoder(
         const char *name, const sp<MediaSource> &source,
@@ -97,6 +99,7 @@ static sp<MediaSource> InstantiateSoftwareEncoder(
         FACTORY_REF(AMRWBEncoder)
         FACTORY_REF(AACEncoder)
         FACTORY_REF(AVCEncoder)
+        FACTORY_REF(M4vH263Encoder)
     };
     for (size_t i = 0;
          i < sizeof(kFactoryInfo) / sizeof(kFactoryInfo[0]); ++i) {
@@ -181,10 +184,12 @@ static const CodecInfo kEncoderInfo[] = {
     { MEDIA_MIMETYPE_VIDEO_MPEG4, "OMX.qcom.7x30.video.encoder.mpeg4" },
     { MEDIA_MIMETYPE_VIDEO_MPEG4, "OMX.qcom.video.encoder.mpeg4" },
     { MEDIA_MIMETYPE_VIDEO_MPEG4, "OMX.TI.Video.encoder" },
+    { MEDIA_MIMETYPE_VIDEO_MPEG4, "M4vH263Encoder" },
 //    { MEDIA_MIMETYPE_VIDEO_MPEG4, "OMX.PV.mpeg4enc" },
     { MEDIA_MIMETYPE_VIDEO_H263, "OMX.qcom.7x30.video.encoder.h263" },
     { MEDIA_MIMETYPE_VIDEO_H263, "OMX.qcom.video.encoder.h263" },
     { MEDIA_MIMETYPE_VIDEO_H263, "OMX.TI.Video.encoder" },
+    { MEDIA_MIMETYPE_VIDEO_H263, "M4vH263Encoder" },
 //    { MEDIA_MIMETYPE_VIDEO_H263, "OMX.PV.h263enc" },
     { MEDIA_MIMETYPE_VIDEO_AVC, "OMX.qcom.7x30.video.encoder.avc" },
     { MEDIA_MIMETYPE_VIDEO_AVC, "OMX.qcom.video.encoder.avc" },
diff --git a/media/libstagefright/codecs/m4v_h263/enc/Android.mk b/media/libstagefright/codecs/m4v_h263/enc/Android.mk
new file mode 100644
index 0000000..f2c9320
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/Android.mk
@@ -0,0 +1,37 @@
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+    M4vH263Encoder.cpp \
+    src/bitstream_io.cpp \
+    src/combined_encode.cpp \
+    src/datapart_encode.cpp \
+    src/dct.cpp \
+    src/findhalfpel.cpp \
+    src/fastcodemb.cpp \
+    src/fastidct.cpp \
+    src/fastquant.cpp \
+    src/me_utils.cpp \
+    src/mp4enc_api.cpp \
+    src/rate_control.cpp \
+    src/motion_est.cpp \
+    src/motion_comp.cpp \
+    src/sad.cpp \
+    src/sad_halfpel.cpp \
+    src/vlc_encode.cpp \
+    src/vop.cpp
+
+
+LOCAL_MODULE := libstagefright_m4vh263enc
+
+LOCAL_CFLAGS := \
+    -DBX_RC \
+    -DOSCL_IMPORT_REF= -DOSCL_UNUSED_ARG= -DOSCL_EXPORT_REF=
+
+LOCAL_C_INCLUDES := \
+    $(LOCAL_PATH)/src \
+    $(LOCAL_PATH)/include \
+    $(TOP)/external/opencore/extern_libs_v2/khronos/openmax/include \
+    $(TOP)/frameworks/base/media/libstagefright/include
+
+include $(BUILD_STATIC_LIBRARY)
diff --git a/media/libstagefright/codecs/m4v_h263/enc/M4vH263Encoder.cpp b/media/libstagefright/codecs/m4v_h263/enc/M4vH263Encoder.cpp
new file mode 100644
index 0000000..e375250
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/M4vH263Encoder.cpp
@@ -0,0 +1,359 @@
+/*
+ * 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 "M4vH263Encoder"
+#include <utils/Log.h>
+
+#include "M4vH263Encoder.h"
+
+#include "mp4enc_api.h"
+#include "OMX_Video.h"
+
+#include <media/stagefright/MediaBufferGroup.h>
+#include <media/stagefright/MediaDebug.h>
+#include <media/stagefright/MediaDefs.h>
+#include <media/stagefright/MediaErrors.h>
+#include <media/stagefright/MetaData.h>
+#include <media/stagefright/Utils.h>
+
+namespace android {
+
+inline static void ConvertYUV420SemiPlanarToYUV420Planar(
+        uint8_t *inyuv, uint8_t* outyuv,
+        int32_t width, int32_t height) {
+
+    int32_t outYsize = width * height;
+    uint32_t *outy = (uint32_t *)  outyuv;
+    uint16_t *outcb = (uint16_t *) (outyuv + outYsize);
+    uint16_t *outcr = (uint16_t *) (outyuv + outYsize + (outYsize >> 2));
+
+    /* Y copying */
+    memcpy(outy, inyuv, outYsize);
+
+    /* U & V copying */
+    uint32_t *inyuv_4 = (uint32_t *) (inyuv + outYsize);
+    for (int32_t i = height >> 1; i > 0; --i) {
+        for (int32_t j = width >> 2; j > 0; --j) {
+            uint32_t temp = *inyuv_4++;
+            uint32_t tempU = temp & 0xFF;
+            tempU = tempU | ((temp >> 8) & 0xFF00);
+
+            uint32_t tempV = (temp >> 8) & 0xFF;
+            tempV = tempV | ((temp >> 16) & 0xFF00);
+
+            // Flip U and V
+            *outcb++ = tempV;
+            *outcr++ = tempU;
+        }
+    }
+}
+
+M4vH263Encoder::M4vH263Encoder(
+        const sp<MediaSource>& source,
+        const sp<MetaData>& meta)
+    : mSource(source),
+      mMeta(meta),
+      mNumInputFrames(-1),
+      mNextModTimeUs(0),
+      mStarted(false),
+      mInputBuffer(NULL),
+      mInputFrameData(NULL),
+      mGroup(NULL) {
+
+    LOGV("Construct software M4vH263Encoder");
+
+    mHandle = new tagvideoEncControls;
+    memset(mHandle, 0, sizeof(tagvideoEncControls));
+
+    mInitCheck = initCheck(meta);
+}
+
+M4vH263Encoder::~M4vH263Encoder() {
+    LOGV("Destruct software M4vH263Encoder");
+    if (mStarted) {
+        stop();
+    }
+
+    delete mEncParams;
+    delete mHandle;
+}
+
+status_t M4vH263Encoder::initCheck(const sp<MetaData>& meta) {
+    LOGV("initCheck");
+    CHECK(meta->findInt32(kKeyWidth, &mVideoWidth));
+    CHECK(meta->findInt32(kKeyHeight, &mVideoHeight));
+    CHECK(meta->findInt32(kKeySampleRate, &mVideoFrameRate));
+    CHECK(meta->findInt32(kKeyBitRate, &mVideoBitRate));
+
+    // XXX: Add more color format support
+    CHECK(meta->findInt32(kKeyColorFormat, &mVideoColorFormat));
+    if (mVideoColorFormat != OMX_COLOR_FormatYUV420Planar) {
+        if (mVideoColorFormat != OMX_COLOR_FormatYUV420SemiPlanar) {
+            LOGE("Color format %d is not supported", mVideoColorFormat);
+            return BAD_VALUE;
+        }
+        // Allocate spare buffer only when color conversion is needed.
+        // Assume the color format is OMX_COLOR_FormatYUV420SemiPlanar.
+        mInputFrameData =
+            (uint8_t *) malloc((mVideoWidth * mVideoHeight * 3 ) >> 1);
+        CHECK(mInputFrameData);
+    }
+
+    // XXX: Remove this restriction
+    if (mVideoWidth % 16 != 0 || mVideoHeight % 16 != 0) {
+        LOGE("Video frame size %dx%d must be a multiple of 16",
+            mVideoWidth, mVideoHeight);
+        return BAD_VALUE;
+    }
+
+    mEncParams = new tagvideoEncOptions;
+    memset(mEncParams, 0, sizeof(tagvideoEncOptions));
+    if (!PVGetDefaultEncOption(mEncParams, 0)) {
+        LOGE("Failed to get default encoding parameters");
+        return BAD_VALUE;
+    }
+
+    // Need to know which role the encoder is in.
+    // XXX: Set the mode proper for other types of applications
+    //      like streaming or video conference
+    const char *mime;
+    CHECK(meta->findCString(kKeyMIMEType, &mime));
+    CHECK(!strcmp(mime, MEDIA_MIMETYPE_VIDEO_MPEG4) ||
+          !strcmp(mime, MEDIA_MIMETYPE_VIDEO_H263));
+    if (!strcmp(mime, MEDIA_MIMETYPE_VIDEO_MPEG4)) {
+        mEncParams->encMode = COMBINE_MODE_WITH_ERR_RES;
+    } else {
+        mEncParams->encMode = H263_MODE;
+    }
+    mEncParams->encWidth[0] = mVideoWidth;
+    mEncParams->encHeight[0] = mVideoHeight;
+    mEncParams->encFrameRate[0] = mVideoFrameRate;
+    mEncParams->rcType = VBR_1;
+    mEncParams->vbvDelay = (float)5.0;
+
+    // Set profile and level
+    // If profile and level setting is not correct, failure
+    // is reported when the encoder is initialized.
+    mEncParams->profile_level = CORE_PROFILE_LEVEL2;
+    int32_t profileLevel;
+    if (meta->findInt32(kKeyVideoLevel, &profileLevel)) {
+        mEncParams->profile_level = (ProfileLevelType)profileLevel;
+    }
+
+    mEncParams->packetSize = 32;
+    mEncParams->rvlcEnable = PV_OFF;
+    mEncParams->numLayers = 1;
+    mEncParams->timeIncRes = 1000;
+    mEncParams->tickPerSrc = mEncParams->timeIncRes / mVideoFrameRate;
+
+    mEncParams->bitRate[0] = mVideoBitRate;
+    mEncParams->iQuant[0] = 15;
+    mEncParams->pQuant[0] = 12;
+    mEncParams->quantType[0] = 0;
+    mEncParams->noFrameSkipped = PV_OFF;
+
+    // Set IDR frame refresh interval
+    int32_t iFramesIntervalSec;
+    CHECK(meta->findInt32(kKeyIFramesInterval, &iFramesIntervalSec));
+    if (iFramesIntervalSec < 0) {
+        mEncParams->intraPeriod = -1;
+    } else if (iFramesIntervalSec == 0) {
+        mEncParams->intraPeriod = 1;  // All I frames
+    } else {
+        mEncParams->intraPeriod =
+            (iFramesIntervalSec * mVideoFrameRate);
+    }
+
+    mEncParams->numIntraMB = 0;
+    mEncParams->sceneDetect = PV_ON;
+    mEncParams->searchRange = 16;
+    mEncParams->mv8x8Enable = PV_OFF;
+    mEncParams->gobHeaderInterval = 0;
+    mEncParams->useACPred = PV_ON;
+    mEncParams->intraDCVlcTh = 0;
+
+    mFormat = new MetaData;
+    mFormat->setInt32(kKeyWidth, mVideoWidth);
+    mFormat->setInt32(kKeyHeight, mVideoHeight);
+    mFormat->setInt32(kKeyBitRate, mVideoBitRate);
+    mFormat->setInt32(kKeySampleRate, mVideoFrameRate);
+    mFormat->setInt32(kKeyColorFormat, mVideoColorFormat);
+
+    mFormat->setCString(kKeyMIMEType, mime);
+    mFormat->setCString(kKeyDecoderComponent, "M4vH263Encoder");
+    return OK;
+}
+
+status_t M4vH263Encoder::start(MetaData *params) {
+    LOGV("start");
+    if (mInitCheck != OK) {
+        return mInitCheck;
+    }
+
+    if (mStarted) {
+        LOGW("Call start() when encoder already started");
+        return OK;
+    }
+
+    if (!PVInitVideoEncoder(mHandle, mEncParams)) {
+        LOGE("Failed to initialize the encoder");
+        return UNKNOWN_ERROR;
+    }
+
+    mGroup = new MediaBufferGroup();
+    int32_t maxSize;
+    if (!PVGetMaxVideoFrameSize(mHandle, &maxSize)) {
+        maxSize = 256 * 1024;  // Magic #
+    }
+    LOGV("Max output buffer size: %d", maxSize);
+    mGroup->add_buffer(new MediaBuffer(maxSize));
+
+    mSource->start(params);
+    mNumInputFrames = -1;  // 1st frame contains codec specific data
+    mStarted = true;
+
+    return OK;
+}
+
+status_t M4vH263Encoder::stop() {
+    LOGV("stop");
+    if (!mStarted) {
+        LOGW("Call stop() when encoder has not started");
+        return OK;
+    }
+
+    if (mInputBuffer) {
+        mInputBuffer->release();
+        mInputBuffer = NULL;
+    }
+
+    if (mGroup) {
+        delete mGroup;
+        mGroup = NULL;
+    }
+
+    if (mInputFrameData) {
+        delete mInputFrameData;
+        mInputFrameData = NULL;
+    }
+
+    CHECK(PVCleanUpVideoEncoder(mHandle));
+
+    mSource->stop();
+    mStarted = false;
+
+    return OK;
+}
+
+sp<MetaData> M4vH263Encoder::getFormat() {
+    LOGV("getFormat");
+    return mFormat;
+}
+
+status_t M4vH263Encoder::read(
+        MediaBuffer **out, const ReadOptions *options) {
+
+    CHECK(!options);
+    *out = NULL;
+
+    MediaBuffer *outputBuffer;
+    CHECK_EQ(OK, mGroup->acquire_buffer(&outputBuffer));
+    uint8_t *outPtr = (uint8_t *) outputBuffer->data();
+    int32_t dataLength = outputBuffer->size();
+
+    // Output codec specific data
+    if (mNumInputFrames < 0) {
+        if (!PVGetVolHeader(mHandle, outPtr, &dataLength, 0)) {
+            LOGE("Failed to get VOL header");
+            return UNKNOWN_ERROR;
+        }
+        LOGV("Output VOL header: %d bytes", dataLength);
+        outputBuffer->meta_data()->setInt32(kKeyIsCodecConfig, 1);
+        outputBuffer->set_range(0, dataLength);
+        *out = outputBuffer;
+        ++mNumInputFrames;
+        return OK;
+    }
+
+    // Ready for accepting an input video frame
+    if (OK != mSource->read(&mInputBuffer, options)) {
+        LOGE("Failed to read from data source");
+        outputBuffer->release();
+        return UNKNOWN_ERROR;
+    }
+    int64_t timeUs;
+    CHECK(mInputBuffer->meta_data()->findInt64(kKeyTime, &timeUs));
+    if (mNextModTimeUs > timeUs) {
+        LOGV("mNextModTimeUs %lld > timeUs %lld", mNextModTimeUs, timeUs);
+        outputBuffer->set_range(0, 0);
+        *out = outputBuffer;
+        mInputBuffer->release();
+        mInputBuffer = NULL;
+        return OK;
+    }
+
+    // Color convert to OMX_COLOR_FormatYUV420Planar if necessary
+    outputBuffer->meta_data()->setInt64(kKeyTime, timeUs);
+    uint8_t *inPtr = (uint8_t *) mInputBuffer->data();
+    if (mVideoColorFormat != OMX_COLOR_FormatYUV420Planar) {
+        CHECK(mInputFrameData);
+        CHECK(mVideoColorFormat == OMX_COLOR_FormatYUV420SemiPlanar);
+        ConvertYUV420SemiPlanarToYUV420Planar(
+            inPtr, mInputFrameData, mVideoWidth, mVideoHeight);
+        inPtr = mInputFrameData;
+    }
+    CHECK(inPtr != NULL);
+
+    // Ready for encoding a video frame
+    VideoEncFrameIO vin, vout;
+    vin.height = ((mVideoHeight + 15) >> 4) << 4;
+    vin.pitch  = ((mVideoWidth  + 15) >> 4) << 4;
+    vin.timestamp = (timeUs + 500) / 1000; // in ms
+    vin.yChan = inPtr;
+    vin.uChan = vin.yChan + vin.height * vin.pitch;
+    vin.vChan = vin.uChan + ((vin.height * vin.pitch) >> 2);
+    unsigned long modTimeMs = 0;
+    int32_t nLayer = 0;
+    MP4HintTrack hintTrack;
+    if (!PVEncodeVideoFrame(mHandle, &vin, &vout,
+            &modTimeMs, outPtr, &dataLength, &nLayer) ||
+        !PVGetHintTrack(mHandle, &hintTrack)) {
+        LOGE("Failed to encode frame or get hink track at frame %lld",
+            mNumInputFrames);
+        outputBuffer->release();
+        mInputBuffer->release();
+        mInputBuffer = NULL;
+        return UNKNOWN_ERROR;
+    }
+    CHECK_EQ(NULL, PVGetOverrunBuffer(mHandle));
+    if (hintTrack.CodeType == 0) {  // I-frame serves as sync frame
+        outputBuffer->meta_data()->setInt32(kKeyIsSyncFrame, 1);
+    }
+
+    ++mNumInputFrames;
+    mNextModTimeUs = modTimeMs * 1000LL;
+    outputBuffer->set_range(0, dataLength);
+    *out = outputBuffer;
+    mInputBuffer->release();
+    mInputBuffer = NULL;
+    return OK;
+}
+
+void M4vH263Encoder::signalBufferReturned(MediaBuffer *buffer) {
+}
+
+}  // namespace android
diff --git a/media/libstagefright/codecs/m4v_h263/enc/include/cvei.h b/media/libstagefright/codecs/m4v_h263/enc/include/cvei.h
new file mode 100644
index 0000000..18e54dc
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/include/cvei.h
@@ -0,0 +1,437 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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.
+ * -------------------------------------------------------------------
+ */
+/*********************************************************************************/
+/*  File: cvei.h                                                                */
+/*  Purpose:                                                                    */
+/*  Date:                                                                       */
+/*  Revision History:                                                           */
+/** @introduction   Common Video Encoder Interface (CVEI) is intended to be used by
+    application developers who want to create a multimedia application with video
+    encoding feature. CVEI is designed such that new video encoder algorithms or
+    modules can be plugged in seamlessly without user interaction. In other words,
+    any changes to the CVEI library are transparent to the users. Users can still
+    use the same set of APIs for new encoding tools.
+
+    @requirement    CVEI will take an input frame in one of several format supported
+    by PV and encode it to an MPEG4 bitstream. It will also return a reconstructed
+    image in YUV 4:2:0 format. Currently the input format supported are YUV 4:2:0,
+    RGB24 and UYVY 4:2:2.
+
+    CVEI is designed such that it is simple to use. It should hides implementation
+    dependency  from the users. In this version, we decided that the operation will
+    be synchronous, i.e., the encoding will be a blocked call. Asynchronous operation
+    will be in the level above CVEI, i.e., in Author Engine Video Module which will
+    take care of capturing device as well.
+
+    @brief  The following classes are used to interface with codecs. Their names
+    are CPVxxxVideoEncoder where xxx is codec specific such as MPEG4, H263, H26L,
+    etc. All of them are subclasses of CPVCommonVideoEncoder.
+*/
+/*********************************************************************************/
+
+#ifndef __CVEI_H
+#define __CVEI_H
+
+#include "oscl_scheduler_ao.h"
+#include "oscl_base.h"
+#include "mp4enc_api.h" /* for MP4HintTrack */
+
+#define MAX_LAYER 2
+
+/** General returned values. */
+enum TCVEI_RETVAL
+{
+    ECVEI_SUCCESS,
+    ECVEI_FAIL,
+    ECVEI_FLUSH,
+    ECVEI_MORE_OUTPUT
+} ;
+
+/** Returned events with the callback function. */
+enum TCVEI_EVENT
+{
+    /** Called when a packet or a frame of output bitstream is ready. */
+    ECVEI_BUFFER_READY,
+
+    /** Called when the last packet of a frame of output bitstream is ready. */
+    ECVEI_FRAME_DONE,
+
+    /** Called when no buffers is available for output bitstream. A buffer can be added thru AddBuffer API. */
+    ECVEI_NO_BUFFERS,
+
+    /** Called when there is an error with the encoding operation. */
+    ECVEI_ERROR
+};
+
+/** Contains supported input format */
+enum TPVVideoFormat
+{
+    ECVEI_RGB24,
+    ECVEI_RGB12,
+    ECVEI_YUV420,
+    ECVEI_UYVY,
+    ECVEI_YUV420SEMIPLANAR
+};
+
+/** Type of contents for optimal encoding mode. */
+enum TPVContentType
+{
+    /** Content is to be streamed in real-time. */
+    ECVEI_STREAMING,
+
+    /** Content is to be downloaded and playbacked later.*/
+    ECVEI_DOWNLOAD,
+
+    /** Content is to be 3gpp baseline compliant. */
+    ECVEI_H263
+};
+
+/** Rate control type. */
+enum TMP4RateControlType
+{
+    /** Constant quality, variable bit rate, fixed quantization level. */
+    ECONSTANT_Q,
+
+    /** Short-term constant bit rate control. */
+    ECBR_1,
+
+    /** Long-term constant bit rate control. */
+    EVBR_1
+};
+
+/** Targeted profile and level to encode. */
+enum TPVM4VProfileLevel
+{
+    /* Non-scalable profile */
+    ECVEI_SIMPLE_LEVEL0 = 0,
+    ECVEI_SIMPLE_LEVEL1,
+    ECVEI_SIMPLE_LEVEL2,
+    ECVEI_SIMPLE_LEVEL3,
+    ECVEI_CORE_LEVEL1,
+    ECVEI_CORE_LEVEL2,
+
+    /* Scalable profile */
+    ECVEI_SIMPLE_SCALABLE_LEVEL0 = 6,
+    ECVEI_SIMPLE_SCALABLE_LEVEL1,
+    ECVEI_SIMPLE_SCALABLE_LEVEL2,
+
+    ECVEI_CORE_SCALABLE_LEVEL1 = 10,
+    ECVEI_CORE_SCALABLE_LEVEL2,
+    ECVEI_CORE_SCALABLE_LEVEL3
+};
+
+/** This structure contains encoder settings. */
+struct TPVVideoEncodeParam
+{
+    /** Specifies an  ID that will be used to specify this encoder while returning
+    the bitstream in asynchronous mode. */
+    uint32              iEncodeID;
+
+    /** Specifies whether base only (iNumLayer = 1) or base + enhancement layer
+    (iNumLayer =2 ) is to be used. */
+    int32               iNumLayer;
+
+    /** Specifies the width in pixels of the encoded frames. IFrameWidth[0] is for
+    base layer and iFrameWidth[1] is for enhanced layer. */
+    int                 iFrameWidth[MAX_LAYER];
+
+    /** Specifies the height in pixels of the encoded frames. IFrameHeight[0] is for
+    base layer and iFrameHeight[1] is for enhanced layer. */
+    int                 iFrameHeight[MAX_LAYER];
+
+    /** Specifies the cumulative bit rate in bit per second. IBitRate[0] is for base
+    layer and iBitRate[1] is for base+enhanced layer.*/
+    int                 iBitRate[MAX_LAYER];
+
+    /** Specifies the cumulative frame rate in frame per second. IFrameRate[0] is for
+    base layer and iFrameRate[1] is for base+enhanced layer. */
+    float               iFrameRate[MAX_LAYER];
+
+    /** Specifies the picture quality factor on the scale of 1 to 10. It trades off
+    the picture quality with the frame rate. Higher frame quality means lower frame rate.
+    Lower frame quality for higher frame rate.*/
+    int32               iFrameQuality;
+
+    /** Enable the use of iFrameQuality to determine the frame rate. If it is false,
+    the encoder will try to meet the specified frame rate regardless of the frame quality.*/
+    bool                iEnableFrameQuality;
+
+    /** Specifies the maximum number of P-frames between 2 INTRA frames. An INTRA mode is
+    forced to a frame once this interval is reached. When there is only one I-frame is present
+    at the beginning of the clip, iIFrameInterval should be set to -1. */
+    int32               iIFrameInterval;
+
+    /** According to iIFrameInterval setting, the minimum number of intra MB per frame is
+    optimally calculated for error resiliency. However, when iIFrameInterval is set to -1,
+    iNumIntraMBRefresh must be specified to guarantee the minimum number of intra
+    macroblocks per frame.*/
+    uint32              iNumIntraMBRefresh;
+
+    /** Specifies the VBV buffer size which determines the end-to-end delay between the
+    encoder and the decoder.  The size is in unit of seconds. For download application,
+    the buffer size can be larger than the streaming application. For 2-way application,
+    this buffer shall be kept minimal. For a special case, in VBR mode, iBufferDelay will
+    be set to -1 to allow buffer underflow. */
+    float               iBufferDelay;
+
+    /** Specifies the type of the access whether it is streaming, CVEI_STREAMING
+    (data partitioning mode) or download, CVEI_DOWNLOAD (combined mode).*/
+    TPVContentType      iContentType;
+
+    /** Specifies the rate control algorithm among one of the following constant Q,
+    CBR and VBR.  The structure TMP4RateControlType is defined below.*/
+    TMP4RateControlType iRateControlType;
+
+    /** Specifies high quality but also high complexity mode for rate control. */
+    bool                iRDOptimal;
+
+    /** Specifies the initial quantization parameter for the first I-frame. If constant Q
+    rate control is used, this QP will be used for all the I-frames. This number must be
+    set between 1 and 31, otherwise, Initialize() will fail. */
+    int                 iIquant[2];
+
+    /** Specifies the initial quantization parameter for the first P-frame. If constant Q
+    rate control is used, this QP will be used for all the P-frames. This number must be
+    set between 1 and 31, otherwise, Initialize() will fail. */
+    int                 iPquant[2];
+
+    /** Specifies the initial quantization parameter for the first B-frame. If constant Q
+    rate control is used, this QP will be used for all the B-frames. This number must be
+    set between 1 and 31, otherwise, Initialize() will fail. */
+    int                 iBquant[2];
+
+    /** Specifies the search range in pixel unit for motion vector. The range of the
+    motion vector will be of dimension [-iSearchRange.5, +iSearchRange.0]. */
+    int32               iSearchRange;
+
+    /** Specifies the use of 8x8 motion vectors. */
+    bool                iMV8x8;
+
+    /** Specifies the use of half-pel motion vectors. */
+    bool                iMVHalfPel;
+
+    /** Specifies automatic scene detection where I-frame will be used the the first frame
+    in a new scene. */
+    bool                iSceneDetection;
+
+    /** Specifies the packet size in bytes which represents the number of bytes between two resync markers.
+    For ECVEI_DOWNLOAD and ECVEI_H263, if iPacketSize is set to 0, there will be no resync markers in the bitstream.
+    For ECVEI_STREAMING is parameter must be set to a value greater than 0.*/
+    uint32              iPacketSize;
+
+    /** Specifies whether the current frame skipping decision is allowed after encoding
+    the current frame. If there is no memory of what has been coded for the current frame,
+    iNoCurrentSkip has to be on. */
+    bool                iNoCurrentSkip;
+
+    /** Specifies that no frame skipping is allowed. Frame skipping is a tool used to
+    control the average number of bits spent to meet the target bit rate. */
+    bool                iNoFrameSkip;
+
+    /** Specifies the duration of the clip in millisecond.*/
+    int32               iClipDuration;
+
+    /** Specifies the profile and level used to encode the bitstream. When present,
+    other settings will be checked against the range allowable by this target profile
+    and level. Fail may be returned from the Initialize call. */
+    TPVM4VProfileLevel  iProfileLevel;
+
+    /** Specifies FSI Buffer input */
+    uint8*              iFSIBuff;
+
+    /** Specifies FSI Buffer Length */
+    int             iFSIBuffLength;
+
+
+};
+
+
+/** Structure for input format information */
+struct TPVVideoInputFormat
+{
+    /** Contains the width in pixels of the input frame. */
+    int32           iFrameWidth;
+
+    /** Contains the height in pixels of the input frame. */
+    int32           iFrameHeight;
+
+    /** Contains the input frame rate in the unit of frame per second. */
+    float           iFrameRate;
+
+    /** Contains Frame Orientation. Used for RGB input. 1 means Bottom_UP RGB, 0 means Top_Down RGB, -1 for video formats other than RGB*/
+    int             iFrameOrientation;
+
+    /** Contains the format of the input video, e.g., YUV 4:2:0, UYVY, RGB24, etc. */
+    TPVVideoFormat  iVideoFormat;
+};
+
+
+/** Contains the input data information */
+struct TPVVideoInputData
+{
+    /** Pointer to an input frame buffer in input source format.*/
+    uint8       *iSource;
+
+    /** The corresponding time stamp of the input frame. */
+    uint32      iTimeStamp;
+};
+
+/** Contains the output data information */
+struct TPVVideoOutputData
+{
+    /** Pointer to the reconstructed frame buffer in YUV 4:2:0 domain. */
+    uint8           *iFrame;
+
+    /** The number of layer encoded, 0 for base, 1 for enhanced. */
+    int32           iLayerNumber;
+
+    /** Pointer to the encoded bitstream buffer. */
+    uint8           *iBitStream;
+
+    /** The size in bytes of iBStream. */
+    int32           iBitStreamSize;
+
+    /** The time stamp of the encoded frame according to the bitstream. */
+    uint32          iVideoTimeStamp;
+
+    /** The time stamp of the encoded frame as given before the encoding. */
+    uint32          iExternalTimeStamp;
+
+    /** The hint track information. */
+    MP4HintTrack    iHintTrack;
+};
+
+/** An observer class for callbacks to report the status of the CVEI */
+class MPVCVEIObserver
+{
+    public:
+        /** The callback funtion with aEvent being one of TCVEIEvent enumeration. */
+        virtual void HandlePVCVEIEvent
+        (uint32 aId, uint32 aEvent, uint32 aParam1 = 0) = 0;
+        virtual ~MPVCVEIObserver() {}
+};
+
+/** This class is the base class for codec specific interface class.
+The users must maintain an instance of the codec specific class throughout
+the encoding session.
+*/
+class CommonVideoEncoder : public OsclTimerObject
+{
+    public:
+        /** Constructor for CVEI class. */
+        CommonVideoEncoder() : OsclTimerObject(OsclActiveObject::EPriorityNominal, "PVEncoder") {};
+
+        /** Initialization function to set the input video format and the
+        encoding parameters. This function returns CVEI_ERROR if there is
+        any errors. Otherwise, the function returns CVEI_SUCCESS.*/
+        virtual  TCVEI_RETVAL Initialize(TPVVideoInputFormat *aVidInFormat, TPVVideoEncodeParam *aEncParam) = 0;
+
+        /** Set the observer for asynchronous encoding mode. */
+        virtual  TCVEI_RETVAL SetObserver(MPVCVEIObserver *aObserver) = 0;
+
+        /** Add a buffer to the queue of output buffers for output bitstream in
+        asynchronous encoding mode. */
+        virtual  TCVEI_RETVAL AddBuffer(TPVVideoOutputData *aVidOut) = 0;
+
+        /** This function sends in an input video data structure containing a source
+        frame and the associated timestamp. The encoded bitstream will be returned by
+        observer callback.
+        The above 3 APIs only replace EncodeFrame() API. Other APIs such as initialization
+        and update parameters remain the same. */
+        virtual  TCVEI_RETVAL Encode(TPVVideoInputData *aVidIn) = 0;
+
+        /** This function returns the maximum VBV buffer size such that the
+            application can allocate a buffer that guarantees to fit one frame.*/
+        virtual  int32 GetBufferSize() = 0;
+
+        /** This function returns the VOL header part (starting from the VOS header)
+        of the encoded bitstream. This function must be called after Initialize.
+        The output is written to the memory (volHeader) allocated by the users.*/
+        virtual  TCVEI_RETVAL GetVolHeader(uint8 *volHeader, int32 *size, int32 layer) = 0;
+
+        /** This function sends in an input video data structure containing a source
+        frame and the associated timestamp. It returns an output video data structure
+        containing coded bit stream, reconstructed frame in YUV 4:2:0 (can be changed
+        to source format) and the timestamp associated with the coded frame.
+        The input timestamp may not correspond to the output timestamp. User can send
+        an input structure in without getting any encoded data back or getting an encoded
+        frame in the past. This function returns ECVEI_ERROR if there is any errors.
+        Otherwise, the function returns ECVEI_SUCCESS.
+        In case of Overrun Buffer usage, it is possible that return value is ECVEI_MORE_OUTPUT
+        which indicates that frame cannot fit in the current buffer*/
+        virtual  TCVEI_RETVAL EncodeFrame(TPVVideoInputData  *aVidIn, TPVVideoOutputData *aVidOut, int *aRemainingBytes
+#ifdef PVAUTHOR_PROFILING
+                                          , void *aParam1 = 0
+#endif
+                                         ) = 0;
+
+        /** Before the termination of the encoding process, the users have to query
+        whether there are any encoded frame pending inside the CVEI. The returned value
+        will indicate whether there are more frames to be flushed (ECVEI_FLUSH).
+        FlushOutput has to be called until there are no more frames, i.e., it returns
+        ECVEI_SUCCESS. This function may be called during the encoding operation if
+        there is no input frame and the application does not want to waste the time
+        waiting for input frame. It can call this function to flush encoded frame
+        out of the memory. */
+        virtual  TCVEI_RETVAL FlushOutput(TPVVideoOutputData *aVidOut) = 0;
+
+        /** This function cleanup the CVEI allocated resources. */
+        virtual  TCVEI_RETVAL Terminate() = 0;
+
+        /**This function dynamically changes the target bit rate of the encoder
+        while encoding. aBitRate[n] is the new accumulate target bit rate of layer n.
+        Successful update is returned with ECVEI_SUCCESS.*/
+        virtual  TCVEI_RETVAL UpdateBitRate(int32 aNumLayer, int32 *aBitRate) = 0;
+
+        /** This function dynamically changes the target frame rate of the encoder
+        while encoding. aFrameRate[n] is the new accumulate target frame rate of
+        layer n. Successful update is returned with ECVEI_SUCCESS. */
+        virtual  TCVEI_RETVAL UpdateFrameRate(int32 aNumLayer, float *aFrameRate) = 0;
+
+        /** This function dynamically changes the I-Vop update interval while
+        encoding to a new value, aIFrameInterval. */
+        virtual  TCVEI_RETVAL UpdateIFrameInterval(int32 aIFrameInterval) = 0;
+
+        /** This function forces an I-Vop mode to the next frame to be encoded. */
+        virtual  TCVEI_RETVAL IFrameRequest() = 0;
+
+        /** This function returns the input width of a specific layer
+        (not necessarily multiple of 16). */
+        virtual  int32 GetEncodeWidth(int32 aLayer) = 0;
+
+        /** This function returns the input height of a specific layer
+        (not necessarily multiple of 16). */
+        virtual  int32 GetEncodeHeight(int32 aLayer) = 0;
+
+        /** This function returns the target encoded frame rate of a specific layer. */
+        virtual  float GetEncodeFrameRate(int32 aLayer) = 0;
+    protected:
+        virtual void Run(void) = 0;
+        virtual void DoCancel(void) = 0;
+        /* internal enum */
+        enum TCVEIState
+        {
+            EIdle,
+            EEncode
+        };
+
+        TCVEIState  iState;
+        uint32      iId;
+};
+
+#endif
diff --git a/media/libstagefright/codecs/m4v_h263/enc/include/mp4enc_api.h b/media/libstagefright/codecs/m4v_h263/enc/include/mp4enc_api.h
new file mode 100644
index 0000000..a54fd8b
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/include/mp4enc_api.h
@@ -0,0 +1,454 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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 _MP4ENC_API_H_
+#define _MP4ENC_API_H_
+
+#include <string.h>
+
+#ifndef _PV_TYPES_
+#define _PV_TYPES_
+typedef unsigned char UChar;
+typedef char Char;
+typedef unsigned int UInt;
+typedef int Int;
+typedef unsigned short UShort;
+typedef short Short;
+typedef unsigned int Bool;
+typedef unsigned long ULong;
+
+#define PV_CODEC_INIT  0
+#define PV_CODEC_STOP  1
+#endif
+
+#define PV_TRUE  1
+#define PV_FALSE 0
+
+typedef enum
+{
+    SHORT_HEADER,
+    SHORT_HEADER_WITH_ERR_RES,
+    H263_MODE,
+    H263_MODE_WITH_ERR_RES,
+    DATA_PARTITIONING_MODE,
+    COMBINE_MODE_NO_ERR_RES,
+    COMBINE_MODE_WITH_ERR_RES
+
+} MP4EncodingMode;
+
+typedef enum
+{
+    CONSTANT_Q,
+    CBR_1,
+    VBR_1,
+    CBR_2,
+    VBR_2,
+    CBR_LOWDELAY
+} MP4RateControlType;
+
+typedef enum
+{
+    PASS1,
+    PASS2
+} PassNum;
+
+typedef enum
+{
+    PV_OFF,
+    PV_ON
+} ParamEncMode;
+
+
+/* {SPL0, SPL1, SPL2, SPL3, CPL1, CPL2, CPL2, CPL2} , SPL0: Simple Profile@Level0 , CPL1: Core Profile@Level1 */
+/* {SSPL0, SSPL1, SSPL2, SSPL2, CSPL1, CSPL2, CSPL3, CSPL3} , SSPL0: Simple Scalable Profile@Level0, CPL1: Core Scalable Profile@Level1 */
+
+typedef enum
+{
+    /* Non-scalable profile */
+    SIMPLE_PROFILE_LEVEL0 = 0,
+    SIMPLE_PROFILE_LEVEL1,
+    SIMPLE_PROFILE_LEVEL2,
+    SIMPLE_PROFILE_LEVEL3,
+    CORE_PROFILE_LEVEL1,
+    CORE_PROFILE_LEVEL2,
+
+    /* Scalable profile */
+    SIMPLE_SCALABLE_PROFILE_LEVEL0 = 6,
+    SIMPLE_SCALABLE_PROFILE_LEVEL1,
+    SIMPLE_SCALABLE_PROFILE_LEVEL2,
+
+    CORE_SCALABLE_PROFILE_LEVEL1 = 10,
+    CORE_SCALABLE_PROFILE_LEVEL2,
+    CORE_SCALABLE_PROFILE_LEVEL3
+
+} ProfileLevelType;
+
+
+typedef struct tagMP4HintTrack
+{
+    UChar   MTB;
+    UChar   LayerID;
+    UChar   CodeType;
+    UChar   RefSelCode;
+} MP4HintTrack;
+
+typedef struct tagvideoEncControls
+{
+    void            *videoEncoderData;
+    Int             videoEncoderInit;
+} VideoEncControls;
+
+
+typedef struct tagvideoEncFrameIO
+{
+    UChar   *yChan; /* pointer to Y */
+    UChar   *uChan; /* pointer to U */
+    UChar   *vChan; /* pointer to V */
+    Int     height; /* height for Y */
+    Int     pitch;  /* stride  for Y */
+    ULong   timestamp; /* modulo timestamp in millisecond*/
+
+}   VideoEncFrameIO  ;
+
+/**
+@brief  Encoding options structure */
+typedef struct tagvideoEncOptions
+{
+    /** @brief Sets the encoding mode, defined by the above enumaration. If there are conflicts between the encoding mode
+    *   and subsequent encoding options, encoding mode take precedent over encoding options. */
+    MP4EncodingMode     encMode;
+
+    /** @brief Sets the number of bytes per packet, only used in DATA_PARTITIONING_MODE or COMBINE_MODE_WITH_ERR_RES mode.
+    *           The resync marker will be inserted as often as the size of the packet.*/
+    Int                 packetSize;
+
+    /** @brief Selects MPEG-4/H.263 profile and level, if specified other encoding options must conform with it. */
+    ProfileLevelType    profile_level;
+
+    /** @brief Enables reversible variable length code (RVLC) mode. Normally it is set to PV_OFF.*/
+    ParamEncMode        rvlcEnable;
+
+    /** @brief Set the frequency of GOB header interval */
+    Int                 gobHeaderInterval;
+
+    /** @brief Sets the number of bitstream layers: 1 is base only: 2 is base + enhancement */
+    Int                 numLayers;
+
+    /** @brief Sets the number of ticks per second used for timing information encoded in MPEG4 bitstream.*/
+    Int                 timeIncRes;
+
+    /** @brief Sets the number of ticks in time increment resolution between 2 source frames (equivalent to source frame rate). */
+    Int                 tickPerSrc;
+
+    /** @brief Specifies encoded heights in pixels, height[n] represents the n-th layer's height. */
+    Int                 encHeight[2];
+
+    /** @brief Specifies encoded widths in pixels, width[n] represents the n-th layer's width.*/
+    Int                 encWidth[2];
+
+    /** @brief Specifies target frame rates in frames per second, frameRate[n] represents the n-th layer's target frame rate.*/
+    float               encFrameRate[2];
+
+    /** @brief Specifies target bit rates in bits per second unit, bitRate[n] represents the n-th layer's target bit rate. */
+    Int                 bitRate[2];
+
+    /** @brief Specifies default quantization parameters for I-Vop. Iquant[n] represents the n-th layer default quantization parameter. The default is Iquant[0]=12.*/
+    Int                 iQuant[2];
+
+    /** @brief Specifies default quantization parameters for P-Vop. Pquant[n] represents the n-th layer default quantization parameter. The default is Pquant[0]=10.*/
+    Int                 pQuant[2];
+
+    /** @brief  specifies quantization mode (H263 mode or MPEG mode) of the encoded base and enhance layer (if any).
+    *           In Simple and Simple Scalable profile, we use only H263 mode.*/
+    Int                 quantType[2];
+
+    /** @brief Sets rate control algorithm, one of (CONSTANT_Q, CBR_1, or VBR_1).
+    *           CONSTANT_Q uses the default quantization values to encode the sequence.
+    *           CBR_1 (constant bit rate) controls the output at a desired bit rate
+    *           VBR_1 (variable bit rate) gives better picture quality at the expense of bit rate fluctuation
+    *           Note:   type=CONSTANT_Q produces sequences with arbitrary bit rate.
+    *                   type=CBR_1 produces sequences suitable for streaming.
+    *                   type=VBR_1 produces sequences suitable for download. */
+    MP4RateControlType  rcType;
+
+    /** @brief  Sets the VBV buffer size (in the unit of second delay) used to prevent buffer overflow and underflow
+    *           on the decoder side. This function is redundant to PVSetVBVSize. Either one of them is used at a time. */
+    float               vbvDelay;
+
+    /** @brief  Specifies whether frame skipping is permitted or not. When rate control type is set to CONSTANT_Q
+    *           frame skipping is automatically banned.  In CBR_1 and VBR_1 rate control, frame skipping is allowed by default.
+    *           However, users can force no frame skipping with this flag, but buffer constraint may be violated.*/
+    ParamEncMode        noFrameSkipped;
+
+    /** @brief Sets the maximum number of P-frames between two I-frames. I-frame mode is periodically forced
+    *           if no I-frame is encoded after the specified period to add error resiliency and help resynchronize in case of errors.
+    *           If scene change detection can add additional I-frame if new scenes are detected.
+    *           intraPeriod is the I frame interval in terms of second.
+    *           intraPeriod =0 indicates I-frame encoding only;
+    *           intraPeriod = -1  indicates I-frame followed by all P-frames; (default)
+    *           intraPeriod = N, indicates the number of P-frames between 2 I-frames.*/
+    Int                 intraPeriod;
+
+
+    /** @brief  Specifies the number Intra MBs to be refreshed in a P-frame. */
+    Int                 numIntraMB;
+
+    /**
+    *   @brief  Specifies whether the scene change detection (SCD) is enabled or disabled.
+    *           With SCD enable, when a new scene is detected, I-Vop mode will be used for the first frame of
+    *           the new scene resulting in better picture quality. An insertion of an I-VOP resets the intraPeriod
+    *           specified by the IntraPeriodAPI().*/
+    ParamEncMode        sceneDetect;
+
+    /** @brief  Specifies the search range of motion estimation search.  Larger value implies
+    *           larger search range, better motion vector match, but more complexity.
+    *           If searchRange=n, the motion vector search is in the range of [-n,n-1] pixels.
+    *           If half-pel  mode is on, the range is [-n, (n-1)+1/2] pixels. The default value is 16.*/
+    Int                 searchRange;
+
+    /** @brief  Turns on/off 8x8 block motion estimation and compensation.
+    *           If on, four motion vectors may be used for motion estimation and compensation of a macroblock,
+    *           otherwise one motion vector per macroblock is used. When the 8x8 MV is off, the total encoding complexity
+    *           is less but the image quality is also worse. Therefore, it can be used in complexity limited environment.*/
+    ParamEncMode        mv8x8Enable;
+
+
+    /** @brief Set the threshold for using intra DC VLC.
+    *           Value must range from 0-7.*/
+    Int                 intraDCVlcTh;
+
+    /** @brief This flag turns on the use of AC prediction */
+    Bool                useACPred;
+
+} VideoEncOptions;
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+    /* API's */
+    /* Always start with this one !!*/
+    /**
+    *   @brief  Gets default encoding options. This way users only have to set relevant encoding options and leave the one
+    *           they are unsure of.
+    *   @encOption  Pointer to VideoEncOption structure.
+    *   @encUseCase This value determines the set of default encoding options, for example, different encoding options
+    *            are assigned to streaming use-case as compared to download use-case. It can be project dependent too.
+    *   @return true for correct operation; false if error happens
+    */
+    OSCL_IMPORT_REF Bool PVGetDefaultEncOption(VideoEncOptions *encOption, Int encUseCase);
+
+    /**
+    *   @brief  Verifies the consistency of encoding parameters, allocates memory needed and set necessary internal variables.
+    *   @param  encCtrl is video encoder control structure that is always passed as input in all APIs
+    *   @return true for correct operation; false if error happens
+    */
+    OSCL_IMPORT_REF Bool    PVInitVideoEncoder(VideoEncControls *encCtrl, VideoEncOptions *encOption);
+
+    /* acquiring encoder info APIs */
+    /**
+    *   @brief  This function returns VOL header. It has to be called before the frame is encoded.  If so,
+    *           then the VOL Header is passed back to the application. Then all frames that are encoded do not contain the VOL Header.
+    *           If you do not call the API then the VOL Header is passed within the first frame that is encoded.
+    *           The behavior is unknown if it is called after the first frame is encoded. It is mainly used for MP4 file format authoring.
+    *   @param  encCtrl is video encoder control structure that is always passed as input in all APIs.
+    *   @param  volHeader is the Buffer for VOL header.
+    *   @param  size is the size of VOL header in bytes.
+    *   @param  layer is the layer of the requested VOL header.
+    *   @return true for correct operation; false if error happens.
+    */
+    OSCL_IMPORT_REF Bool    PVGetVolHeader(VideoEncControls *encCtrl, UChar *volHeader, Int *size, Int layer);
+
+    /**
+    *   @brief  This function returns the profile and level in H.263 coding when the encoding parameters are set
+    *   @param  encCtrl is video encoder control structure that is always passed as input in all APIs.
+    *   @param  profileID is the pointer of the profile ID. Right now we only support profile 0
+    *   @param  levelID is the pointer of the level ID that could be 10-70.
+    *   @return true for correct operation; false if error happens.
+    */
+    OSCL_IMPORT_REF Bool    PVGetH263ProfileLevelID(VideoEncControls *encCtrl, Int *profileID, Int *levelID);
+
+    /**
+    *   @brief  This function returns the profile and level of MPEG4 when the encoding parameters are set
+    *   @param  encCtrl is video encoder control structure that is always passed as input in all APIs.
+    *   @param  profile_level is the pointer of the profile enumeration
+    *   @param  nLayer is the index of the layer of interest
+    *   @return true for correct operation; false if error happens.
+    */
+    OSCL_IMPORT_REF Bool    PVGetMPEG4ProfileLevelID(VideoEncControls *encCtrl, Int *profile_level, Int nLayer);
+
+    /**
+    *   @brief  This function returns maximum frame size in bytes
+    *   @param  encCtrl is video encoder control structure that is always passed as input in all APIs
+    *   @param  maxVideoFrameSize is the pointer of the maximum frame size
+    *   @return true for correct operation; false if error happens
+    */
+    OSCL_IMPORT_REF Bool    PVGetMaxVideoFrameSize(VideoEncControls *encCtrl, Int *maxVideoFrameSize);
+
+#ifndef LIMITED_API
+    /**
+    *   @brief  This function returns the total amount of memory (in bytes) allocated by the encoder library.
+    *   @param  encCtrl is video encoder control structure that is always passed as input in all APIs
+    *   @return true for correct operation; false if error happens
+    */
+    OSCL_IMPORT_REF Int     PVGetEncMemoryUsage(VideoEncControls *encCtrl);
+
+    /**
+    *   @brief  This function is used by PVAuthor to get the size of the VBV buffer.
+    *   @param  encCtrl is video encoder control structure that is always passed as input in all APIs
+    *   @param  VBVSize is the pointer of The size of the VBV buffer in bytes.
+    *   @return true for correct operation; false if error happens
+    */
+    OSCL_IMPORT_REF Bool    PVGetVBVSize(VideoEncControls *encCtrl, Int *VBVSize);
+#endif
+
+    /**
+    *   @brief  This function encodes a frame in YUV 4:2:0 format from the *video_in input frame and put the result in YUV
+    *           for reconstructed frame and bstream for MPEG4 bitstream. The application is required to allocate memory for
+    *           bitstream buffer.The size of the input bitstream memory and the returned output buffer are specified in the
+    *           size field. The encoded layer is specified by the nLayer field. If the current frame is not encoded, size=0 and nLayer=-1.
+    *           Note: If the allocated buffer size is too small to fit a bitstream of a frame, then those extra bits will be left out
+    *                 which can cause syntactic error at the decoder side.
+    *   @param  encCtrl is video encoder control structure that is always passed as input in all APIs
+    *   @param  vid_in is the pointer to VideoEncFrameIO structure containing the YUV input data
+    *   @param  vid_out is the pointer to VideoEncFrameIO structure containing the reconstructed YUV output data after encoding
+    *   @param  nextModTime is the timestamp encoder expects from the next input
+    *   @param  bstream is the pointer to MPEG4 bitstream buffer
+    *   @param  size is the size of bitstream buffer allocated (input) and size of the encoded bitstream (output).
+    *   @param  nLayer is the layer of the encoded frame either 0 for base or 1 for enhancement layer. The value -1 indicates skipped frame due to buffer overflow.
+    *   @return true newfor correct operation; false if error happens
+    */
+    OSCL_IMPORT_REF Bool    PVEncodeVideoFrame(VideoEncControls *encCtrl, VideoEncFrameIO *vid_in, VideoEncFrameIO *vid_out,
+            ULong *nextModTime, UChar *bstream, Int *size, Int *nLayer);
+
+
+    /**
+    *   @brief  This function is used to query overrun buffer. It is used when PVEncodeVideoFrame.returns size that is
+    *           larger than the input size.
+    *   @param  encCtrl is video encoder control structure that is always passed as input in all APIs
+    *   @return Pointer to the overrun buffer. NULL if overrun buffer is not used.
+    */
+    OSCL_IMPORT_REF UChar* PVGetOverrunBuffer(VideoEncControls *encCtrl);
+
+#ifndef NO_SLICE_ENCODE   /* This set of APIs are not working. This functionality has been partially 
+    replaced by the introduction of overrun buffer. */
+
+    /* slice-based coding */
+    /**
+    *   @brief  This function sets the input YUV frame and timestamp to be encoded by the slice-based encoding function PVEncodeSlice().
+    *           It also return the memory address the reconstructed frame will be copied to (in advance) and the coded layer number.
+    *           The encoder library processes the timestamp and determine if this frame is to be encoded or not. If the current frame
+    *           is not encoded, nLayer=-1. For frame-based motion estimation, the motion estimation of the entire frame is also performed
+    *           in this function. For MB-based motion estimation, the motion vector is searched while coding each MB in PVEncodeSlice().
+    *   @param  encCtrl is video encoder control structure that is always passed as input in all APIs
+    *   @param  vid_in is the pointer to VideoEncFrameIO structure containing the YUV input data
+    *   @param  nextModTime is the timestamp encoder expects from the next input if this input is rejected and nLayer is set to -1.
+    *   @param  nLayer is the layer of the encoded frame either 0 for base or 1 for enhancement layer. The value -1 indicates skipped frame due to buffer overflow.
+    *   @return true newfor correct operation; false if error happens
+    */
+    OSCL_IMPORT_REF Bool    PVEncodeFrameSet(VideoEncControls *encCtrl, VideoEncFrameIO *vid_in, ULong *nextModTime, Int *nLayer);
+    /**
+    *   @brief  This function encodes a GOB (short header mode) or a packet (data partitioning mode or combined mode with resync marker)
+    *           and output the reconstructed frame and MPEG4 bitstream. The application is required to allocate memory for the bitstream buffer.
+    *           The size of the input bitstream memory and the returned output buffer are specified in the size field.  If the buffer size is
+    *           smaller than the requested packet size, user has to call PVEncodeSlice again to get the rest of that pending packet before moving
+    *           on to the next packet. For the combined mode without resync marker, the function returns when the buffer is full.
+    *           The end-of-frame flag  indicates the completion of the frame encoding.  Next frame must be sent in with PVEncodeFrameSet().
+    *           At the end-of-frame, the next video input address and the next video modulo timestamp will be set.
+    *   @param  encCtrl is video encoder control structure that is always passed as input in all APIs
+    *   @param  bstream is the pointer to MPEG4 bitstream buffer.
+    *   @param  size is the size of bitstream buffer allocated (input) and size of the encoded bitstream (output).
+    *   @param  endofFrame is a flag indicating the end-of-frame, '1'. Otherwise, '0'.  When PVSetNoCurrentFrameSkip is OFF,
+    *           end-of-frame '-1' indicates current frame bitstream must be disregarded.
+    *   @param  vid_out is the pointer to VideoEncFrameIO structure containing the reconstructed YUV output data after encoding
+    *   @param  nextModTime is the timestamp encoder expects from the next input
+    *   @return true newfor correct operation; false if error happens
+    */
+    OSCL_IMPORT_REF Bool    PVEncodeSlice(VideoEncControls *encCtrl, UChar *bstream, Int *size,
+                                          Int *endofFrame, VideoEncFrameIO *vid_out, ULong *nextModTime);
+#endif
+
+    /**
+    *   @brief  This function returns MP4 file format hint track information.
+    *   @param  encCtrl is video encoder control structure that is always passed as input in all APIs
+    *   @param  info is the structure for MP4 hint track information
+    *   @return true for correct operation; false if error happens
+    */
+    OSCL_IMPORT_REF Bool    PVGetHintTrack(VideoEncControls *encCtrl, MP4HintTrack *info);
+
+#ifndef LIMITED_API
+    /**
+    *   @brief  updates target frame rates of the encoded base and enhance layer (if any) while encoding operation is ongoing.
+    *   @param  encCtrl is video encoder control structure that is always passed as input in all APIs
+    *   @param  frameRate is the pointers to array of target frame rates in frames per second,
+    *           frameRate[n] represents the n-th layer's target frame rate.
+    *   @return true for correct operation; false if error happens
+    */
+    OSCL_IMPORT_REF Bool    PVUpdateEncFrameRate(VideoEncControls *encCtrl, float *frameRate); /* for 2-way */
+
+
+    /**
+    *   @brief  updates target bit rates of the encoded base and enhance layer (if any) while encoding operation is ongoing.
+    *   @param  encCtrl is video encoder control structure that is always passed as input in all APIs
+    *   @param  bitRate is the pointers to array of target bit rates in bits per second unit,
+    *           bitRate[n] represents the n-th layer's target bit rate.
+    *   @return true for correct operation; false if error happens
+    */
+    OSCL_IMPORT_REF Bool    PVUpdateBitRate(VideoEncControls *encCtrl, Int *bitRate);           /* for 2-way */
+
+
+    /**
+    *   @brief  updates the INTRA frame refresh interval while encoding operation is ongoing.
+    *   @param  encCtrl is video encoder control structure that is always passed as input in all APIs
+    *   @param  aIFramePeriod is a new value of INTRA frame interval in the unit of number of coded frames.
+    *   @return true for correct operation; false if error happens
+    */
+
+    OSCL_IMPORT_REF Bool    PVUpdateIFrameInterval(VideoEncControls *encCtrl, Int aIFramePeriod);/* for 2-way */
+
+    /**
+    *   @brief  specifies the number Intra MBs to be refreshed
+    *   @param  encCtrl is video encoder control structure that is always passed as input in all APIs
+    *   @param  numMB is the number of Intra MBs to be refreshed
+    *   @return true for correct operation; false if error happens
+    */
+    OSCL_IMPORT_REF Bool    PVUpdateNumIntraMBRefresh(VideoEncControls *encCtrl, Int numMB);  /* for 2-way */
+
+    /**
+    *   @brief  This function is called whenever users want the next base frame to be encoded as an I-Vop.
+    *   @param  encCtrl is video encoder control structure that is always passed as input in all APIs
+    *   @return true for correct operation; false if error happens
+    */
+    OSCL_IMPORT_REF Bool    PVIFrameRequest(VideoEncControls *encCtrl);                         /* for 2-way */
+
+#endif // LIMITED_API
+
+    /* finishing encoder */
+    /**
+    *   @brief  This function frees up all the memory allocated by the encoder library.
+    *   @param  encCtrl is video encoder control structure that is always passed as input in all APIs
+    *   @return true for correct operation; false if error happens
+    */
+    OSCL_IMPORT_REF Bool    PVCleanUpVideoEncoder(VideoEncControls *encCtrl);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* _MP4ENC_API_H_ */
+
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/bitstream_io.cpp b/media/libstagefright/codecs/m4v_h263/enc/src/bitstream_io.cpp
new file mode 100644
index 0000000..5c4c4ab
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/bitstream_io.cpp
@@ -0,0 +1,859 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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.
+ * -------------------------------------------------------------------
+ */
+/* Date: 8/02/04                                                                */
+/* Description:                                                                 */
+/*  Change the bitstream parsing algorithm. Use temporary word of 2 or 4 bytes  */
+/*  before writing it to the bitstream buffer.                                  */
+/*  Note byteCount doesn't have to be multiple of 2 or 4                        */
+/*********************************************************************************/
+
+#include "bitstream_io.h"
+#include "m4venc_oscl.h"
+#include <stdlib.h>
+
+static const UChar Mask[ ] =
+{
+    0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF
+};
+
+#define WORD_SIZE   4   /* for 32-bit machine */
+
+/*Note:
+    1. There is a problem when output the last bits(which can not form a byte yet
+    so when you output, you need to stuff to make sure it is a byte
+    2.  I now hard coded byte to be 8 bits*/
+
+
+/* ======================================================================== */
+/*  Function : BitStreamCreateEnc(Int bufferSize )                          */
+/*  Date     : 08/29/2000                                                   */
+/*  Purpose  : Create a bitstream to hold one encoded video packet or frame */
+/*  In/out   :                                                              */
+/*      bufferSize  :   size of the bitstream buffer in bytes               */
+/*  Return   : Pointer to the BitstreamEncVideo                             */
+/*  Modified :                                                              */
+/* ======================================================================== */
+
+BitstreamEncVideo *BitStreamCreateEnc(Int bufferSize)
+{
+    BitstreamEncVideo *stream;
+    stream = (BitstreamEncVideo *) M4VENC_MALLOC(sizeof(BitstreamEncVideo));
+    if (stream == NULL)
+    {
+        return NULL;
+    }
+    stream->bufferSize = bufferSize;
+    stream->bitstreamBuffer = (UChar *) M4VENC_MALLOC(stream->bufferSize * sizeof(UChar));
+    if (stream->bitstreamBuffer == NULL)
+    {
+        M4VENC_FREE(stream);
+        stream = NULL;
+        return NULL;
+    }
+    M4VENC_MEMSET(stream->bitstreamBuffer, 0, stream->bufferSize*sizeof(UChar));
+    stream->word = 0;
+#if WORD_SIZE==4
+    stream->bitLeft = 32;
+#else
+    stream->bitLeft = 16;
+#endif
+    stream->byteCount = 0;
+
+    stream->overrunBuffer = NULL;
+    stream->oBSize = 0;
+
+    return stream;
+}
+
+/* ======================================================================== */
+/*  Function : BitstreamCloseEnc( )                                         */
+/*  Date     : 08/29/2000                                                   */
+/*  Purpose  : close a bitstream                                            */
+/*  In/out   :
+        stream  :   the bitstream to be closed                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+
+Void  BitstreamCloseEnc(BitstreamEncVideo *stream)
+{
+    if (stream)
+    {
+        if (stream->bitstreamBuffer)
+        {
+            M4VENC_FREE(stream->bitstreamBuffer);
+        }
+
+        M4VENC_FREE(stream);
+    }
+}
+
+
+/* ======================================================================== */
+/*  Function : BitstreamPutBits(BitstreamEncVideo *stream, Int Length,
+                         Int Value)                                         */
+/*  Date     : 08/29/2000                                                   */
+/*  Purpose  : put Length (1-16) number of bits to the stream               */
+/*            for 32-bit machine this function can do upto 32 bit input     */
+/*  In/out   :                                                              */
+/*      stream      the bitstream where the bits are put in                 */
+/*      Length      bits length (should belong to 1 to 16)                  */
+/*      Value       those bits value                                        */
+/*  Return   :  PV_STATUS                                                   */
+/*  Modified :                                                              */
+/* ======================================================================== */
+PV_STATUS BitstreamPutBits(BitstreamEncVideo *stream, Int Length, UInt Value)
+{
+    PV_STATUS status;
+
+    if (stream->bitLeft > Length)
+    {
+        stream->word <<= Length;
+        stream->word |= Value;  /* assuming Value is not larger than Length */
+        stream->bitLeft -= Length;
+        return PV_SUCCESS;
+    }
+    else
+    {
+
+        stream->word <<= stream->bitLeft;
+        Length -= stream->bitLeft;
+        stream->word |= ((UInt)Value >> Length);
+
+        status = BitstreamSaveWord(stream);
+        if (status != PV_SUCCESS)
+        {
+            return status;
+        }
+
+        /* we got new Length and Value */
+        /* note that Value is not "clean" because of msb are not masked out */
+        stream->word = Value;
+        stream->bitLeft -= Length;
+        /* assuming that Length is no more than 16 bits */
+        /* stream->bitLeft should be greater than zero at this point */
+        //if(stream->bitLeft<=0)
+        //  exit(-1);
+        return PV_SUCCESS;
+    }
+}
+
+/* ======================================================================== */
+/*  Function : BitstreamPutGT16Bits(BitstreamEncVideo *stream, Int Length, UInt32 Value)    */
+/*  Date     : 08/29/2000                                                   */
+/*  Purpose  : Use this function to put Length (17-32) number of bits to    */
+/*              for 16-bit machine  the stream.                             */
+/*  In/out   :                                                              */
+/*      stream      the bitstream where the bits are put in                 */
+/*      Length      bits length (should belong to 17 to 32)                 */
+/*      Value       those bits value                                        */
+/*  Return   :  PV_STATUS                                                   */
+/*  Modified :                                                              */
+/* ======================================================================== */
+PV_STATUS BitstreamPutGT16Bits(BitstreamEncVideo *stream, Int Length, ULong Value)
+{
+    PV_STATUS status;
+    UInt topValue;
+    Int topLength;
+
+    topValue = (Value >> 16);
+    topLength = Length - 16;
+
+    if (topLength > 0)
+    {
+        status = BitstreamPutBits(stream, topLength, topValue);
+
+        if (status != PV_SUCCESS)
+        {
+            return status;
+        }
+
+        status = BitstreamPutBits(stream, 16, (UInt)(Value & 0xFFFF));
+
+        return status;
+    }
+    else
+    {
+        status = BitstreamPutBits(stream, Length, (UInt)Value);
+        return status;
+    }
+}
+
+/* ======================================================================== */
+/*  Function : BitstreamSaveWord                                            */
+/*  Date     : 08/03/2004                                                   */
+/*  Purpose  : save written word into the bitstream buffer.                 */
+/*  In/out   :                                                              */
+/*      stream      the bitstream where the bits are put in                 */
+/*  Return   :  PV_STATUS                                                   */
+/*  Modified :                                                              */
+/* ======================================================================== */
+
+PV_STATUS BitstreamSaveWord(BitstreamEncVideo *stream)
+{
+    UChar *ptr;
+    UInt word;
+
+    /* assume that stream->bitLeft is always zero when this function is called */
+    if (stream->byteCount + WORD_SIZE > stream->bufferSize)
+    {
+        if (PV_SUCCESS != BitstreamUseOverrunBuffer(stream, WORD_SIZE))
+        {
+            stream->byteCount += WORD_SIZE;
+            return PV_FAIL;
+        }
+    }
+
+    ptr = stream->bitstreamBuffer + stream->byteCount;
+    word = stream->word;
+    stream->word = 0; /* important to reset to zero */
+
+    /* NOTE: byteCount does not have to be multiple of 2 or 4 */
+#if (WORD_SIZE == 4)
+    *ptr++ = word >> 24;
+    *ptr++ = 0xFF & (word >> 16);
+#endif
+
+    *ptr++ = 0xFF & (word >> 8);
+    *ptr = 0xFF & word;
+
+#if (WORD_SIZE == 4)
+    stream->byteCount += 4;
+    stream->bitLeft = 32;
+#else
+    stream->byteCount += 2;
+    stream->bitLeft = 16;
+#endif
+
+    return PV_SUCCESS;
+}
+
+
+/* ======================================================================== */
+/*  Function : BitstreamSavePartial                                         */
+/*  Date     : 08/03/2004                                                   */
+/*  Purpose  : save unfinished written word into the bitstream buffer.      */
+/*  In/out   :                                                              */
+/*      stream      the bitstream where the bits are put in                 */
+/*  Return   :  PV_STATUS                                                   */
+/*  Modified :                                                              */
+/* ======================================================================== */
+
+PV_STATUS BitstreamSavePartial(BitstreamEncVideo *stream, Int *fraction)
+{
+    UChar *ptr;
+    UInt word, shift;
+    Int numbyte, bitleft, bitused;
+
+    bitleft = stream->bitLeft;
+    bitused = (WORD_SIZE << 3) - bitleft; /* number of bits used */
+    numbyte = bitused >> 3; /* number of byte fully used */
+
+    if (stream->byteCount + numbyte > stream->bufferSize)
+    {
+        if (PV_SUCCESS != BitstreamUseOverrunBuffer(stream, numbyte))
+        {
+            stream->byteCount += numbyte;
+            return PV_FAIL;
+        }
+    }
+
+    ptr = stream->bitstreamBuffer + stream->byteCount;
+    word = stream->word;
+    word <<= bitleft;   /* word is not all consumed */
+    bitleft = bitused - (numbyte << 3); /* number of bits used (fraction) */
+    stream->byteCount += numbyte;
+    if (bitleft)
+    {
+        *fraction = 1;
+    }
+    else
+    {
+        *fraction = 0;
+    }
+    bitleft = (WORD_SIZE << 3) - bitleft;
+    /* save new value */
+    stream->bitLeft = bitleft;
+
+    shift = ((WORD_SIZE - 1) << 3);
+    while (numbyte)
+    {
+        *ptr++ = (UChar)((word >> shift) & 0xFF);
+        word <<= 8;
+        numbyte--;
+    }
+
+    if (*fraction)
+    {// this could lead to buffer overrun when ptr is already out of bound.
+        //  *ptr = (UChar)((word>>shift)&0xFF); /* need to do it for the last fractional byte */
+    }
+
+    /* save new values */
+    stream->word = word >> bitleft;
+
+    /* note we don't update byteCount, bitLeft and word */
+    /* so that encoder can continue PutBits if they don't */
+
+    return PV_SUCCESS;
+}
+
+
+/* ======================================================================== */
+/*  Function : BitstreamShortHeaderByteAlignStuffing(                       */
+/*                                      BitstreamEncVideo *stream)          */
+/*  Date     : 08/29/2000                                                   */
+/*  Purpose  : bit stuffing for next start code in short video header       */
+/*  In/out   :                                                              */
+/*  Return   :  number of bits to be stuffed                                */
+/*  Modified :                                                              */
+/* ======================================================================== */
+
+Int BitstreamShortHeaderByteAlignStuffing(BitstreamEncVideo *stream)
+{
+    UInt restBits;
+    Int fraction;
+
+    restBits = (stream->bitLeft & 0x7); /* modulo 8 */
+
+    if (restBits)  /*short_video_header[0] is 1 in h263 baseline*/
+    {
+        /* H.263 style stuffing */
+        BitstreamPutBits(stream, restBits, 0);
+    }
+
+    if (stream->bitLeft != (WORD_SIZE << 3))
+    {
+        BitstreamSavePartial(stream, &fraction);
+    }
+
+    return restBits;
+}
+
+/* ======================================================================== */
+/*  Function : BitstreamMpeg4ByteAlignStuffing(BitstreamEncVideo *stream)   */
+/*  Date     : 08/29/2000                                                   */
+/*  Purpose  : bit stuffing for next start code in MPEG-4                  */
+/*  In/out   :                                                              */
+/*  Return   :  number of bits to be stuffed                                */
+/*  Modified :                                                              */
+/* ======================================================================== */
+Int BitstreamMpeg4ByteAlignStuffing(BitstreamEncVideo *stream)
+{
+
+    UInt restBits;
+    Int fraction;
+    /* Question: in MPEG-4 , short_video_header[0]==0 => even already byte aligned, will still stuff 8 bits
+       need to check with  */
+    /*if (!(getPointerENC(index1, index2)%8) && short_video_header[0]) return 0;*/
+
+    /* need stuffing bits, */
+    BitstreamPutBits(stream, 1, 0);
+
+    restBits = (stream->bitLeft & 0x7); /* modulo 8 */
+
+    if (restBits)  /*short_video_header[0] is 1 in h263 baseline*/
+    {
+        /* need stuffing bits, */
+        BitstreamPutBits(stream, restBits, Mask[restBits]);
+    }
+
+    if (stream->bitLeft != (WORD_SIZE << 3))
+    {
+        BitstreamSavePartial(stream, &fraction);
+    }
+
+    return (restBits);
+}
+
+/*does bit stuffing for next resync marker*/
+/*  does bit stuffing for next resync marker
+ *                                            "0"
+ *                                           "01"
+ *                                          "011"
+ *                                         "0111"
+ *                                        "01111"
+ *                                       "011111"
+ *                                      "0111111"
+ *                                     "01111111"   (8-bit codeword)
+ */
+
+/*Int BitstreamNextResyncMarkerEnc(BitstreamEncVideo *stream)
+{
+  Int count;
+  BitstreamPut1Bits(stream,0);
+  count=8-stream->totalBits & 8;
+  BitstreamPutBits(stream,count,Mask[count]);
+  return count;
+}*/
+
+/* ======================================================================== */
+/*  Function : BitstreamAppendEnc( BitstreamEncVideo *bitstream1,           */
+/*                                      BitstreamEncVideo *bitstream2   )   */
+/*  Date     : 08/29/2000                                                   */
+/*  Purpose  : Append the intermediate bitstream (bitstream2) to the end of */
+/*                              output bitstream(bitstream1)                */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+
+
+PV_STATUS BitstreamAppendEnc(BitstreamEncVideo *bitstream1, BitstreamEncVideo *bitstream2)
+{
+    PV_STATUS status;
+    UChar *ptrBS2, *ptrBS1;
+    UChar byteBS2, byteBS1;
+    Int  numbyte2;
+    Int bitused, bitleft, offset, fraction;
+
+    status = BitstreamSavePartial(bitstream1, &fraction);
+    if (status != PV_SUCCESS)
+    {
+        return status;
+    }
+
+    offset = fraction;
+    status = BitstreamSavePartial(bitstream2, &fraction);
+    if (status != PV_SUCCESS)
+    {
+        return status;
+    }
+
+    if (!offset) /* bitstream1 is byte-aligned */
+    {
+        return BitstreamAppendPacket(bitstream1, bitstream2);
+    }
+
+    offset += fraction;
+
+    /* since bitstream1 doesn't have to be byte-aligned, we have to process byte by byte */
+    /* we read one byte from bitstream2 and use BitstreamPutBits to do the job */
+    if (bitstream1->byteCount + bitstream2->byteCount + offset > bitstream1->bufferSize)
+    {
+        if (PV_SUCCESS != BitstreamUseOverrunBuffer(bitstream1, bitstream2->byteCount + offset))
+        {
+            bitstream1->byteCount += (bitstream2->byteCount + offset);
+            return PV_FAIL;
+        }
+    }
+
+    ptrBS1 = bitstream1->bitstreamBuffer + bitstream1->byteCount; /* move ptr bs1*/
+    ptrBS2 = bitstream2->bitstreamBuffer;
+
+    bitused = (WORD_SIZE << 3) - bitstream1->bitLeft; /* this must be between 1-7 */
+    bitleft = 8 - bitused;
+
+    numbyte2 = bitstream2->byteCount;   /* number of byte to copy from bs2 */
+    bitstream1->byteCount += numbyte2;  /* new byteCount */
+
+    byteBS1 = ((UChar) bitstream1->word) << bitleft;    /* fraction byte from bs1 */
+
+    while (numbyte2)
+    {
+        byteBS2 = *ptrBS2++;
+        byteBS1 |= (byteBS2 >> bitused);
+        *ptrBS1++ = byteBS1;
+        byteBS1 = byteBS2 << bitleft;
+        numbyte2--;
+    }
+
+    bitstream1->word = byteBS1 >> bitleft;  /* bitstream->bitLeft remains the same */
+
+    /* now save bs2->word in bs1 */
+    status = BitstreamPutBits(bitstream1, (WORD_SIZE << 3) - bitstream2->bitLeft, bitstream2->word);
+
+    return status;
+}
+
+/* ======================================================================== */
+/*  Function : BitstreamAppendPacket( BitstreamEncVideo *bitstream1,        */
+/*                                      BitstreamEncVideo *bitstream2   )   */
+/*  Date     : 05/31/2001                                                   */
+/*  Purpose  : Append the intermediate bitstream (bitstream2) to the end of */
+/*              output bitstream(bitstream1) knowing that bitstream1 is byte-aligned*/
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+PV_STATUS BitstreamAppendPacket(BitstreamEncVideo *bitstream1, BitstreamEncVideo *bitstream2)
+{
+    UChar *ptrBS2, *ptrBS1;
+    Int  numbyte2;
+
+    if (bitstream1->byteCount + bitstream2->byteCount  > bitstream1->bufferSize)
+    {
+        if (PV_SUCCESS != BitstreamUseOverrunBuffer(bitstream1, bitstream2->byteCount))
+        {
+            bitstream1->byteCount += bitstream2->byteCount; /* legacy, to keep track of total bytes */
+            return PV_FAIL;
+        }
+    }
+
+    ptrBS1 = bitstream1->bitstreamBuffer + bitstream1->byteCount; /* move ptr bs1*/
+    ptrBS2 = bitstream2->bitstreamBuffer;
+
+    numbyte2 = bitstream2->byteCount;
+    bitstream1->byteCount += numbyte2; /* new byteCount */
+
+    /*copy all the bytes in bitstream2*/
+    M4VENC_MEMCPY(ptrBS1, ptrBS2, sizeof(UChar)*numbyte2);
+
+    bitstream1->word = bitstream2->word;  /* bitstream1->bitLeft is the same */
+    bitstream1->bitLeft = bitstream2->bitLeft;
+
+    return PV_SUCCESS;
+}
+
+/* ======================================================================== */
+/*  Function : BitstreamAppendPacketNoOffset( BitstreamEncVideo *bitstream1,*/
+/*                                      BitstreamEncVideo *bitstream2   )   */
+/*  Date     : 04/23/2002                                                   */
+/*  Purpose  : Append the intermediate bitstream (bitstream2) to the end of */
+/*              output bitstream(bitstream1) , for slice-based coding only */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+PV_STATUS BitstreamAppendPacketNoOffset(BitstreamEncVideo *bitstream1, BitstreamEncVideo *bitstream2)
+{
+    PV_STATUS status = PV_SUCCESS;
+    UChar *ptrBS2, *ptrBS1;
+    Int  numbyte2;
+    Int  byteleft;
+
+    numbyte2 = bitstream2->byteCount;
+
+    if (bitstream1->byteCount + bitstream2->byteCount > bitstream1->bufferSize)
+    {
+        numbyte2 =  bitstream1->bufferSize - bitstream1->byteCount;
+        status =  PV_END_OF_BUF;    /* signal end of buffer */
+    }
+
+    ptrBS1 = bitstream1->bitstreamBuffer; /* move ptr bs1*/
+    ptrBS2 = bitstream2->bitstreamBuffer;
+
+    bitstream1->byteCount += numbyte2; /* should be equal to bufferSize */
+
+    /*copy all the bytes in bitstream2*/
+    M4VENC_MEMCPY(ptrBS1, ptrBS2, sizeof(UChar)*numbyte2);
+    bitstream1->word = 0;
+    bitstream1->bitLeft = (WORD_SIZE << 3);
+
+    if (status == PV_END_OF_BUF) /* re-position bitstream2 */
+    {
+        byteleft = bitstream2->byteCount - numbyte2;
+
+        M4VENC_MEMCPY(ptrBS2, ptrBS2 + numbyte2, sizeof(UChar)*byteleft);
+
+        bitstream2->byteCount = byteleft;
+        /* bitstream2->word and bitstream->bitLeft are unchanged.
+           they should be 0 and (WORD_SIZE<<3) */
+    }
+
+    return status;
+}
+
+#ifndef NO_SLICE_ENCODE
+/* ======================================================================== */
+/*  Function : BitstreamRepos( BitstreamEncVideo *bitstream,                */
+/*                                      Int byteCount, Int bitCount)        */
+/*  Date     : 04/28/2002                                                   */
+/*  Purpose  : Reposition the size of the buffer content (curtail)          */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+PV_STATUS   BitstreamRepos(BitstreamEncVideo *bitstream, Int byteCount, Int bitCount)
+{
+    UChar *ptr, byte;
+    UInt word;
+    Int fraction;
+
+    BitstreamSavePartial(bitstream, &fraction);
+
+    bitstream->byteCount = byteCount;
+    ptr = bitstream->bitstreamBuffer + byteCount; /* get fraction of the byte */
+    if (bitCount)
+    {
+        bitstream->bitLeft = (WORD_SIZE << 3) - bitCount; /* bitCount should be 0-31 */
+        word = *ptr++;
+        byte = *ptr++;
+        word = byte | (word << 8);
+#if (WORD_SIZE == 4)
+        byte = *ptr++;
+        word = byte | (word << 8);
+        byte = *ptr++;
+        word = byte | (word << 8);
+#endif
+        bitstream->word = word >> (bitstream->bitLeft);
+    }
+    else
+    {
+        bitstream->word = 0;
+        bitstream->bitLeft = (WORD_SIZE << 3);
+    }
+
+    return PV_SUCCESS;
+}
+
+/* ======================================================================== */
+/*  Function : BitstreamFlushBits(BitstreamEncVideo *bitstream1,            */
+/*                              Int num_bit_left)                           */
+/*  Date     : 04/24/2002                                                   */
+/*  Purpose  : Flush buffer except the last num_bit_left bits.              */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+
+
+PV_STATUS BitstreamFlushBits(BitstreamEncVideo *bitstream1, Int num_bit_left)
+{
+    Int i;
+    UChar *ptrDst, *ptrSrc;
+    Int leftover, bitused;
+    Int new_byte = (num_bit_left >> 3);
+    Int new_bit = num_bit_left - (new_byte << 3); /* between 0-7 */
+
+    ptrSrc = bitstream1->bitstreamBuffer + bitstream1->byteCount;
+    ptrDst = bitstream1->bitstreamBuffer;
+
+    bitused = (WORD_SIZE << 3) - bitstream1->bitLeft;
+
+    leftover = 8 - bitused; /* bitused should be between 0-7 */
+
+    bitstream1->byteCount = new_byte;
+    bitstream1->bitLeft = (WORD_SIZE << 3) - new_bit;
+
+    if (!bitused) /* byte aligned */
+    {
+        M4VENC_MEMCPY(ptrDst, ptrSrc, new_byte + 1);
+    }
+    else
+    {
+        /*copy all the bytes in bitstream2*/
+        for (i = 0; i < new_byte; i++)
+        {
+            *ptrDst++ = (ptrSrc[0] << bitused) | (ptrSrc[1] >> leftover);
+            ptrSrc++;
+        }
+        /* copy for the last byte of ptrSrc, copy extra bits doesn't hurt */
+        if (new_bit)
+        {
+            *ptrDst++ = (ptrSrc[0] << bitused) | (ptrSrc[1] >> leftover);
+            ptrSrc++;
+        }
+    }
+    if (new_bit)
+    {
+        ptrSrc = bitstream1->bitstreamBuffer + new_byte;
+        bitstream1->word = (*ptrSrc) >> (8 - new_bit);
+    }
+
+    return PV_SUCCESS;
+}
+
+/* ======================================================================== */
+/*  Function : BitstreamPrependPacket( BitstreamEncVideo *bitstream1,       */
+/*                                      BitstreamEncVideo *bitstream2   )   */
+/*  Date     : 04/26/2002                                                   */
+/*  Purpose  : Prepend the intermediate bitstream (bitstream2) to the beginning of */
+/*              output bitstream(bitstream1) */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+PV_STATUS BitstreamPrependPacket(BitstreamEncVideo *bitstream1, BitstreamEncVideo *bitstream2)
+{
+    UChar *pSrc, *pDst, byte;
+    Int     movebyte, bitused, leftover, i, fraction;
+
+    BitstreamSavePartial(bitstream2, &fraction); /* make sure only fraction of byte left */
+    BitstreamSavePartial(bitstream1, &fraction);
+
+    if (bitstream1->byteCount + bitstream2->byteCount >= bitstream1->bufferSize)
+    {
+        bitstream1->byteCount += bitstream2->byteCount;
+        return PV_END_OF_BUF;
+    }
+
+    movebyte = bitstream1->byteCount;
+    if (movebyte < bitstream2->byteCount)
+        movebyte = bitstream2->byteCount;
+    movebyte++;
+
+    /* shift bitstream1 to the right by movebyte */
+    pSrc = bitstream1->bitstreamBuffer;
+    pDst = pSrc + movebyte;
+
+    M4VENC_MEMCPY(pDst, pSrc, bitstream1->byteCount + 1);
+
+    /* copy bitstream2 to the beginning of bitstream1 */
+    M4VENC_MEMCPY(pSrc, bitstream2->bitstreamBuffer, bitstream2->byteCount + 1);
+
+    /* now shift back previous bitstream1 buffer to the end */
+    pSrc = pDst;
+    pDst = bitstream1->bitstreamBuffer + bitstream2->byteCount;
+
+    bitused = (WORD_SIZE << 3) - bitstream2->bitLeft;
+    leftover = 8 - bitused;     /* bitused should be 0-7 */
+
+    byte = (bitstream2->word) << leftover;
+
+    *pDst++ = byte | (pSrc[0] >> bitused);
+
+    for (i = 0; i < bitstream1->byteCount + 1; i++)
+    {
+        *pDst++ = ((pSrc[0] << leftover) | (pSrc[1] >> bitused));
+        pSrc++;
+    }
+
+    bitstream1->byteCount += bitstream2->byteCount;
+    //bitstream1->bitCount += bitstream2->bitCount;
+    bitused = (WORD_SIZE << 4) - (bitstream1->bitLeft + bitstream2->bitLeft);
+
+    if (bitused >= 8)
+    {
+        bitused -= 8;
+        bitstream1->byteCount++;
+    }
+
+    bitstream1->bitLeft = (WORD_SIZE << 3) - bitused;
+
+    bitstream2->byteCount = bitstream2->word = 0;
+    bitstream2->bitLeft = (WORD_SIZE << 3);
+
+    pSrc = bitstream1->bitstreamBuffer + bitstream1->byteCount;
+    leftover = 8 - bitused;
+    //*pSrc = (pSrc[0]>>leftover)<<leftover; /* make sure the rest of bits are zeros */
+
+    bitstream1->word = (UInt)((pSrc[0]) >> leftover);
+
+    return PV_SUCCESS;
+}
+#endif  /* NO_SLICE_ENCODE */
+
+
+/* ======================================================================== */
+/*  Function : BitstreamGetPos( BitstreamEncVideo *stream                   */
+/*  Date     : 08/05/2004                                                   */
+/*  Purpose  : Get the bit position.                                        */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+Int BitstreamGetPos(BitstreamEncVideo *stream)
+{
+
+    return stream->byteCount*8 + (WORD_SIZE << 3) - stream->bitLeft;
+}
+
+void BitstreamEncReset(BitstreamEncVideo *stream)
+{
+    stream->bitLeft = (WORD_SIZE << 3);
+    stream->word = 0;
+    stream->byteCount = 0;
+    return ;
+}
+
+/* This function set the overrun buffer, and VideoEncData context for callback to reallocate
+overrun buffer.  */
+Void  BitstreamSetOverrunBuffer(BitstreamEncVideo* stream, UChar* overrunBuffer, Int oBSize, VideoEncData *video)
+{
+    stream->overrunBuffer = overrunBuffer;
+    stream->oBSize = oBSize;
+    stream->video = video;
+
+    return ;
+}
+
+
+/* determine whether overrun buffer can be used or not */
+PV_STATUS BitstreamUseOverrunBuffer(BitstreamEncVideo* stream, Int numExtraBytes)
+{
+    VideoEncData *video = stream->video;
+
+    if (stream->overrunBuffer != NULL) // overrunBuffer is set
+    {
+        if (stream->bitstreamBuffer != stream->overrunBuffer) // not already used
+        {
+            if (stream->byteCount + numExtraBytes >= stream->oBSize)
+            {
+                stream->oBSize = stream->byteCount + numExtraBytes + 100;
+                stream->oBSize &= (~0x3); // make it multiple of 4
+
+                // allocate new overrun Buffer
+                if (video->overrunBuffer)
+                {
+                    M4VENC_FREE(video->overrunBuffer);
+                }
+                video->oBSize = stream->oBSize;
+                video->overrunBuffer = (UChar*) M4VENC_MALLOC(sizeof(UChar) * stream->oBSize);
+                stream->overrunBuffer = video->overrunBuffer;
+                if (stream->overrunBuffer == NULL)
+                {
+                    return PV_FAIL;
+                }
+            }
+
+            // copy everything to overrun buffer and start using it.
+            memcpy(stream->overrunBuffer, stream->bitstreamBuffer, stream->byteCount);
+            stream->bitstreamBuffer = stream->overrunBuffer;
+            stream->bufferSize = stream->oBSize;
+        }
+        else // overrun buffer is already used
+        {
+            if (stream->byteCount + numExtraBytes >= stream->oBSize)
+            {
+                stream->oBSize = stream->byteCount + numExtraBytes + 100;
+            }
+
+            // allocate new overrun buffer
+            stream->oBSize &= (~0x3); // make it multiple of 4
+            video->oBSize = stream->oBSize;
+            video->overrunBuffer = (UChar*) M4VENC_MALLOC(sizeof(UChar) * stream->oBSize);
+            if (video->overrunBuffer == NULL)
+            {
+                return PV_FAIL;
+            }
+
+            // copy from the old buffer to new buffer
+            memcpy(video->overrunBuffer, stream->overrunBuffer, stream->byteCount);
+            // free old buffer
+            M4VENC_FREE(stream->overrunBuffer);
+            // assign pointer to new buffer
+            stream->overrunBuffer = video->overrunBuffer;
+            stream->bitstreamBuffer = stream->overrunBuffer;
+            stream->bufferSize = stream->oBSize;
+        }
+
+        return PV_SUCCESS;
+    }
+    else // overrunBuffer is not enable.
+    {
+        return PV_FAIL;
+    }
+
+}
+
+
+
+
+
+
+
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/bitstream_io.h b/media/libstagefright/codecs/m4v_h263/enc/src/bitstream_io.h
new file mode 100644
index 0000000..0bce257
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/bitstream_io.h
@@ -0,0 +1,57 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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 _BITSTREAM_IO_H_
+#define _BITSTREAM_IO_H_
+
+#define BitstreamPut1Bits(x,y)  BitstreamPutBits(x,1,y)
+#define BitstreamPutGT8Bits(x,y,z) BitstreamPutBits(x,y,z)
+
+#include "mp4lib_int.h"
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    BitstreamEncVideo *BitStreamCreateEnc(Int bufferSize);
+    Void  BitstreamCloseEnc(BitstreamEncVideo *stream);
+    PV_STATUS BitstreamPutBits(BitstreamEncVideo *stream, Int Length, UInt Value);
+    PV_STATUS BitstreamPutGT16Bits(BitstreamEncVideo *stream, Int Length, ULong Value);
+    PV_STATUS BitstreamSaveWord(BitstreamEncVideo *stream);
+    PV_STATUS BitstreamSavePartial(BitstreamEncVideo *stream, Int *fraction);
+    Int BitstreamGetPos(BitstreamEncVideo *stream);
+    void BitstreamEncReset(BitstreamEncVideo *stream);
+
+    Int BitstreamShortHeaderByteAlignStuffing(BitstreamEncVideo *stream);
+    Int BitstreamMpeg4ByteAlignStuffing(BitstreamEncVideo *stream);
+    PV_STATUS BitstreamAppendEnc(BitstreamEncVideo *bitstream1, BitstreamEncVideo *bitstream2);
+    PV_STATUS BitstreamAppendPacket(BitstreamEncVideo *bitstream1, BitstreamEncVideo *bitstream2);
+    PV_STATUS BitstreamAppendPacketNoOffset(BitstreamEncVideo *bitstream1, BitstreamEncVideo *bitstream2);
+    PV_STATUS BitstreamRepos(BitstreamEncVideo *bitstream, Int byteCount, Int bitCount);
+    PV_STATUS BitstreamFlushBits(BitstreamEncVideo *bitstream1, Int num_bit_left);
+    PV_STATUS BitstreamPrependPacket(BitstreamEncVideo *bitstream1, BitstreamEncVideo *bitstream2);
+
+
+    Void  BitstreamSetOverrunBuffer(BitstreamEncVideo *stream, UChar *overrunBuffer, Int oBSize, VideoEncData *video);
+    PV_STATUS BitstreamUseOverrunBuffer(BitstreamEncVideo* stream, Int numExtraBytes);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _BITSTREAM_IO_H_ */
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/combined_encode.cpp b/media/libstagefright/codecs/m4v_h263/enc/src/combined_encode.cpp
new file mode 100644
index 0000000..e725680
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/combined_encode.cpp
@@ -0,0 +1,693 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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 "mp4def.h"
+#include "mp4enc_lib.h"
+#include "mp4lib_int.h"
+#include "bitstream_io.h"
+#include "vlc_encode.h"
+#include "m4venc_oscl.h"
+
+PV_STATUS EncodeGOBHeader(VideoEncData *video, Int GOB_number, Int quant_scale, Int bs1stream);
+
+/* ======================================================================== */
+/*  Function : EncodeFrameCombinedMode()                                    */
+/*  Date     : 09/01/2000                                                   */
+/*  History  :                                                              */
+/*  Purpose  : Encode a frame of MPEG4 bitstream in Combined mode.          */
+/*  In/out   :                                                              */
+/*  Return   :  PV_SUCCESS if successful else PV_FAIL                       */
+/*  Modified :                                                              */
+/*                                                                          */
+/* ======================================================================== */
+PV_STATUS EncodeFrameCombinedMode(VideoEncData *video)
+{
+    PV_STATUS status = PV_SUCCESS;
+    Vol *currVol = video->vol[video->currLayer];
+    Vop *currVop = video->currVop;
+    VideoEncParams *encParams = video->encParams;
+    Int width = currVop->width; /* has to be Vop, for multiple of 16 */
+    Int lx = currVop->pitch; /* with padding */
+    Int offset = 0;
+    Int ind_x, ind_y;
+    Int start_packet_header = 0;
+    UChar *QPMB = video->QPMB;
+    Int QP;
+    Int mbnum = 0, slice_counter = 0, curr_slice_counter = 0;
+    Int num_bits, packet_size = encParams->ResyncPacketsize;
+    Int GOB_Header_Interval = encParams->GOB_Header_Interval;
+    BitstreamEncVideo *bs1 = video->bitstream1;
+    Int numHeaderBits;
+    approxDCT fastDCTfunction;
+    Int ncoefblck[6] = {64, 64, 64, 64, 64, 64}; /* for FastCodeMB,  5/18/2001 */
+    PV_STATUS(*CodeMB)(VideoEncData *, approxDCT *, Int, Int[]);
+    void (*MBVlcEncode)(VideoEncData*, Int[], void *);
+    void (*BlockCodeCoeff)(RunLevelBlock*, BitstreamEncVideo*, Int, Int, UChar);
+
+    /* for H263 GOB changes */
+//MP4RateControlType rc_type = encParams->RC_Type;
+
+    video->QP_prev = currVop->quantizer;
+
+    numHeaderBits = BitstreamGetPos(bs1);
+
+    /* determine type of quantization   */
+#ifndef NO_MPEG_QUANT
+    if (currVol->quantType == 0)
+        CodeMB = &CodeMB_H263;
+    else
+        CodeMB = &CodeMB_MPEG;
+#else
+    CodeMB = &CodeMB_H263;
+#endif
+
+    /* determine which functions to be used, in MB-level */
+    if (currVop->predictionType == P_VOP)
+        MBVlcEncode = &MBVlcEncodeCombined_P_VOP;
+    else if (currVop->predictionType == I_VOP)
+        MBVlcEncode = &MBVlcEncodeCombined_I_VOP;
+    else /* B_VOP not implemented yet */
+        return PV_FAIL;
+
+    /* determine which VLC table to be used */
+#ifndef H263_ONLY
+    if (currVol->shortVideoHeader)
+        BlockCodeCoeff = &BlockCodeCoeff_ShortHeader;
+#ifndef NO_RVLC
+    else if (currVol->useReverseVLC)
+        BlockCodeCoeff = &BlockCodeCoeff_RVLC;
+#endif
+    else
+        BlockCodeCoeff = &BlockCodeCoeff_Normal;
+#else
+    BlockCodeCoeff = &BlockCodeCoeff_ShortHeader;
+#endif
+
+    /* gob_frame_id is the same for different vop types - the reason should be SCD */
+    if (currVol->shortVideoHeader && currVop->gobFrameID != currVop->predictionType)
+        currVop->gobFrameID = currVop->predictionType;
+
+
+    video->usePrevQP = 0;
+
+    for (ind_y = 0; ind_y < currVol->nMBPerCol; ind_y++)    /* Col MB Loop */
+    {
+
+        video->outputMB->mb_y = ind_y; /*  5/28/01 */
+
+        if (currVol->shortVideoHeader)  /* ShortVideoHeader Mode */
+        {
+
+            if (slice_counter && GOB_Header_Interval && (ind_y % GOB_Header_Interval == 0))     /* Encode GOB Header */
+            {
+                QP = QPMB[mbnum];    /* Get quant_scale */
+                video->header_bits -= BitstreamGetPos(currVol->stream); /* Header Bits */
+                status = EncodeGOBHeader(video, slice_counter, QP, 0);  //ind_y     /* Encode GOB Header */
+                video->header_bits += BitstreamGetPos(currVol->stream); /* Header Bits */
+                curr_slice_counter = slice_counter;
+            }
+        }
+
+        for (ind_x = 0; ind_x < currVol->nMBPerRow; ind_x++)  /* Row MB Loop */
+        {
+            video->outputMB->mb_x = ind_x; /*  5/28/01 */
+            video->mbnum = mbnum;
+            QP = QPMB[mbnum];   /* always read new QP */
+
+            if (GOB_Header_Interval)
+                video->sliceNo[mbnum] = curr_slice_counter; /* Update MB slice number */
+            else
+                video->sliceNo[mbnum] = slice_counter;
+
+            /****************************************************************************************/
+            /* MB Prediction:Put into MC macroblock, substract from currVop, put in predMB */
+            /****************************************************************************************/
+            getMotionCompensatedMB(video, ind_x, ind_y, offset);
+
+#ifndef H263_ONLY
+            if (start_packet_header)
+            {
+                slice_counter++;                        /* Increment slice counter */
+                video->sliceNo[mbnum] = slice_counter;  /* Update MB slice number*/
+                video->header_bits -= BitstreamGetPos(bs1); /* Header Bits */
+                video->QP_prev = currVop->quantizer;
+                status = EncodeVideoPacketHeader(video, mbnum, video->QP_prev, 0);
+                video->header_bits += BitstreamGetPos(bs1); /* Header Bits */
+                numHeaderBits = BitstreamGetPos(bs1);
+                start_packet_header = 0;
+                video->usePrevQP = 0;
+            }
+#endif
+            /***********************************************/
+            /* Code_MB:  DCT, Q, Q^(-1), IDCT, Motion Comp */
+            /***********************************************/
+
+            status = (*CodeMB)(video, &fastDCTfunction, (offset << 5) + QP, ncoefblck);
+
+            /************************************/
+            /* MB VLC Encode: VLC Encode MB     */
+            /************************************/
+
+            (*MBVlcEncode)(video, ncoefblck, (void*)BlockCodeCoeff);
+
+            /*************************************************************/
+            /* Assemble Packets:  Assemble the MB VLC codes into Packets */
+            /*************************************************************/
+
+            /* Assemble_Packet(video) */
+#ifndef H263_ONLY
+            if (!currVol->shortVideoHeader) /* Not in ShortVideoHeader mode */
+            {
+                if (!currVol->ResyncMarkerDisable) /* RESYNC MARKER MODE */
+                {
+                    num_bits = BitstreamGetPos(bs1) - numHeaderBits;
+                    if (num_bits > packet_size)
+                    {
+                        video->header_bits += BitstreamMpeg4ByteAlignStuffing(bs1); /* Byte align Packet */
+
+                        status = BitstreamAppendPacket(currVol->stream, bs1); /* Put Packet to Buffer */
+                        /* continue even if status == PV_END_OF_BUF, to get the stats */
+
+                        BitstreamEncReset(bs1);
+
+                        start_packet_header = 1;
+                    }
+                }
+                else   /* NO RESYNC MARKER MODE */
+                {
+                    status = BitstreamAppendEnc(currVol->stream, bs1); /* Initialize to 0 */
+                    /* continue even if status == PV_END_OF_BUF, to get the stats */
+
+                    BitstreamEncReset(bs1);
+                }
+            }
+            else
+#endif /* H263_ONLY */
+            {   /* ShortVideoHeader Mode */
+                status = BitstreamAppendEnc(currVol->stream, bs1);  /* Initialize to 0 */
+                /* continue even if status == PV_END_OF_BUF, to get the stats */
+
+                BitstreamEncReset(bs1);
+            }
+            mbnum++;
+            offset += 16;
+        } /* End of For ind_x */
+
+        offset += (lx << 4) - width;
+        if (currVol->shortVideoHeader)  /* ShortVideoHeader = 1 */
+        {
+
+            if (GOB_Header_Interval)  slice_counter++;
+        }
+
+    } /* End of For ind_y */
+
+    if (currVol->shortVideoHeader) /* ShortVideoHeader = 1 */
+    {
+
+        video->header_bits += BitstreamShortHeaderByteAlignStuffing(currVol->stream); /* Byte Align */
+    }
+#ifndef H263_ONLY
+    else   /* Combined Mode*/
+    {
+        if (!currVol->ResyncMarkerDisable) /* Resync Markers */
+        {
+
+            if (!start_packet_header)
+            {
+                video->header_bits += BitstreamMpeg4ByteAlignStuffing(bs1);/* Byte Align  */
+
+                status = BitstreamAppendPacket(currVol->stream, bs1);   /* Put Packet to Buffer */
+                /* continue even if status == PV_END_OF_BUF, to get the stats */
+
+                BitstreamEncReset(bs1);
+            }
+        }
+        else   /* No Resync Markers */
+        {
+            video->header_bits += BitstreamMpeg4ByteAlignStuffing(currVol->stream); /* Byte Align */
+        }
+    }
+#endif /* H263_ONLY */
+
+    return status; /* if status == PV_END_OF_BUF, this frame will be pre-skipped */
+}
+
+#ifndef NO_SLICE_ENCODE
+/* ======================================================================== */
+/*  Function : EncodeSliceCombinedMode()                                    */
+/*  Date     : 04/19/2002                                                   */
+/*  History  :                                                              */
+/*  Purpose  : Encode a slice of MPEG4 bitstream in Combined mode and save  */
+/*              the current MB to continue next time it is called.          */
+/*  In/out   :                                                              */
+/*  Return   :  PV_SUCCESS if successful else PV_FAIL                       */
+/*  Modified :                                                              */
+/*                                                                          */
+/* ======================================================================== */
+PV_STATUS EncodeSliceCombinedMode(VideoEncData *video)
+{
+    PV_STATUS status = PV_SUCCESS;
+    Vol *currVol = video->vol[video->currLayer];
+    Vop *currVop = video->currVop;
+    UChar mode = MODE_INTRA;
+    UChar *Mode = video->headerInfo.Mode;
+    VideoEncParams *encParams = video->encParams;
+    Int nTotalMB = currVol->nTotalMB;
+    Int width = currVop->width; /* has to be Vop, for multiple of 16 */
+    Int lx = currVop->pitch; /* , with padding */
+//  rateControl *rc = encParams->rc[video->currLayer];
+    UChar *QPMB = video->QPMB;
+    Int QP;
+    Int ind_x = video->outputMB->mb_x, ind_y = video->outputMB->mb_y;
+    Int offset = video->offset;                 /* get current MB location */
+    Int mbnum = video->mbnum, slice_counter = video->sliceNo[mbnum]; /* get current MB location */
+    Int firstMB = mbnum;
+    Int start_packet_header = 0;
+    Int num_bits = 0;
+    Int packet_size = encParams->ResyncPacketsize - 1;
+    Int resync_marker = ((!currVol->shortVideoHeader) && (!currVol->ResyncMarkerDisable));
+    BitstreamEncVideo *bs1 = video->bitstream1;
+    Int byteCount = 0, byteCount1 = 0, bitCount = 0;
+    Int numHeaderBits = 0;
+    approxDCT fastDCTfunction;
+    Int ncoefblck[6] = {64, 64, 64, 64, 64, 64}; /* for FastCodeMB,  5/18/2001 */
+    UChar CBP = 0;
+    Short outputMB[6][64];
+    Int k;
+    PV_STATUS(*CodeMB)(VideoEncData *, approxDCT *, Int, Int[]);
+    void (*MBVlcEncode)(VideoEncData*, Int[], void *);
+    void (*BlockCodeCoeff)(RunLevelBlock*, BitstreamEncVideo*, Int, Int, UChar);
+
+    video->QP_prev = 31;
+
+#define H263_GOB_CHANGES
+
+
+    if (video->end_of_buf) /* left-over from previous run */
+    {
+        status = BitstreamAppendPacketNoOffset(currVol->stream, bs1);
+        if (status != PV_END_OF_BUF)
+        {
+            BitstreamEncReset(bs1);
+            video->end_of_buf = 0;
+        }
+        return status;
+    }
+
+
+    if (mbnum == 0) /* only do this at the start of a frame */
+    {
+        QPMB[0] = video->QP_prev = QP = currVop->quantizer;
+        video->usePrevQP = 0;
+
+        numHeaderBits = BitstreamGetPos(bs1);
+    }
+
+    /* Re-assign fast functions on every slice, don't have to put it in the memory */
+    QP = QPMB[mbnum];
+    if (mbnum > 0)   video->QP_prev = QPMB[mbnum-1];
+
+    /* determine type of quantization   */
+#ifndef NO_MPEG_QUANT
+    if (currVol->quantType == 0)
+        CodeMB = &CodeMB_H263;
+    else
+        CodeMB = &CodeMB_MPEG;
+#else
+    CodeMB = &CodeMB_H263;
+#endif
+
+    /* determine which functions to be used, in MB-level */
+    if (currVop->predictionType == P_VOP)
+        MBVlcEncode = &MBVlcEncodeCombined_P_VOP;
+    else if (currVop->predictionType == I_VOP)
+        MBVlcEncode = &MBVlcEncodeCombined_I_VOP;
+    else /* B_VOP not implemented yet */
+        return PV_FAIL;
+
+    /* determine which VLC table to be used */
+#ifndef H263_ONLY
+    if (currVol->shortVideoHeader)
+        BlockCodeCoeff = &BlockCodeCoeff_ShortHeader;
+#ifndef NO_RVLC
+    else if (currVol->useReverseVLC)
+        BlockCodeCoeff = &BlockCodeCoeff_RVLC;
+#endif
+    else
+        BlockCodeCoeff = &BlockCodeCoeff_Normal;
+#else
+    BlockCodeCoeff = &BlockCodeCoeff_ShortHeader;
+#endif
+
+    /*  (gob_frame_id is the same for different vop types) The reason should be SCD */
+    if (currVol->shortVideoHeader && currVop->gobFrameID != currVop->predictionType)
+        currVop->gobFrameID = currVop->predictionType;
+
+
+    if (mbnum != 0)
+    {
+        if (currVol->shortVideoHeader)
+        {
+            /* Encode GOB Header */
+            bitCount = BitstreamGetPos(bs1);
+            byteCount1 = byteCount = bitCount >> 3; /* save the position before GOB header */
+            bitCount = bitCount & 0x7;
+
+#ifdef H263_GOB_CHANGES
+            video->header_bits -= BitstreamGetPos(bs1); /* Header Bits */
+            status = EncodeGOBHeader(video, slice_counter, QP, 1);  //ind_y    /* Encode GOB Header */
+            video->header_bits += BitstreamGetPos(bs1); /* Header Bits */
+#endif
+            goto JUMP_IN_SH;
+        }
+        else if (currVol->ResyncMarkerDisable)
+        {
+            goto JUMP_IN_SH;
+        }
+        else
+        {
+            start_packet_header = 1;
+            goto JUMP_IN;
+        }
+    }
+
+    for (ind_y = 0; ind_y < currVol->nMBPerCol; ind_y++)    /* Col MB Loop */
+    {
+
+        video->outputMB->mb_y = ind_y; /*  5/28/01, do not remove */
+
+        for (ind_x = 0; ind_x < currVol->nMBPerRow; ind_x++)  /* Row MB Loop */
+        {
+
+            video->outputMB->mb_x = ind_x; /*  5/28/01, do not remove */
+            video->mbnum = mbnum;
+            video->sliceNo[mbnum] = slice_counter;      /* Update MB slice number */
+JUMP_IN_SH:
+            /****************************************************************************************/
+            /* MB Prediction:Put into MC macroblock, substract from currVop, put in predMB */
+            /****************************************************************************************/
+            getMotionCompensatedMB(video, ind_x, ind_y, offset);
+
+JUMP_IN:
+            QP = QPMB[mbnum];   /* always read new QP */
+#ifndef H263_ONLY
+            if (start_packet_header)
+            {
+                slice_counter++;                        /* Increment slice counter */
+                video->sliceNo[mbnum] = slice_counter;  /* Update MB slice number*/
+                video->QP_prev = currVop->quantizer;                        /* store QP */
+                num_bits = BitstreamGetPos(bs1);
+                status = EncodeVideoPacketHeader(video, mbnum, video->QP_prev, 1);
+                numHeaderBits = BitstreamGetPos(bs1) - num_bits;
+                video->header_bits += numHeaderBits; /* Header Bits */
+                start_packet_header = 0;
+                video->usePrevQP = 0;
+            }
+            else  /* don't encode the first MB in packet again */
+#endif /* H263_ONLY */
+            {
+                /***********************************************/
+                /* Code_MB:  DCT, Q, Q^(-1), IDCT, Motion Comp */
+                /***********************************************/
+                status = (*CodeMB)(video, &fastDCTfunction, (offset << 5) + QP, ncoefblck);
+            }
+
+            /************************************/
+            /* MB VLC Encode: VLC Encode MB     */
+            /************************************/
+
+            /* save the state before VLC encoding */
+            if (resync_marker)
+            {
+                bitCount = BitstreamGetPos(bs1);
+                byteCount = bitCount >> 3; /* save the state before encoding */
+                bitCount = bitCount & 0x7;
+                mode = Mode[mbnum];
+                CBP = video->headerInfo.CBP[mbnum];
+                for (k = 0; k < 6; k++)
+                {
+                    M4VENC_MEMCPY(outputMB[k], video->outputMB->block[k], sizeof(Short) << 6);
+                }
+            }
+            /*************************************/
+
+            (*MBVlcEncode)(video, ncoefblck, (void*)BlockCodeCoeff);
+
+            /*************************************************************/
+            /* Assemble Packets:  Assemble the MB VLC codes into Packets */
+            /*************************************************************/
+
+            /* Assemble_Packet(video) */
+#ifndef H263_ONLY
+            if (!currVol->shortVideoHeader)
+            {
+                if (!currVol->ResyncMarkerDisable)
+                {
+                    /* Not in ShortVideoHeader mode and RESYNC MARKER MODE */
+
+                    num_bits = BitstreamGetPos(bs1) ;//- numHeaderBits; // include header
+
+                    /* Assemble packet and return when size reached */
+                    if (num_bits > packet_size && mbnum != firstMB)
+                    {
+
+                        BitstreamRepos(bs1, byteCount, bitCount); /* rewind one MB */
+
+                        video->header_bits += BitstreamMpeg4ByteAlignStuffing(bs1); /* Byte align Packet */
+
+                        status = BitstreamAppendPacketNoOffset(currVol->stream, bs1); /* Put Packet to Buffer */
+
+                        if (status == PV_END_OF_BUF)
+                        {
+                            video->end_of_buf = 1;
+                        }
+                        else
+                        {
+                            BitstreamEncReset(bs1);
+                        }
+
+                        start_packet_header = 1;
+
+                        if (mbnum < nTotalMB || video->end_of_buf) /* return here */
+                        {
+                            video->mbnum = mbnum;
+                            video->sliceNo[mbnum] = slice_counter;
+                            video->offset = offset;
+                            Mode[mbnum] = mode;
+                            video->headerInfo.CBP[mbnum] = CBP;
+
+                            for (k = 0; k < 6; k++)
+                            {
+                                M4VENC_MEMCPY(video->outputMB->block[k], outputMB[k], sizeof(Short) << 6);
+                            }
+
+                            return status;
+                        }
+                    }
+                }
+                else  /* NO RESYNC MARKER , return when buffer is full*/
+                {
+
+                    if (mbnum < nTotalMB - 1 && currVol->stream->byteCount + bs1->byteCount + 1 >= currVol->stream->bufferSize)
+                    {
+                        /* find maximum bytes to fit in the buffer */
+                        byteCount = currVol->stream->bufferSize - currVol->stream->byteCount - 1;
+
+                        num_bits = BitstreamGetPos(bs1) - (byteCount << 3);
+                        BitstreamRepos(bs1, byteCount, 0);
+                        status = BitstreamAppendPacketNoOffset(currVol->stream, bs1);
+                        BitstreamFlushBits(bs1, num_bits);
+
+                        /* move on to next MB */
+                        mbnum++ ;
+                        offset += 16;
+                        video->outputMB->mb_x++;
+                        if (video->outputMB->mb_x >= currVol->nMBPerRow)
+                        {
+                            video->outputMB->mb_x = 0;
+                            video->outputMB->mb_y++;
+                            offset += (lx << 4) - width;
+                        }
+                        video->mbnum = mbnum;
+                        video->offset = offset;
+                        video->sliceNo[mbnum] = slice_counter;
+                        return status;
+                    }
+                }
+            }
+#endif /* H263_ONLY */
+            offset += 16;
+            mbnum++; /* has to increment before SCD, to preserve Mode[mbnum] */
+
+        } /* End of For ind_x */
+
+        offset += (lx << 4) - width;
+
+        if (currVol->shortVideoHeader)  /* ShortVideoHeader = 1 */
+        {
+#ifdef H263_GOB_CHANGES
+            slice_counter++;
+            video->header_bits += BitstreamShortHeaderByteAlignStuffing(bs1);
+#endif
+            //video->header_bits+=BitstreamShortHeaderByteAlignStuffing(bs1);
+
+            /* check if time to packetize */
+            if (currVol->stream->byteCount + bs1->byteCount > currVol->stream->bufferSize)
+            {
+                if (byteCount == byteCount1) /* a single GOB bigger than packet size */
+                {
+                    status = BitstreamAppendPacketNoOffset(currVol->stream, bs1);
+                    status = PV_END_OF_BUF;
+                    video->end_of_buf = 1;
+                    start_packet_header = 1;
+                }
+                else    /* for short_header scooch back to previous GOB */
+                {
+                    num_bits = ((bs1->byteCount - byteCount) << 3);
+                    //num_bits = ((bs1->byteCount<<3) + bs1->bitCount) - ((byteCount<<3) + bitCount);
+                    BitstreamRepos(bs1, byteCount, 0);
+                    //BitstreamRepos(bs1,byteCount,bitCount);
+//                  k = currVol->stream->byteCount; /* save state before appending */
+                    status = BitstreamAppendPacketNoOffset(currVol->stream, bs1);
+                    BitstreamFlushBits(bs1, num_bits);
+//                  if(mbnum == nTotalMB || k + bs1->byteCount >= currVol->stream->bufferSize){
+                    /* last GOB or current one with larger size will be returned next run */
+//                      status = PV_END_OF_BUF;
+//                      video->end_of_buf = 1;
+//                  }
+                    start_packet_header = 1;
+                    if (mbnum == nTotalMB) /* there's one more GOB to packetize for the next round */
+                    {
+                        status = PV_END_OF_BUF;
+                        video->end_of_buf = 1;
+                    }
+                }
+
+                if (mbnum < nTotalMB) /* return here */
+                {
+                    /* move on to next MB */
+                    video->outputMB->mb_x = 0;
+                    video->outputMB->mb_y++;
+                    video->mbnum = mbnum;
+                    video->offset = offset;
+                    video->sliceNo[mbnum] = slice_counter;
+                    return status;
+                }
+            }
+            else if (mbnum < nTotalMB) /* do not write GOB header if end of vop */
+            {
+                bitCount = BitstreamGetPos(bs1);
+                byteCount = bitCount >> 3;  /* save the position before GOB header */
+                bitCount = bitCount & 0x7;
+#ifdef H263_GOB_CHANGES
+                video->header_bits -= BitstreamGetPos(bs1); /* Header Bits */
+                status = EncodeGOBHeader(video, slice_counter, QP, 1);         /* Encode GOB Header */
+                video->header_bits += BitstreamGetPos(bs1); /* Header Bits */
+#endif
+            }
+        }
+
+    } /* End of For ind_y */
+#ifndef H263_ONLY
+    if (!currVol->shortVideoHeader) /* Combined Mode*/
+    {
+        if (!currVol->ResyncMarkerDisable) /* Resync Markers */
+        {
+
+            if (!start_packet_header)
+            {
+
+                video->header_bits += BitstreamMpeg4ByteAlignStuffing(bs1);/* Byte Align  */
+
+                status = BitstreamAppendPacketNoOffset(currVol->stream, bs1);   /* Put Packet to Buffer */
+                if (status == PV_END_OF_BUF)
+                {
+                    video->end_of_buf = 1;
+                }
+                else
+                {
+                    BitstreamEncReset(bs1);
+                }
+            }
+        }
+        else   /* No Resync Markers */
+        {
+            video->header_bits += BitstreamMpeg4ByteAlignStuffing(bs1); /* Byte Align */
+            status = BitstreamAppendPacketNoOffset(currVol->stream, bs1); /* Initialize to 0 */
+            if (status == PV_END_OF_BUF)
+            {
+                video->end_of_buf = 1;
+            }
+            else
+            {
+                BitstreamEncReset(bs1);
+            }
+        }
+    }
+    else
+#endif /* H263_ONLY */
+    {
+        if (!start_packet_header) /* not yet packetized */
+        {
+            video->header_bits += BitstreamShortHeaderByteAlignStuffing(bs1);
+            status = BitstreamAppendPacketNoOffset(currVol->stream, bs1);
+            if (status == PV_END_OF_BUF)
+            {
+                video->end_of_buf = 1;
+            }
+            else
+            {
+                BitstreamEncReset(bs1);
+                video->end_of_buf = 0;
+            }
+        }
+    }
+
+    video->mbnum = mbnum;
+    if (mbnum < nTotalMB)
+        video->sliceNo[mbnum] = slice_counter;
+    video->offset = offset;
+
+    return status;
+}
+#endif  /* NO_SLICE_ENCODE */
+
+/* ======================================================================== */
+/*  Function : EncodeGOBHeader()                                            */
+/*  Date     : 09/05/2000                                                   */
+/*  History  :                                                              */
+/*  Purpose  : Encode a frame of MPEG4 bitstream in Combined mode.          */
+/*  In/out   :                                                              */
+/*  Return   :  PV_SUCCESS if successful else PV_FAIL                       */
+/*  Modified :                                                              */
+/*                                                                          */
+/* ======================================================================== */
+
+PV_STATUS EncodeGOBHeader(VideoEncData *video, Int GOB_number, Int quant_scale, Int bs1stream)
+{
+    PV_STATUS status = PV_SUCCESS;
+    BitstreamEncVideo *stream = (bs1stream ? video->bitstream1 : video->vol[video->currLayer]->stream);
+
+    status = BitstreamPutGT16Bits(stream, 17, GOB_RESYNC_MARKER); /* gob_resync_marker */
+    status = BitstreamPutBits(stream, 5, GOB_number);           /* Current gob_number */
+    status = BitstreamPutBits(stream, 2, video->currVop->gobFrameID); /* gob_frame_id */
+    status = BitstreamPutBits(stream, 5, quant_scale);              /* quant_scale */
+    return status;
+}
+
+
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/datapart_encode.cpp b/media/libstagefright/codecs/m4v_h263/enc/src/datapart_encode.cpp
new file mode 100644
index 0000000..16c8e79
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/datapart_encode.cpp
@@ -0,0 +1,482 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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 H263_ONLY
+
+#include "mp4def.h"
+#include "mp4lib_int.h"
+#include "bitstream_io.h"
+#include "mp4enc_lib.h"
+#include "m4venc_oscl.h"
+
+/* ======================================================================== */
+/*  Function : EncodeFrameDataPartMode()                                    */
+/*  Date     : 09/6/2000                                                    */
+/*  History  :                                                              */
+/*  Purpose  : Encode a frame of MPEG4 bitstream in datapartitioning mode.  */
+/*  In/out   :                                                              */
+/*  Return   :  PV_SUCCESS if successful else PV_FAIL                       */
+/*  Modified :                                                              */
+/*                                                                          */
+/* ======================================================================== */
+PV_STATUS EncodeFrameDataPartMode(VideoEncData *video)
+{
+    PV_STATUS status = PV_SUCCESS;
+    Vol *currVol = video->vol[video->currLayer];
+    Vop *currVop = video->currVop;
+    VideoEncParams *encParams = video->encParams;
+    Int width = currVop->width; /* has to be Vop, for multiple of 16 */
+    Int lx = currVop->pitch; /*  with padding */
+    Int offset = 0;
+    Int ind_x, ind_y;
+    Int start_packet_header = 0;
+    UChar *QPMB = video->QPMB;
+    Int QP;
+    Int mbnum = 0, slice_counter = 0;
+    Int num_bits, packet_size = encParams->ResyncPacketsize;
+    BitstreamEncVideo *bs1 = video->bitstream1;
+    BitstreamEncVideo *bs2 = video->bitstream2;
+    BitstreamEncVideo *bs3 = video->bitstream3;
+    Int numHeaderBits;
+    approxDCT fastDCTfunction;
+    Int ncoefblck[6] = {64, 64, 64, 64, 64, 64}; /* for FastCodeMB,  5/18/2001 */
+    PV_STATUS(*CodeMB)(VideoEncData *, approxDCT *, Int, Int[]);
+    void (*MBVlcEncode)(VideoEncData*, Int[], void *);
+    void (*BlockCodeCoeff)(RunLevelBlock*, BitstreamEncVideo*, Int, Int, UChar);
+
+    video->QP_prev = currVop->quantizer;
+
+    numHeaderBits = BitstreamGetPos(bs1); /* Number of bits in VOP Header */
+
+    /* determine type of quantization   */
+#ifndef NO_MPEG_QUANT
+    if (currVol->quantType == 0)
+        CodeMB = &CodeMB_H263;
+    else
+        CodeMB = &CodeMB_MPEG;
+#else
+    CodeMB = &CodeMB_H263;
+#endif
+
+    /* determine which functions to be used, in MB-level */
+    if (currVop->predictionType == P_VOP)
+        MBVlcEncode = &MBVlcEncodeDataPar_P_VOP;
+    else if (currVop->predictionType == I_VOP)
+        MBVlcEncode = &MBVlcEncodeDataPar_I_VOP;
+    else /* B_VOP not implemented yet */
+        return PV_FAIL;
+
+    /* determine which VLC table to be used */
+    if (currVol->shortVideoHeader)
+        BlockCodeCoeff = &BlockCodeCoeff_ShortHeader;
+#ifndef NO_RVLC
+    else if (currVol->useReverseVLC)
+        BlockCodeCoeff = &BlockCodeCoeff_RVLC;
+#endif
+    else
+        BlockCodeCoeff = &BlockCodeCoeff_Normal;
+
+    video->usePrevQP = 0;
+
+    for (ind_y = 0; ind_y < currVol->nMBPerCol; ind_y++)    /* Col MB Loop */
+    {
+
+        video->outputMB->mb_y = ind_y; /*  5/28/01 */
+
+        for (ind_x = 0; ind_x < currVol->nMBPerRow; ind_x++)  /* Row MB Loop */
+        {
+            video->outputMB->mb_x = ind_x; /*  5/28/01 */
+            video->mbnum = mbnum;
+            video->sliceNo[mbnum] = slice_counter;      /* Update MB slice number */
+            QP = QPMB[mbnum];   /* always read new QP */
+
+            /****************************************************************************************/
+            /* MB Prediction:Put into MC macroblock, substract from currVop, put in predMB */
+            /****************************************************************************************/
+
+            getMotionCompensatedMB(video, ind_x, ind_y, offset);
+
+            if (start_packet_header)
+            {
+                slice_counter++;                        /* Increment slice counter */
+                video->sliceNo[mbnum] = slice_counter;  /* Update MB slice number*/
+                video->header_bits -= BitstreamGetPos(bs1); /* Header Bits */
+                video->QP_prev = currVop->quantizer;                        /* store QP */
+                status = EncodeVideoPacketHeader(video, mbnum, video->QP_prev, 0);
+                video->header_bits += BitstreamGetPos(bs1); /* Header Bits */
+                numHeaderBits = BitstreamGetPos(bs1);
+                start_packet_header = 0;
+                video->usePrevQP = 0;
+            }
+
+            /***********************************************/
+            /* Code_MB:  DCT, Q, Q^(-1), IDCT, Motion Comp */
+            /***********************************************/
+
+            status = (*CodeMB)(video, &fastDCTfunction, (offset << 5) + QP, ncoefblck);
+
+            /************************************/
+            /* MB VLC Encode: VLC Encode MB     */
+            /************************************/
+
+            MBVlcEncode(video, ncoefblck, (void*)BlockCodeCoeff);
+
+            /*************************************************************/
+            /* Assemble Packets:  Assemble the MB VLC codes into Packets */
+            /*************************************************************/
+
+            /* INCLUDE VOP HEADER IN COUNT */
+
+            num_bits = BitstreamGetPos(bs1) + BitstreamGetPos(bs2) +
+                       BitstreamGetPos(bs3) - numHeaderBits;
+
+            /* Assemble_Packet(video) */
+
+            if (num_bits > packet_size)
+            {
+                if (video->currVop->predictionType == I_VOP)
+                    BitstreamPutGT16Bits(bs1, 19, DC_MARKER);   /* Add dc_marker */
+                else
+                    BitstreamPutGT16Bits(bs1, 17, MOTION_MARKER_COMB); /*Add motion_marker*/
+                BitstreamAppendEnc(bs1, bs2);   /* Combine bs1 and bs2 */
+                BitstreamAppendEnc(bs1, bs3);   /* Combine bs1 and bs3 */
+                video->header_bits += BitstreamMpeg4ByteAlignStuffing(bs1); /* Byte align Packet */
+
+                status = BitstreamAppendPacket(currVol->stream, bs1); /* Put Packet to Buffer */
+                /* continue even if status == PV_END_OF_BUF, to get the stats */
+
+                BitstreamEncReset(bs1); /* Initialize to 0 */
+                BitstreamEncReset(bs2);
+                BitstreamEncReset(bs3);
+                start_packet_header = 1;
+            }
+            mbnum++;
+            offset += 16;
+        } /* End of For ind_x */
+
+        offset += (lx << 4) - width;
+    } /* End of For ind_y */
+
+    if (!start_packet_header)
+    {
+        if (video->currVop->predictionType == I_VOP)
+        {
+            BitstreamPutGT16Bits(bs1, 19, DC_MARKER);   /* Add dc_marker */
+            video->header_bits += 19;
+        }
+        else
+        {
+            BitstreamPutGT16Bits(bs1, 17, MOTION_MARKER_COMB); /* Add motion_marker */
+            video->header_bits += 17;
+        }
+        BitstreamAppendEnc(bs1, bs2);
+        BitstreamAppendEnc(bs1, bs3);
+        video->header_bits += BitstreamMpeg4ByteAlignStuffing(bs1); /* Byte align Packet */
+        status = BitstreamAppendPacket(currVol->stream, bs1); /* Put Packet to Buffer */
+        /* continue even if status == PV_END_OF_BUF, to get the stats */
+        BitstreamEncReset(bs1); /* Initialize to 0 */
+        BitstreamEncReset(bs2);
+        BitstreamEncReset(bs3);
+    }
+
+    return status; /* if status == PV_END_OF_BUF, this frame will be pre-skipped */
+}
+
+#ifndef  NO_SLICE_ENCODE
+/* ======================================================================== */
+/*  Function : EncodeSliceDataPartMode()                                    */
+/*  Date     : 04/19/2002                                                   */
+/*  History  :                                                              */
+/*  Purpose  : Encode a slice of MPEG4 bitstream in DataPar mode and save   */
+/*              the current MB to continue next time it is called.          */
+/*  In/out   :                                                              */
+/*  Return   :  PV_SUCCESS if successful else PV_FAIL                       */
+/*  Modified :                                                              */
+/*                                                                          */
+/* ======================================================================== */
+PV_STATUS EncodeSliceDataPartMode(VideoEncData *video)
+{
+    PV_STATUS status = PV_SUCCESS;
+    Vol *currVol = video->vol[video->currLayer];
+    Vop *currVop = video->currVop;
+    UChar mode, *Mode = video->headerInfo.Mode;
+    VideoEncParams *encParams = video->encParams;
+    Int nTotalMB = currVol->nTotalMB;
+    Int width = currVop->width; /* has to be Vop, for multiple of 16 */
+    Int lx = currVop->pitch; /* , with pading */
+    UChar *QPMB = video->QPMB;
+    Int QP;
+    Int ind_x = video->outputMB->mb_x, ind_y = video->outputMB->mb_y;
+    Int offset = video->offset;                 /* get current MB location */
+    Int mbnum = video->mbnum, slice_counter = video->sliceNo[mbnum]; /* get current MB location */
+    Int firstMB = mbnum;
+    Int start_packet_header = (mbnum != 0);
+    Int num_bits = 0;
+    Int packet_size = encParams->ResyncPacketsize - 1 - (currVop->predictionType == I_VOP ? 19 : 17);
+    BitstreamEncVideo *bs1 = video->bitstream1;
+    BitstreamEncVideo *bs2 = video->bitstream2;
+    BitstreamEncVideo *bs3 = video->bitstream3;
+    Int bitCount1 = 0, bitCount2 = 0, bitCount3 = 0, byteCount1 = 0, byteCount2 = 0, byteCount3 = 0;
+    Int numHeaderBits = 0;
+    approxDCT fastDCTfunction;
+    Int ncoefblck[6] = {64, 64, 64, 64, 64, 64}; /* for FastCodeMB,  5/18/2001 */
+    UChar CBP;
+    Short outputMB[6][64];
+    PV_STATUS(*CodeMB)(VideoEncData *, approxDCT *, Int, Int[]);
+    void (*MBVlcEncode)(VideoEncData*, Int[], void *);
+    void (*BlockCodeCoeff)(RunLevelBlock*, BitstreamEncVideo*, Int, Int, UChar);
+    Int k;
+
+    video->QP_prev = 31;
+
+    if (video->end_of_buf) /* left-over from previous run */
+    {
+        status = BitstreamAppendPacketNoOffset(currVol->stream, bs1);
+        if (status != PV_END_OF_BUF)
+        {
+            BitstreamEncReset(bs1);
+            video->end_of_buf = 0;
+        }
+        return status;
+    }
+
+    if (mbnum == 0) /* only do this at the start of a frame */
+    {
+        QPMB[0] = video->QP_prev = QP = currVop->quantizer;
+        video->usePrevQP = 0;
+
+        numHeaderBits = BitstreamGetPos(bs1); /* Number of bits in VOP Header */
+
+    }
+
+
+    /* Re-assign fast functions on every slice, don't have to put it in the memory */
+    QP = QPMB[mbnum];
+    if (mbnum > 0)   video->QP_prev = QPMB[mbnum-1];
+
+    /* determine type of quantization   */
+#ifndef NO_MPEG_QUANT
+    if (currVol->quantType == 0)
+        CodeMB = &CodeMB_H263;
+    else
+        CodeMB = &CodeMB_MPEG;
+#else
+    CodeMB = &CodeMB_H263;
+#endif
+
+    /* determine which functions to be used, in MB-level */
+    if (currVop->predictionType == P_VOP)
+        MBVlcEncode = &MBVlcEncodeDataPar_P_VOP;
+    else if (currVop->predictionType == I_VOP)
+        MBVlcEncode = &MBVlcEncodeDataPar_I_VOP;
+    else /* B_VOP not implemented yet */
+        return PV_FAIL;
+
+    /* determine which VLC table to be used */
+#ifndef NO_RVLC
+    if (currVol->useReverseVLC)
+        BlockCodeCoeff = &BlockCodeCoeff_RVLC;
+    else
+#endif
+        BlockCodeCoeff = &BlockCodeCoeff_Normal;
+
+    if (mbnum != 0)
+    {
+        goto JUMP_IN;
+    }
+
+    for (ind_y = 0; ind_y < currVol->nMBPerCol; ind_y++)    /* Col MB Loop */
+    {
+
+        video->outputMB->mb_y = ind_y; /*  5/28/01 */
+
+        for (ind_x = 0; ind_x < currVol->nMBPerRow; ind_x++)  /* Row MB Loop */
+        {
+
+            video->outputMB->mb_x = ind_x; /*  5/28/01 */
+            video->mbnum = mbnum;
+            video->sliceNo[mbnum] = slice_counter;      /* Update MB slice number */
+
+            /****************************************************************************************/
+            /* MB Prediction:Put into MC macroblock, substract from currVop, put in predMB */
+            /****************************************************************************************/
+            getMotionCompensatedMB(video, ind_x, ind_y, offset);
+
+JUMP_IN:
+
+            QP = QPMB[mbnum];   /* always read new QP */
+
+            if (start_packet_header)
+            {
+                slice_counter++;                        /* Increment slice counter */
+                video->sliceNo[mbnum] = slice_counter;  /* Update MB slice number*/
+                video->QP_prev = currVop->quantizer;                        /* store QP */
+                num_bits = BitstreamGetPos(bs1);
+                status = EncodeVideoPacketHeader(video, mbnum, video->QP_prev, 0);
+                numHeaderBits = BitstreamGetPos(bs1) - num_bits;
+                video->header_bits += numHeaderBits; /* Header Bits */
+                start_packet_header = 0;
+                video->usePrevQP = 0;
+            }
+            else  /* don't encode the first MB in packet again */
+            {
+                /***********************************************/
+                /* Code_MB:  DCT, Q, Q^(-1), IDCT, Motion Comp */
+                /***********************************************/
+
+                status = (*CodeMB)(video, &fastDCTfunction, (offset << 5) + QP, ncoefblck);
+                for (k = 0; k < 6; k++)
+                {
+                    M4VENC_MEMCPY(outputMB[k], video->outputMB->block[k], sizeof(Short) << 6);
+                }
+            }
+
+            /************************************/
+            /* MB VLC Encode: VLC Encode MB     */
+            /************************************/
+
+            /* save the state before VLC encoding */
+            bitCount1 = BitstreamGetPos(bs1);
+            bitCount2 = BitstreamGetPos(bs2);
+            bitCount3 = BitstreamGetPos(bs3);
+            byteCount1 = bitCount1 >> 3;
+            byteCount2 = bitCount2 >> 3;
+            byteCount3 = bitCount3 >> 3;
+            bitCount1 &= 0x7;
+            bitCount2 &= 0x7;
+            bitCount3 &= 0x7;
+            mode = Mode[mbnum];
+            CBP = video->headerInfo.CBP[mbnum];
+
+            /*************************************/
+
+            MBVlcEncode(video, ncoefblck, (void*)BlockCodeCoeff);
+
+            /*************************************************************/
+            /* Assemble Packets:  Assemble the MB VLC codes into Packets */
+            /*************************************************************/
+
+            num_bits = BitstreamGetPos(bs1) + BitstreamGetPos(bs2) +
+                       BitstreamGetPos(bs3);// - numHeaderBits; //include header bits
+
+            /* Assemble_Packet(video) */
+            if (num_bits > packet_size && mbnum != firstMB)  /* encoding at least one more MB*/
+            {
+
+                BitstreamRepos(bs1, byteCount1, bitCount1); /* rewind one MB */
+                BitstreamRepos(bs2, byteCount2, bitCount2); /* rewind one MB */
+                BitstreamRepos(bs3, byteCount3, bitCount3); /* rewind one MB */
+
+                if (video->currVop->predictionType == I_VOP)
+                {
+                    BitstreamPutGT16Bits(bs1, 19, DC_MARKER);   /* Add dc_marker */
+                    video->header_bits += 19;
+                }
+                else
+                {
+                    BitstreamPutGT16Bits(bs1, 17, MOTION_MARKER_COMB); /*Add motion_marker*/
+                    video->header_bits += 17;
+                }
+
+                status = BitstreamAppendEnc(bs1, bs2);  /* Combine with bs2 */
+                status = BitstreamAppendEnc(bs1, bs3);  /* Combine with bs3 */
+
+                video->header_bits += BitstreamMpeg4ByteAlignStuffing(bs1); /* Byte align Packet */
+                status = BitstreamAppendPacketNoOffset(currVol->stream, bs1);
+
+                BitstreamEncReset(bs2);
+                BitstreamEncReset(bs3);
+
+                if (status == PV_END_OF_BUF) /* if cannot fit a buffer */
+                {
+                    video->end_of_buf = 1;
+                }
+                else
+                {
+                    BitstreamEncReset(bs1);
+                }
+
+                start_packet_header = 1;
+
+                if (mbnum < nTotalMB || video->end_of_buf) /* return here */
+                {
+                    video->mbnum = mbnum;
+                    video->sliceNo[mbnum] = slice_counter;
+                    video->offset = offset;
+                    Mode[mbnum] = mode;
+                    video->headerInfo.CBP[mbnum] = CBP;
+
+                    for (k = 0; k < 6; k++)
+                    {
+                        M4VENC_MEMCPY(video->outputMB->block[k], outputMB[k], sizeof(Short) << 6);
+                    }
+
+                    return status;
+                }
+            }
+
+            offset += 16;
+            mbnum++; /* has to increment before SCD, to preserve Mode[mbnum] */
+        } /* End of For ind_x */
+
+        offset += (lx << 4) - width;
+
+    } /* End of For ind_y */
+
+    if (!start_packet_header)
+    {
+        if (video->currVop->predictionType == I_VOP)
+        {
+            BitstreamPutGT16Bits(bs1, 19, DC_MARKER);   /* Add dc_marker */
+            video->header_bits += 19;
+        }
+        else
+        {
+            BitstreamPutGT16Bits(bs1, 17, MOTION_MARKER_COMB); /*Add motion_marker*/
+            video->header_bits += 17;
+        }
+
+        status = BitstreamAppendEnc(bs1, bs2);  /* Combine with bs2 */
+        status = BitstreamAppendEnc(bs1, bs3);  /* Combine with bs3 */
+
+        video->header_bits += BitstreamMpeg4ByteAlignStuffing(bs1); /* Byte align Packet */
+        status = BitstreamAppendPacketNoOffset(currVol->stream, bs1);
+
+        BitstreamEncReset(bs2);
+        BitstreamEncReset(bs3);
+
+        if (status == PV_END_OF_BUF)
+        {
+            video->end_of_buf = 1;
+        }
+        else
+        {
+            BitstreamEncReset(bs1);
+        }
+    }
+
+    video->mbnum = mbnum;
+    if (mbnum < nTotalMB)
+        video->sliceNo[mbnum] = slice_counter;
+    video->offset = offset;
+
+    return status;
+}
+#endif /* NO_SLICE_ENCODE */
+#endif /* H263_ONLY */
+
+
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/dct.cpp b/media/libstagefright/codecs/m4v_h263/enc/src/dct.cpp
new file mode 100644
index 0000000..fa50eeb
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/dct.cpp
@@ -0,0 +1,1283 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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 "mp4enc_lib.h"
+#include "mp4lib_int.h"
+#include "dct_inline.h"
+
+#define FDCT_SHIFT 10
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    /**************************************************************************/
+    /*  Function:   BlockDCT_AANwSub
+        Date:       7/31/01
+        Input:
+        Output:     out[64] ==> next block
+        Purpose:    Do subtraction for zero MV first
+        Modified:
+    **************************************************************************/
+
+    Void BlockDCT_AANwSub(Short *out, UChar *cur, UChar *pred, Int width)
+    {
+        Short *dst;
+        Int k0, k1, k2, k3, k4, k5, k6, k7;
+        Int round;
+        Int k12 = 0x022A02D4;
+        Int k14 = 0x0188053A;
+        Int abs_sum;
+        Int mask;
+        Int tmp, tmp2;
+        Int ColTh;
+
+        dst = out + 64 ;
+        ColTh = *dst;
+        out += 128;
+        round = 1 << (FDCT_SHIFT - 1);
+
+        do  /* fdct_nextrow */
+        {
+            /* assuming the block is word-aligned */
+            mask = 0x1FE;
+            tmp = *((Int*) cur);    /* contains 4 pixels */
+            tmp2 = *((Int*) pred); /* prediction 4 pixels */
+            k0 = tmp2 & 0xFF;
+            k1 = mask & (tmp << 1);
+            k0 = k1 - (k0 << 1);
+            k1 = (tmp2 >> 8) & 0xFF;
+            k2 = mask & (tmp >> 7);
+            k1 = k2 - (k1 << 1);
+            k2 = (tmp2 >> 16) & 0xFF;
+            k3 = mask & (tmp >> 15);
+            k2 = k3 - (k2 << 1);
+            k3 = (tmp2 >> 24) & 0xFF;
+            k4 = mask & (tmp >> 23);
+            k3 = k4 - (k3 << 1);
+            tmp = *((Int*)(cur + 4));   /* another 4 pixels */
+            tmp2 = *((Int*)(pred + 4));
+            k4 = tmp2 & 0xFF;
+            k5 = mask & (tmp << 1);
+            k4 = k5 - (k4 << 1);
+            k5 = (tmp2 >> 8) & 0xFF;
+            k6 = mask & (tmp >> 7);
+            k5 = k6 - (k5 << 1);
+            k6 = (tmp2 >> 16) & 0xFF;
+            k7 = mask & (tmp >> 15);
+            k6 = k7 - (k6 << 1);
+            k7 = (tmp2 >> 24) & 0xFF;
+            tmp = mask & (tmp >> 23);
+            k7 = tmp - (k7 << 1);
+            cur += width;
+            pred += 16;
+
+            /* fdct_1 */
+            k0 = k0 + k7;
+            k7 = k0 - (k7 << 1);
+            k1 = k1 + k6;
+            k6 = k1 - (k6 << 1);
+            k2 = k2 + k5;
+            k5 = k2 - (k5 << 1);
+            k3 = k3 + k4;
+            k4 = k3 - (k4 << 1);
+
+            k0 = k0 + k3;
+            k3 = k0 - (k3 << 1);
+            k1 = k1 + k2;
+            k2 = k1 - (k2 << 1);
+
+            k0 = k0 + k1;
+            k1 = k0 - (k1 << 1);
+            /**********/
+            dst[0] = k0;
+            dst[4] = k1; /* col. 4 */
+            /* fdct_2 */
+            k4 = k4 + k5;
+            k5 = k5 + k6;
+            k6 = k6 + k7;
+            k2 = k2 + k3;
+            /* MUL2C k2,k5,724,FDCT_SHIFT */
+            /* k0, k1 become scratch */
+            /* assume FAST MULTIPLY */
+            k1 = mla724(k12, k5, round);
+            k0 = mla724(k12, k2, round);
+
+            k5 = k1 >> FDCT_SHIFT;
+            k2 = k0 >> FDCT_SHIFT;
+            /*****************/
+            k2 = k2 + k3;
+            k3 = (k3 << 1) - k2;
+            /********/
+            dst[2] = k2;        /* col. 2 */
+            k3 <<= 1;       /* scale up col. 6 */
+            dst[6] = k3; /* col. 6 */
+            /* fdct_3 */
+            /* ROTATE k4,k6,392,946, FDCT_SHIFT */
+            /* assume FAST MULTIPLY */
+            /* k0, k1 are output */
+            k0 = k4 - k6;
+
+            k1 = mla392(k0, k14, round);
+            k0 = mla554(k4, k12, k1);
+            k1 = mla1338(k6, k14, k1);
+
+            k4 = k0 >> FDCT_SHIFT;
+            k6 = k1 >> FDCT_SHIFT;
+            /***********************/
+            k5 = k5 + k7;
+            k7 = (k7 << 1) - k5;
+            k4 = k4 + k7;
+            k7 = (k7 << 1) - k4;
+            k5 = k5 + k6;
+            k4 <<= 1;       /* scale up col.5 */
+            k6 = k5 - (k6 << 1);
+            /********/
+            dst[5] = k4;    /* col. 5 */
+            k6 <<= 2;       /* scale up col. 7 */
+            dst[1] = k5;    /* col. 1 */
+            dst[7] = k6;    /* col. 7 */
+            dst[3] = k7;    /* col. 3 */
+            dst += 8;
+        }
+        while (dst < out);
+
+        out -= 64;
+        dst = out + 8;
+
+        /*  Vertical Block Loop  */
+        do  /* Vertical 8xDCT loop */
+        {
+            k0 = out[0];
+            k1 = out[8];
+            k2 = out[16];
+            k3 = out[24];
+            k4 = out[32];
+            k5 = out[40];
+            k6 = out[48];
+            k7 = out[56];
+            /* deadzone thresholding for column */
+
+            abs_sum = sum_abs(k0, k1, k2, k3, k4, k5, k6, k7);
+
+            if (abs_sum < ColTh)
+            {
+                out[0] = 0x7fff;
+                out++;
+                continue;
+            }
+
+            /* fdct_1 */
+            k0 = k0 + k7;
+            k7 = k0 - (k7 << 1);
+            k1 = k1 + k6;
+            k6 = k1 - (k6 << 1);
+            k2 = k2 + k5;
+            k5 = k2 - (k5 << 1);
+            k3 = k3 + k4;
+            k4 = k3 - (k4 << 1);
+
+            k0 = k0 + k3;
+            k3 = k0 - (k3 << 1);
+            k1 = k1 + k2;
+            k2 = k1 - (k2 << 1);
+
+            k0 = k0 + k1;
+            k1 = k0 - (k1 << 1);
+            /**********/
+            out[32] = k1; /* row 4 */
+            out[0] = k0; /* row 0 */
+            /* fdct_2 */
+            k4 = k4 + k5;
+            k5 = k5 + k6;
+            k6 = k6 + k7;
+            k2 = k2 + k3;
+            /* MUL2C k2,k5,724,FDCT_SHIFT */
+            /* k0, k1 become scratch */
+            /* assume FAST MULTIPLY */
+            k1 = mla724(k12, k5, round);
+            k0 = mla724(k12, k2, round);
+
+            k5 = k1 >> FDCT_SHIFT;
+            k2 = k0 >> FDCT_SHIFT;
+            /*****************/
+            k2 = k2 + k3;
+            k3 = (k3 << 1) - k2;
+            k3 <<= 1;       /* scale up col. 6 */
+            /********/
+            out[48] = k3;   /* row 6 */
+            out[16] = k2;   /* row 2 */
+            /* fdct_3 */
+            /* ROTATE k4,k6,392,946, FDCT_SHIFT */
+            /* assume FAST MULTIPLY */
+            /* k0, k1 are output */
+            k0 = k4 - k6;
+
+            k1 = mla392(k0, k14, round);
+            k0 = mla554(k4, k12, k1);
+            k1 = mla1338(k6, k14, k1);
+
+            k4 = k0 >> FDCT_SHIFT;
+            k6 = k1 >> FDCT_SHIFT;
+            /***********************/
+            k5 = k5 + k7;
+            k7 = (k7 << 1) - k5;
+            k4 = k4 + k7;
+            k7 = (k7 << 1) - k4;
+            k5 = k5 + k6;
+            k4 <<= 1;       /* scale up col. 5 */
+            k6 = k5 - (k6 << 1);
+            /********/
+            out[24] = k7 ;    /* row 3 */
+            k6 <<= 2;       /* scale up col. 7 */
+            out[56] = k6 ;   /* row 7 */
+            out[8] = k5 ;    /* row 1 */
+            out[40] = k4 ;   /* row 5 */
+            out++;
+        }
+        while ((UInt)out < (UInt)dst) ;
+
+        return ;
+    }
+
+    /**************************************************************************/
+    /*  Function:   Block4x4DCT_AANwSub
+        Date:       7/31/01
+        Input:
+        Output:     out[64] ==> next block
+        Purpose:    Do subtraction for zero MV first before 4x4 DCT
+        Modified:
+    **************************************************************************/
+
+    Void Block4x4DCT_AANwSub(Short *out, UChar *cur, UChar *pred, Int width)
+    {
+        Short *dst;
+        register Int k0, k1, k2, k3, k4, k5, k6, k7;
+        Int round;
+        Int k12 = 0x022A02D4;
+        Int k14 = 0x0188053A;
+        Int mask;
+        Int tmp, tmp2;
+        Int abs_sum;
+        Int ColTh;
+
+        dst = out + 64 ;
+        ColTh = *dst;
+        out += 128;
+        round = 1 << (FDCT_SHIFT - 1);
+
+        do  /* fdct_nextrow */
+        {
+            /* assuming the block is word-aligned */
+            mask = 0x1FE;
+            tmp = *((Int*) cur);    /* contains 4 pixels */
+            tmp2 = *((Int*) pred); /* prediction 4 pixels */
+            k0 = tmp2 & 0xFF;
+            k1 = mask & (tmp << 1);
+            k0 = k1 - (k0 << 1);
+            k1 = (tmp2 >> 8) & 0xFF;
+            k2 = mask & (tmp >> 7);
+            k1 = k2 - (k1 << 1);
+            k2 = (tmp2 >> 16) & 0xFF;
+            k3 = mask & (tmp >> 15);
+            k2 = k3 - (k2 << 1);
+            k3 = (tmp2 >> 24) & 0xFF;
+            k4 = mask & (tmp >> 23);
+            k3 = k4 - (k3 << 1);
+            tmp = *((Int*)(cur + 4));   /* another 4 pixels */
+            tmp2 = *((Int*)(pred + 4));
+            k4 = tmp2 & 0xFF;
+            k5 = mask & (tmp << 1);
+            k4 = k5 - (k4 << 1);
+            k5 = (tmp2 >> 8) & 0xFF;
+            k6 = mask & (tmp >> 7);
+            k5 = k6 - (k5 << 1);
+            k6 = (tmp2 >> 16) & 0xFF;
+            k7 = mask & (tmp >> 15);
+            k6 = k7 - (k6 << 1);
+            k7 = (tmp2 >> 24) & 0xFF;
+            tmp = mask & (tmp >> 23);
+            k7 = tmp - (k7 << 1);
+            cur += width;
+            pred += 16;
+
+            /* fdct_1 */
+            k0 = k0 + k7;
+            k7 = k0 - (k7 << 1);
+            k1 = k1 + k6;
+            k6 = k1 - (k6 << 1);
+            k2 = k2 + k5;
+            k5 = k2 - (k5 << 1);
+            k3 = k3 + k4;
+            k4 = k3 - (k4 << 1);
+
+            k0 = k0 + k3;
+            k3 = k0 - (k3 << 1);
+            k1 = k1 + k2;
+            k2 = k1 - (k2 << 1);
+
+            k0 = k0 + k1;
+            /**********/
+            dst[0] = k0;
+            /* fdct_2 */
+            k4 = k4 + k5;
+            k5 = k5 + k6;
+            k6 = k6 + k7;
+            k2 = k2 + k3;
+            /* MUL2C k2,k5,724,FDCT_SHIFT */
+            /* k0, k1 become scratch */
+            /* assume FAST MULTIPLY */
+            k1 = mla724(k12, k5, round);
+            k0 = mla724(k12, k2, round);
+
+            k5 = k1 >> FDCT_SHIFT;
+            k2 = k0 >> FDCT_SHIFT;
+            /*****************/
+            k2 = k2 + k3;
+            /********/
+            dst[2] = k2;        /* col. 2 */
+            /* fdct_3 */
+            /* ROTATE k4,k6,392,946, FDCT_SHIFT */
+            /* assume FAST MULTIPLY */
+            /* k0, k1 are output */
+            k0 = k4 - k6;
+
+            k1 = mla392(k0, k14, round);
+            k0 = mla554(k4, k12, k1);
+            k1 = mla1338(k6, k14, k1);
+
+            k4 = k0 >> FDCT_SHIFT;
+            k6 = k1 >> FDCT_SHIFT;
+            /***********************/
+            k5 = k5 + k7;
+            k7 = (k7 << 1) - k5;
+            k7 = k7 - k4;
+            k5 = k5 + k6;
+            /********/
+            dst[1] = k5;        /* col. 1 */
+            dst[3] = k7;        /* col. 3 */
+            dst += 8;
+        }
+        while (dst < out);
+
+        out -= 64;
+        dst = out + 4;
+
+        /*  Vertical Block Loop  */
+        do  /* Vertical 8xDCT loop */
+        {
+            k0 = out[0];
+            k1 = out[8];
+            k2 = out[16];
+            k3 = out[24];
+            k4 = out[32];
+            k5 = out[40];
+            k6 = out[48];
+            k7 = out[56];
+
+            abs_sum = sum_abs(k0, k1, k2, k3, k4, k5, k6, k7);
+
+            if (abs_sum < ColTh)
+            {
+                out[0] = 0x7fff;
+                out++;
+                continue;
+            }
+            /* fdct_1 */
+            k0 = k0 + k7;
+            k7 = k0 - (k7 << 1);
+            k1 = k1 + k6;
+            k6 = k1 - (k6 << 1);
+            k2 = k2 + k5;
+            k5 = k2 - (k5 << 1);
+            k3 = k3 + k4;
+            k4 = k3 - (k4 << 1);
+
+            k0 = k0 + k3;
+            k3 = k0 - (k3 << 1);
+            k1 = k1 + k2;
+            k2 = k1 - (k2 << 1);
+
+            k0 = k0 + k1;
+            /**********/
+            out[0] = k0;   /* row 0 */
+            /* fdct_2 */
+            k4 = k4 + k5;
+            k5 = k5 + k6;
+            k6 = k6 + k7;
+            k2 = k2 + k3;
+            /* MUL2C k2,k5,724,FDCT_SHIFT */
+            /* k0, k1 become scratch */
+            /* assume FAST MULTIPLY */
+            k1 = mla724(k12, k5, round);
+            k0 = mla724(k12, k2, round);
+
+            k5 = k1 >> FDCT_SHIFT;
+            k2 = k0 >> FDCT_SHIFT;
+            /*****************/
+            k2 = k2 + k3;
+            /********/
+            out[16] = k2;           /* row 2 */
+            /* fdct_3 */
+            /* ROTATE k4,k6,392,946, FDCT_SHIFT */
+            /* assume FAST MULTIPLY */
+            /* k0, k1 are output */
+            k0 = k4 - k6;
+
+            k1 = mla392(k0, k14, round);
+            k0 = mla554(k4, k12, k1);
+            k1 = mla1338(k6, k14, k1);
+
+            k4 = k0 >> FDCT_SHIFT;
+            k6 = k1 >> FDCT_SHIFT;
+            /***********************/
+            k5 = k5 + k7;
+            k7 = (k7 << 1) - k5;
+            k7 = k7 - k4 ;
+            k5 = k5 + k6;
+            /********/
+            out[24] = k7 ;      /* row 3 */
+            out[8] = k5 ;       /* row 1 */
+            out++;
+        }
+        while ((UInt)out < (UInt)dst) ;
+
+        return ;
+    }
+
+    /**************************************************************************/
+    /*  Function:   Block2x2DCT_AANwSub
+        Date:       7/31/01
+        Input:
+        Output:     out[64] ==> next block
+        Purpose:    Do subtraction for zero MV first before 2x2 DCT
+        Modified:
+    **************************************************************************/
+
+
+    Void Block2x2DCT_AANwSub(Short *out, UChar *cur, UChar *pred, Int width)
+    {
+        Short *dst;
+        register Int k0, k1, k2, k3, k4, k5, k6, k7;
+        Int round;
+        Int k12 = 0x022A02D4;
+        Int k14 = 0x018803B2;
+        Int mask;
+        Int tmp, tmp2;
+        Int abs_sum;
+        Int ColTh;
+
+        dst = out + 64 ;
+        ColTh = *dst;
+        out += 128;
+        round = 1 << (FDCT_SHIFT - 1);
+
+        do  /* fdct_nextrow */
+        {
+            /* assuming the block is word-aligned */
+            mask = 0x1FE;
+            tmp = *((Int*) cur);    /* contains 4 pixels */
+            tmp2 = *((Int*) pred); /* prediction 4 pixels */
+            k0 = tmp2 & 0xFF;
+            k1 = mask & (tmp << 1);
+            k0 = k1 - (k0 << 1);
+            k1 = (tmp2 >> 8) & 0xFF;
+            k2 = mask & (tmp >> 7);
+            k1 = k2 - (k1 << 1);
+            k2 = (tmp2 >> 16) & 0xFF;
+            k3 = mask & (tmp >> 15);
+            k2 = k3 - (k2 << 1);
+            k3 = (tmp2 >> 24) & 0xFF;
+            k4 = mask & (tmp >> 23);
+            k3 = k4 - (k3 << 1);
+            tmp = *((Int*)(cur + 4));   /* another 4 pixels */
+            tmp2 = *((Int*)(pred + 4));
+            k4 = tmp2 & 0xFF;
+            k5 = mask & (tmp << 1);
+            k4 = k5 - (k4 << 1);
+            k5 = (tmp2 >> 8) & 0xFF;
+            k6 = mask & (tmp >> 7);
+            k5 = k6 - (k5 << 1);
+            k6 = (tmp2 >> 16) & 0xFF;
+            k7 = mask & (tmp >> 15);
+            k6 = k7 - (k6 << 1);
+            k7 = (tmp2 >> 24) & 0xFF;
+            tmp = mask & (tmp >> 23);
+            k7 = tmp - (k7 << 1);
+            cur += width;
+            pred += 16;
+
+            /* fdct_1 */
+            k0 = k0 + k7;
+            k7 = k0 - (k7 << 1);
+            k1 = k1 + k6;
+            k6 = k1 - (k6 << 1);
+            k2 = k2 + k5;
+            k5 = k2 - (k5 << 1);
+            k3 = k3 + k4;
+            k4 = k3 - (k4 << 1);
+
+            k0 = k0 + k3;
+            k3 = k0 - (k3 << 1);
+            k1 = k1 + k2;
+            k2 = k1 - (k2 << 1);
+
+            k0 = k0 + k1;
+            /**********/
+            dst[0] = k0;
+            /* fdct_2 */
+            k4 = k4 + k5;
+            k5 = k5 + k6;
+            k6 = k6 + k7;
+            /* MUL2C k2,k5,724,FDCT_SHIFT */
+            /* k0, k1 become scratch */
+            /* assume FAST MULTIPLY */
+            k1 = mla724(k12, k5, round);
+
+            k5 = k1 >> FDCT_SHIFT;
+            /*****************/
+            /********/
+            /* fdct_3 */
+            /* ROTATE k4,k6,392,946, FDCT_SHIFT */
+            /* assume FAST MULTIPLY */
+            /* k0, k1 are output */
+            k1 = mla392(k4, k14, round);
+            k1 = mla946(k6, k14, k1);
+
+            k6 = k1 >> FDCT_SHIFT;
+            /***********************/
+            k5 = k5 + k7;
+            k5 = k5 + k6;
+            /********/
+            dst[1] = k5;
+            dst += 8;
+        }
+        while (dst < out);
+        out -= 64;
+        dst = out + 2;
+        /*  Vertical Block Loop  */
+        do  /* Vertical 8xDCT loop */
+        {
+            k0 = out[0];
+            k1 = out[8];
+            k2 = out[16];
+            k3 = out[24];
+            k4 = out[32];
+            k5 = out[40];
+            k6 = out[48];
+            k7 = out[56];
+
+            abs_sum = sum_abs(k0, k1, k2, k3, k4, k5, k6, k7);
+
+            if (abs_sum < ColTh)
+            {
+                out[0] = 0x7fff;
+                out++;
+                continue;
+            }
+            /* fdct_1 */
+            k0 = k0 + k7;
+            k7 = k0 - (k7 << 1);
+            k1 = k1 + k6;
+            k6 = k1 - (k6 << 1);
+            k2 = k2 + k5;
+            k5 = k2 - (k5 << 1);
+            k3 = k3 + k4;
+            k4 = k3 - (k4 << 1);
+
+            k0 = k0 + k3;
+            k3 = k0 - (k3 << 1);
+            k1 = k1 + k2;
+            k2 = k1 - (k2 << 1);
+
+            k0 = k0 + k1;
+            /**********/
+            out[0] = k0;        /* row 0 */
+            /* fdct_2 */
+            k4 = k4 + k5;
+            k5 = k5 + k6;
+            k6 = k6 + k7;
+            /* MUL2C k2,k5,724,FDCT_SHIFT */
+            /* k0, k1 become scratch */
+            /* assume FAST MULTIPLY */
+            k1 = mla724(k12, k5, round);
+
+            k5 = k1 >> FDCT_SHIFT;
+            /*****************/
+            /********/
+            /* fdct_3 */
+            /* ROTATE k4,k6,392,946, FDCT_SHIFT */
+            /* assume FAST MULTIPLY */
+            /* k0, k1 are output */
+            k1 = mla392(k4, k14, round);
+            k1 = mla946(k6, k14, k1);
+
+            k6 = k1 >> FDCT_SHIFT;
+            /***********************/
+            k5 = k5 + k7;
+            k5 = k5 + k6;
+            /********/
+            out[8] = k5 ;       /* row 1 */
+            out++;
+        }
+        while ((UInt)out < (UInt)dst) ;
+
+        return ;
+    }
+
+    /**************************************************************************/
+    /*  Function:   BlockDCT_AANIntra
+        Date:       8/9/01
+        Input:      rec
+        Output:     out[64] ==> next block
+        Purpose:    Input directly from rec frame.
+        Modified:
+    **************************************************************************/
+
+    Void BlockDCT_AANIntra(Short *out, UChar *cur, UChar *dummy2, Int width)
+    {
+        Short *dst;
+        Int k0, k1, k2, k3, k4, k5, k6, k7;
+        Int round;
+        Int k12 = 0x022A02D4;
+        Int k14 = 0x0188053A;
+        Int abs_sum;
+        Int mask;
+        Int *curInt, tmp;
+        Int ColTh;
+
+        OSCL_UNUSED_ARG(dummy2);
+
+        dst = out + 64 ;
+        ColTh = *dst;
+        out += 128;
+        round = 1 << (FDCT_SHIFT - 1);
+
+        do  /* fdct_nextrow */
+        {
+            mask = 0x1FE;
+            curInt = (Int*) cur;
+            tmp = curInt[0];    /* contains 4 pixels */
+            k0 = mask & (tmp << 1);
+            k1 = mask & (tmp >> 7);
+            k2 = mask & (tmp >> 15);
+            k3 = mask & (tmp >> 23);
+            tmp = curInt[1];    /* another 4 pixels */
+            k4 =  mask & (tmp << 1);
+            k5 =  mask & (tmp >> 7);
+            k6 =  mask & (tmp >> 15);
+            k7 =  mask & (tmp >> 23);
+            cur += width;
+            /* fdct_1 */
+            k0 = k0 + k7;
+            k7 = k0 - (k7 << 1);
+            k1 = k1 + k6;
+            k6 = k1 - (k6 << 1);
+            k2 = k2 + k5;
+            k5 = k2 - (k5 << 1);
+            k3 = k3 + k4;
+            k4 = k3 - (k4 << 1);
+
+            k0 = k0 + k3;
+            k3 = k0 - (k3 << 1);
+            k1 = k1 + k2;
+            k2 = k1 - (k2 << 1);
+
+            k0 = k0 + k1;
+            k1 = k0 - (k1 << 1);
+            /**********/
+            dst[0] = k0;
+            dst[4] = k1; /* col. 4 */
+            /* fdct_2 */
+            k4 = k4 + k5;
+            k5 = k5 + k6;
+            k6 = k6 + k7;
+            k2 = k2 + k3;
+            /* MUL2C k2,k5,724,FDCT_SHIFT */
+            /* k0, k1 become scratch */
+            /* assume FAST MULTIPLY */
+            k1 = mla724(k12, k5, round);
+            k0 = mla724(k12, k2, round);
+
+            k5 = k1 >> FDCT_SHIFT;
+            k2 = k0 >> FDCT_SHIFT;
+            /*****************/
+            k2 = k2 + k3;
+            k3 = (k3 << 1) - k2;
+            /********/
+            dst[2] = k2;        /* col. 2 */
+            k3 <<= 1;       /* scale up col. 6 */
+            dst[6] = k3; /* col. 6 */
+            /* fdct_3 */
+            /* ROTATE k4,k6,392,946, FDCT_SHIFT */
+            /* assume FAST MULTIPLY */
+            /* k0, k1 are output */
+            k0 = k4 - k6;
+
+            k1 = mla392(k0, k14, round);
+            k0 = mla554(k4, k12, k1);
+            k1 = mla1338(k6, k14, k1);
+
+            k4 = k0 >> FDCT_SHIFT;
+            k6 = k1 >> FDCT_SHIFT;
+            /***********************/
+            k5 = k5 + k7;
+            k7 = (k7 << 1) - k5;
+            k4 = k4 + k7;
+            k7 = (k7 << 1) - k4;
+            k5 = k5 + k6;
+            k4 <<= 1;       /* scale up col.5 */
+            k6 = k5 - (k6 << 1);
+            /********/
+            dst[5] = k4;    /* col. 5 */
+            k6 <<= 2;       /* scale up col. 7 */
+            dst[1] = k5;    /* col. 1 */
+            dst[7] = k6;    /* col. 7 */
+            dst[3] = k7;    /* col. 3 */
+            dst += 8;
+        }
+        while (dst < out);
+
+        out -= 64;
+        dst = out + 8;
+
+        /*  Vertical Block Loop  */
+        do  /* Vertical 8xDCT loop */
+        {
+            k0 = out[0];
+            k1 = out[8];
+            k2 = out[16];
+            k3 = out[24];
+            k4 = out[32];
+            k5 = out[40];
+            k6 = out[48];
+            k7 = out[56];
+            /* deadzone thresholding for column */
+
+            abs_sum = sum_abs(k0, k1, k2, k3, k4, k5, k6, k7);
+
+            if (abs_sum < ColTh)
+            {
+                out[0] = 0x7fff;
+                out++;
+                continue;
+            }
+
+            /* fdct_1 */
+            k0 = k0 + k7;
+            k7 = k0 - (k7 << 1);
+            k1 = k1 + k6;
+            k6 = k1 - (k6 << 1);
+            k2 = k2 + k5;
+            k5 = k2 - (k5 << 1);
+            k3 = k3 + k4;
+            k4 = k3 - (k4 << 1);
+
+            k0 = k0 + k3;
+            k3 = k0 - (k3 << 1);
+            k1 = k1 + k2;
+            k2 = k1 - (k2 << 1);
+
+            k0 = k0 + k1;
+            k1 = k0 - (k1 << 1);
+            /**********/
+            out[32] = k1; /* row 4 */
+            out[0] = k0; /* row 0 */
+            /* fdct_2 */
+            k4 = k4 + k5;
+            k5 = k5 + k6;
+            k6 = k6 + k7;
+            k2 = k2 + k3;
+            /* MUL2C k2,k5,724,FDCT_SHIFT */
+            /* k0, k1 become scratch */
+            /* assume FAST MULTIPLY */
+            k1 = mla724(k12, k5, round);
+            k0 = mla724(k12, k2, round);
+
+            k5 = k1 >> FDCT_SHIFT;
+            k2 = k0 >> FDCT_SHIFT;
+            /*****************/
+            k2 = k2 + k3;
+            k3 = (k3 << 1) - k2;
+            k3 <<= 1;       /* scale up col. 6 */
+            /********/
+            out[48] = k3;   /* row 6 */
+            out[16] = k2;   /* row 2 */
+            /* fdct_3 */
+            /* ROTATE k4,k6,392,946, FDCT_SHIFT */
+            /* assume FAST MULTIPLY */
+            /* k0, k1 are output */
+            k0 = k4 - k6;
+
+            k1 = mla392(k0, k14, round);
+            k0 = mla554(k4, k12, k1);
+            k1 = mla1338(k6, k14, k1);
+
+            k4 = k0 >> FDCT_SHIFT;
+            k6 = k1 >> FDCT_SHIFT;
+            /***********************/
+            k5 = k5 + k7;
+            k7 = (k7 << 1) - k5;
+            k4 = k4 + k7;
+            k7 = (k7 << 1) - k4;
+            k5 = k5 + k6;
+            k4 <<= 1;       /* scale up col. 5 */
+            k6 = k5 - (k6 << 1);
+            /********/
+            out[24] = k7 ;    /* row 3 */
+            k6 <<= 2;       /* scale up col. 7 */
+            out[56] = k6 ;   /* row 7 */
+            out[8] = k5 ;    /* row 1 */
+            out[40] = k4 ;   /* row 5 */
+            out++;
+        }
+        while ((UInt)out < (UInt)dst) ;
+
+        return ;
+    }
+
+    /**************************************************************************/
+    /*  Function:   Block4x4DCT_AANIntra
+        Date:       8/9/01
+        Input:      prev
+        Output:     out[64] ==> next block
+        Purpose:    Input directly from prev frame. output 2x2 DCT
+        Modified:
+    **************************************************************************/
+
+    Void Block4x4DCT_AANIntra(Short *out, UChar *cur, UChar *dummy2, Int width)
+    {
+        Short *dst;
+        register Int k0, k1, k2, k3, k4, k5, k6, k7;
+        Int round;
+        Int k12 = 0x022A02D4;
+        Int k14 = 0x0188053A;
+        Int mask;
+        Int *curInt, tmp;
+        Int abs_sum;
+        Int ColTh;
+
+        OSCL_UNUSED_ARG(dummy2);
+
+        dst = out + 64 ;
+        ColTh = *dst;
+        out += 128;
+        round = 1 << (FDCT_SHIFT - 1);
+
+        do  /* fdct_nextrow */
+        {
+            mask = 0x1FE;
+            curInt = (Int*) cur;
+            tmp = curInt[0];    /* contains 4 pixels */
+            k0 = mask & (tmp << 1);
+            k1 = mask & (tmp >> 7);
+            k2 = mask & (tmp >> 15);
+            k3 = mask & (tmp >> 23);
+            tmp = curInt[1];    /* another 4 pixels */
+            k4 =  mask & (tmp << 1);
+            k5 =  mask & (tmp >> 7);
+            k6 =  mask & (tmp >> 15);
+            k7 =  mask & (tmp >> 23);
+            cur += width;
+            /* fdct_1 */
+            k0 = k0 + k7;
+            k7 = k0 - (k7 << 1);
+            k1 = k1 + k6;
+            k6 = k1 - (k6 << 1);
+            k2 = k2 + k5;
+            k5 = k2 - (k5 << 1);
+            k3 = k3 + k4;
+            k4 = k3 - (k4 << 1);
+
+            k0 = k0 + k3;
+            k3 = k0 - (k3 << 1);
+            k1 = k1 + k2;
+            k2 = k1 - (k2 << 1);
+
+            k0 = k0 + k1;
+            /**********/
+            dst[0] = k0;
+            /* fdct_2 */
+            k4 = k4 + k5;
+            k5 = k5 + k6;
+            k6 = k6 + k7;
+            k2 = k2 + k3;
+            /* MUL2C k2,k5,724,FDCT_SHIFT */
+            /* k0, k1 become scratch */
+            /* assume FAST MULTIPLY */
+            k1 = mla724(k12, k5, round);
+            k0 = mla724(k12, k2, round);
+
+            k5 = k1 >> FDCT_SHIFT;
+            k2 = k0 >> FDCT_SHIFT;
+            /*****************/
+            k2 = k2 + k3;
+            /********/
+            dst[2] = k2;        /* col. 2 */
+            /* fdct_3 */
+            /* ROTATE k4,k6,392,946, FDCT_SHIFT */
+            /* assume FAST MULTIPLY */
+            /* k0, k1 are output */
+            k0 = k4 - k6;
+
+            k1 = mla392(k0, k14, round);
+            k0 = mla554(k4, k12, k1);
+            k1 = mla1338(k6, k14, k1);
+
+            k4 = k0 >> FDCT_SHIFT;
+            k6 = k1 >> FDCT_SHIFT;
+            /***********************/
+            k5 = k5 + k7;
+            k7 = (k7 << 1) - k5;
+            k7 = k7 - k4;
+            k5 = k5 + k6;
+            /********/
+            dst[1] = k5;        /* col. 1 */
+            dst[3] = k7;        /* col. 3 */
+            dst += 8;
+        }
+        while (dst < out);
+
+        out -= 64;
+        dst = out + 4;
+
+        /*  Vertical Block Loop  */
+        do  /* Vertical 8xDCT loop */
+        {
+            k0 = out[0];
+            k1 = out[8];
+            k2 = out[16];
+            k3 = out[24];
+            k4 = out[32];
+            k5 = out[40];
+            k6 = out[48];
+            k7 = out[56];
+
+            abs_sum = sum_abs(k0, k1, k2, k3, k4, k5, k6, k7);
+
+            if (abs_sum < ColTh)
+            {
+                out[0] = 0x7fff;
+                out++;
+                continue;
+            }
+            /* fdct_1 */
+            k0 = k0 + k7;
+            k7 = k0 - (k7 << 1);
+            k1 = k1 + k6;
+            k6 = k1 - (k6 << 1);
+            k2 = k2 + k5;
+            k5 = k2 - (k5 << 1);
+            k3 = k3 + k4;
+            k4 = k3 - (k4 << 1);
+
+            k0 = k0 + k3;
+            k3 = k0 - (k3 << 1);
+            k1 = k1 + k2;
+            k2 = k1 - (k2 << 1);
+
+            k0 = k0 + k1;
+            /**********/
+            out[0] = k0;   /* row 0 */
+            /* fdct_2 */
+            k4 = k4 + k5;
+            k5 = k5 + k6;
+            k6 = k6 + k7;
+            k2 = k2 + k3;
+            /* MUL2C k2,k5,724,FDCT_SHIFT */
+            /* k0, k1 become scratch */
+            /* assume FAST MULTIPLY */
+            k1 = mla724(k12, k5, round);
+            k0 = mla724(k12, k2, round);
+
+            k5 = k1 >> FDCT_SHIFT;
+            k2 = k0 >> FDCT_SHIFT;
+            /*****************/
+            k2 = k2 + k3;
+            /********/
+            out[16] = k2;           /* row 2 */
+            /* fdct_3 */
+            /* ROTATE k4,k6,392,946, FDCT_SHIFT */
+            /* assume FAST MULTIPLY */
+            /* k0, k1 are output */
+            k0 = k4 - k6;
+
+            k1 = mla392(k0, k14, round);
+            k0 = mla554(k4, k12, k1);
+            k1 = mla1338(k6, k14, k1);
+
+            k4 = k0 >> FDCT_SHIFT;
+            k6 = k1 >> FDCT_SHIFT;
+            /***********************/
+            k5 = k5 + k7;
+            k7 = (k7 << 1) - k5;
+            k7 = k7 - k4 ;
+            k5 = k5 + k6;
+            /********/
+            out[24] = k7 ;      /* row 3 */
+            out[8] = k5 ;       /* row 1 */
+            out++;
+        }
+        while ((UInt)out < (UInt)dst) ;
+
+        return ;
+    }
+
+    /**************************************************************************/
+    /*  Function:   Block2x2DCT_AANIntra
+        Date:       8/9/01
+        Input:      prev
+        Output:     out[64] ==> next block
+        Purpose:    Input directly from prev frame. output 2x2 DCT
+        Modified:
+    **************************************************************************/
+
+    Void Block2x2DCT_AANIntra(Short *out, UChar *cur, UChar *dummy2, Int width)
+    {
+        Short *dst;
+        register Int k0, k1, k2, k3, k4, k5, k6, k7;
+        Int round;
+        Int k12 = 0x022A02D4;
+        Int k14 = 0x018803B2;
+        Int mask;
+        Int *curInt, tmp;
+        Int abs_sum;
+        Int ColTh;
+
+        OSCL_UNUSED_ARG(dummy2);
+
+        dst = out + 64 ;
+        ColTh = *dst;
+        out += 128;
+        round = 1 << (FDCT_SHIFT - 1);
+
+        do  /* fdct_nextrow */
+        {
+            mask = 0x1FE;
+            curInt = (Int*) cur;
+            tmp = curInt[0];    /* contains 4 pixels */
+            k0 = mask & (tmp << 1);
+            k1 = mask & (tmp >> 7);
+            k2 = mask & (tmp >> 15);
+            k3 = mask & (tmp >> 23);
+            tmp = curInt[1];    /* another 4 pixels */
+            k4 =  mask & (tmp << 1);
+            k5 =  mask & (tmp >> 7);
+            k6 =  mask & (tmp >> 15);
+            k7 =  mask & (tmp >> 23);
+            cur += width;
+
+            /* fdct_1 */
+            k0 = k0 + k7;
+            k7 = k0 - (k7 << 1);
+            k1 = k1 + k6;
+            k6 = k1 - (k6 << 1);
+            k2 = k2 + k5;
+            k5 = k2 - (k5 << 1);
+            k3 = k3 + k4;
+            k4 = k3 - (k4 << 1);
+
+            k0 = k0 + k3;
+            k3 = k0 - (k3 << 1);
+            k1 = k1 + k2;
+            k2 = k1 - (k2 << 1);
+
+            k0 = k0 + k1;
+            /**********/
+            dst[0] = k0;
+            /* fdct_2 */
+            k4 = k4 + k5;
+            k5 = k5 + k6;
+            k6 = k6 + k7;
+            /* MUL2C k2,k5,724,FDCT_SHIFT */
+            /* k0, k1 become scratch */
+            /* assume FAST MULTIPLY */
+            k1 = mla724(k12, k5, round);
+
+            k5 = k1 >> FDCT_SHIFT;
+            /*****************/
+            /********/
+            /* fdct_3 */
+            /* ROTATE k4,k6,392,946, FDCT_SHIFT */
+            /* assume FAST MULTIPLY */
+            /* k0, k1 are output */
+            k1 = mla392(k4, k14, round);
+            k1 = mla946(k6, k14, k1);
+
+            k6 = k1 >> FDCT_SHIFT;
+            /***********************/
+            k5 = k5 + k7;
+            k5 = k5 + k6;
+            /********/
+            dst[1] = k5;
+            dst += 8;
+        }
+        while (dst < out);
+        out -= 64;
+        dst = out + 2;
+        /*  Vertical Block Loop  */
+        do  /* Vertical 8xDCT loop */
+        {
+            k0 = out[0];
+            k1 = out[8];
+            k2 = out[16];
+            k3 = out[24];
+            k4 = out[32];
+            k5 = out[40];
+            k6 = out[48];
+            k7 = out[56];
+
+            abs_sum = sum_abs(k0, k1, k2, k3, k4, k5, k6, k7);
+
+            if (abs_sum < ColTh)
+            {
+                out[0] = 0x7fff;
+                out++;
+                continue;
+            }
+            /* fdct_1 */
+            k0 = k0 + k7;
+            k7 = k0 - (k7 << 1);
+            k1 = k1 + k6;
+            k6 = k1 - (k6 << 1);
+            k2 = k2 + k5;
+            k5 = k2 - (k5 << 1);
+            k3 = k3 + k4;
+            k4 = k3 - (k4 << 1);
+
+            k0 = k0 + k3;
+            k3 = k0 - (k3 << 1);
+            k1 = k1 + k2;
+            k2 = k1 - (k2 << 1);
+
+            k0 = k0 + k1;
+            /**********/
+            out[0] = k0;        /* row 0 */
+            /* fdct_2 */
+            k4 = k4 + k5;
+            k5 = k5 + k6;
+            k6 = k6 + k7;
+            /* MUL2C k2,k5,724,FDCT_SHIFT */
+            /* k0, k1 become scratch */
+            /* assume FAST MULTIPLY */
+            k1 = mla724(k12, k5, round);
+
+            k5 = k1 >> FDCT_SHIFT;
+            /*****************/
+            /********/
+            /* fdct_3 */
+            /* ROTATE k4,k6,392,946, FDCT_SHIFT */
+            /* assume FAST MULTIPLY */
+            /* k0, k1 are output */
+            k1 = mla392(k4, k14, round);
+            k1 = mla946(k6, k14, k1);
+
+            k6 = k1 >> FDCT_SHIFT;
+            /***********************/
+            k5 = k5 + k7;
+            k5 = k5 + k6;
+            /********/
+            out[8] = k5 ;       /* row 1 */
+            out++;
+        }
+        while ((UInt)out < (UInt)dst) ;
+
+        return ;
+    }
+    /**************************************************************************/
+    /*  Function:   Block1x1DCTwSub
+        Date:       8/9/01
+        Input:      block
+        Output:     y
+        Purpose:    Compute DC value only
+        Modified:
+    **************************************************************************/
+    void Block1x1DCTwSub(Short *out, UChar *cur, UChar *pred, Int width)
+    {
+        UChar *end;
+        Int temp = 0;
+        Int offset2;
+
+        offset2 = width - 8;
+        end = pred + (16 << 3);
+        do
+        {
+            temp += (*cur++ - *pred++);
+            temp += (*cur++ - *pred++);
+            temp += (*cur++ - *pred++);
+            temp += (*cur++ - *pred++);
+            temp += (*cur++ - *pred++);
+            temp += (*cur++ - *pred++);
+            temp += (*cur++ - *pred++);
+            temp += (*cur++ - *pred++);
+            cur += offset2;
+            pred += 8;
+        }
+        while (pred < end) ;
+
+        out[1] = out[2] = out[3] = out[4] = out[5] = out[6] = out[7] = 0;
+        out[0] = temp >> 3;
+
+        return ;
+    }
+
+    /**************************************************************************/
+    /*  Function:   Block1x1DCTIntra
+        Date:       8/9/01
+        Input:      prev
+        Output:     out
+        Purpose:    Compute DC value only
+        Modified:
+    **************************************************************************/
+    void Block1x1DCTIntra(Short *out, UChar *cur, UChar *dummy2, Int width)
+    {
+        UChar *end;
+        Int temp = 0;
+        ULong word;
+
+        OSCL_UNUSED_ARG(dummy2);
+
+        end = cur + (width << 3);
+        do
+        {
+            word = *((ULong*)cur);
+            temp += (word >> 24);
+            temp += ((word >> 16) & 0xFF);
+            temp += ((word >> 8) & 0xFF);
+            temp += (word & 0xFF);
+
+            word = *((ULong*)(cur + 4));
+            temp += (word >> 24);
+            temp += ((word >> 16) & 0xFF);
+            temp += ((word >> 8) & 0xFF);
+            temp += (word & 0xFF);
+
+            cur += width;
+        }
+        while (cur < end) ;
+
+        out[1] = out[2] = out[3] = out[4] = out[5] = out[6] = out[7] = 0;
+        out[0] = temp >> 3;
+
+        return ;
+    }
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/dct.h b/media/libstagefright/codecs/m4v_h263/enc/src/dct.h
new file mode 100644
index 0000000..3dceb66
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/dct.h
@@ -0,0 +1,191 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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 _DCT_H_
+#define _DCT_H_
+
+const static Int ColThInter[32] = {0, 0x1C, 0x4C, 0x6C, 0x9C, 0xBC, 0xEC, 0x10C,
+                                   0x13C, 0x15C, 0x18C, 0x1AC, 0x1DC, 0x1FC, 0x22C, 0x24C,
+                                   0x27C, 0x29C, 0x2CC, 0x2EC, 0x31C, 0x33C, 0x36C, 0x38C,
+                                   0x3BC, 0x3DC, 0x40C, 0x42C, 0x45C, 0x47C, 0x4AC, 0x4CC
+                                  };
+
+const static Int ColThIntra[32] = {0, 0x1C, 0x3C, 0x5C, 0x7C, 0x9C, 0xBC, 0xDC,
+                                   0xFC, 0x11C, 0x13C, 0x15C, 0x17C, 0x19C, 0x1BC, 0x1DC,
+                                   0x1FC, 0x21C, 0x23C, 0x25C, 0x27C, 0x29C, 0x2BC, 0x2DC,
+                                   0x2FC, 0x31C, 0x33C, 0x35C, 0x37C, 0x39C, 0x3BC, 0x3DC
+                                  };
+
+/******************************************************/
+/********** IDCT part **************************/
+const static unsigned char imask[8] = {128, 64, 32, 16, 8, 4, 2, 1};
+const static unsigned char mask[8] = {0x7f, 0xbf, 0xdf, 0xef, 0xf7, 0xfb, 0xfd, 0xfe};
+
+#define W1 2841                 /* 2048*sqrt(2)*cos(1*pi/16) */
+#define W2 2676                 /* 2048*sqrt(2)*cos(2*pi/16) */
+#define W3 2408                 /* 2048*sqrt(2)*cos(3*pi/16) */
+#define W5 1609                 /* 2048*sqrt(2)*cos(5*pi/16) */
+#define W6 1108                 /* 2048*sqrt(2)*cos(6*pi/16) */
+#define W7 565                  /* 2048*sqrt(2)*cos(7*pi/16) */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    /* Reduced input IDCT */
+    void idct_col0(Short *blk);
+    void idct_col1(Short *blk);
+    void idct_col2(Short *blk);
+    void idct_col3(Short *blk);
+    void idct_col4(Short *blk);
+    void idct_col0x40(Short *blk);
+    void idct_col0x20(Short *blk);
+    void idct_col0x10(Short *blk);
+
+    void idct_rowInter(Short *srce, UChar *rec, Int lx);
+    void idct_row0Inter(Short *blk, UChar *rec, Int lx);
+    void idct_row1Inter(Short *blk, UChar *rec, Int lx);
+    void idct_row2Inter(Short *blk, UChar *rec, Int lx);
+    void idct_row3Inter(Short *blk, UChar *rec, Int lx);
+    void idct_row4Inter(Short *blk, UChar *rec, Int lx);
+    void idct_row0x40Inter(Short *blk, UChar *rec, Int lx);
+    void idct_row0x20Inter(Short *blk, UChar *rec, Int lx);
+    void idct_row0x10Inter(Short *blk, UChar *rec, Int lx);
+    void idct_row0xCCInter(Short *blk, UChar *rec, Int lx);
+    void idct_rowIntra(Short *srce, UChar *rec, Int lx);
+    void idct_row0Intra(Short *blk, UChar *rec, Int lx);
+    void idct_row1Intra(Short *blk, UChar *rec, Int lx);
+    void idct_row2Intra(Short *blk, UChar *rec, Int lx);
+    void idct_row3Intra(Short *blk, UChar *rec, Int lx);
+    void idct_row4Intra(Short *blk, UChar *rec, Int lx);
+    void idct_row0x40Intra(Short *blk, UChar *rec, Int lx);
+    void idct_row0x20Intra(Short *blk, UChar *rec, Int lx);
+    void idct_row0x10Intra(Short *blk, UChar *rec, Int lx);
+    void idct_row0xCCIntra(Short *blk, UChar *rec, Int lx);
+    void idct_rowzmv(Short *srce, UChar *rec, UChar *prev, Int lx);
+    void idct_row0zmv(Short *blk, UChar *rec, UChar *prev, Int lx);
+    void idct_row1zmv(Short *blk, UChar *rec, UChar *prev, Int lx);
+    void idct_row2zmv(Short *blk, UChar *rec, UChar *prev, Int lx);
+    void idct_row3zmv(Short *blk, UChar *rec, UChar *prev, Int lx);
+    void idct_row4zmv(Short *blk, UChar *rec, UChar *prev, Int lx);
+    void idct_row0x40zmv(Short *blk, UChar *rec, UChar *prev, Int lx);
+    void idct_row0x20zmv(Short *blk, UChar *rec, UChar *prev, Int lx);
+    void idct_row0x10zmv(Short *blk, UChar *rec, UChar *prev, Int lx);
+    void idct_row0xCCzmv(Short *blk, UChar *rec, UChar *prev, Int lx);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Look-up table mapping to RIDCT from bitmap */
+#ifdef SMALL_DCT
+
+static void (*const idctcolVCA[16])(Short*) =
+{
+    &idct_col0, &idct_col4, &idct_col3, &idct_col4,
+    &idct_col2, &idct_col4, &idct_col3, &idct_col4,
+    &idct_col1, &idct_col4, &idct_col3, &idct_col4,
+    &idct_col2, &idct_col4, &idct_col3, &idct_col4
+};
+
+static void (*const idctrowVCAInter[16])(Short*, UChar*, Int) =
+{
+    &idct_row0Inter, &idct_row4Inter, &idct_row3Inter, &idct_row4Inter,
+    &idct_row2Inter, &idct_row4Inter, &idct_row3Inter, &idct_row4Inter,
+    &idct_row1Inter, &idct_row4Inter, &idct_row3Inter, &idct_row4Inter,
+    &idct_row2Inter, &idct_row4Inter, &idct_row3Inter, &idct_row4Inter
+};
+
+static void (*const idctrowVCAzmv[16])(Short*, UChar*, UChar*, Int) =
+{
+    &idct_row0zmv, &idct_row4zmv, &idct_row3zmv, &idct_row4zmv,
+    &idct_row2zmv, &idct_row4zmv, &idct_row3zmv, &idct_row4zmv,
+    &idct_row1zmv, &idct_row4zmv, &idct_row3zmv, &idct_row4zmv,
+    &idct_row2zmv, &idct_row4zmv, &idct_row3zmv, &idct_row4zmv
+};
+
+
+static void (*const idctrowVCAIntra[16])(Short*, UChar*, Int) =
+{
+    &idct_row0Intra, &idct_row4Intra, &idct_row3Intra, &idct_row4Intra,
+    &idct_row2Intra, &idct_row4Intra, &idct_row3Intra, &idct_row4Intra,
+    &idct_row1Intra, &idct_row4Intra, &idct_row3Intra, &idct_row4Intra,
+    &idct_row2Intra, &idct_row4Intra, &idct_row3Intra, &idct_row4Intra
+};
+
+#else /* SMALL_DCT */
+
+static void (*const idctcolVCA[16])(Short*) =
+{
+    &idct_col0, &idct_col0x10, &idct_col0x20, &idct_col4,
+    &idct_col0x40, &idct_col4, &idct_col3, &idct_col4,
+    &idct_col1, &idct_col4, &idct_col3, &idct_col4,
+    &idct_col2, &idct_col4, &idct_col3, &idct_col4
+};
+
+static void (*const idctrowVCAInter[16])(Short*, UChar*, Int) =
+{
+    &idct_row0Inter, &idct_row0x10Inter, &idct_row0x20Inter, &idct_row4Inter,
+    &idct_row0x40Inter, &idct_row4Inter, &idct_row3Inter, &idct_row4Inter,
+    &idct_row1Inter, &idct_row4Inter, &idct_row3Inter, &idct_row4Inter,
+    &idct_row2Inter, &idct_row4Inter, &idct_row3Inter, &idct_row4Inter
+};
+
+static void (*const idctrowVCAzmv[16])(Short*, UChar*, UChar*, Int) =
+{
+    &idct_row0zmv, &idct_row0x10zmv, &idct_row0x20zmv, &idct_row4zmv,
+    &idct_row0x40zmv, &idct_row4zmv, &idct_row3zmv, &idct_row4zmv,
+    &idct_row1zmv, &idct_row4zmv, &idct_row3zmv, &idct_row4zmv,
+    &idct_row2zmv, &idct_row4zmv, &idct_row3zmv, &idct_row4zmv
+};
+
+static void (*const idctrowVCAIntra[16])(Short*, UChar*, Int) =
+{
+    &idct_row0Intra, &idct_row0x10Intra, &idct_row0x20Intra, &idct_row4Intra,
+    &idct_row0x40Intra, &idct_row4Intra, &idct_row3Intra, &idct_row4Intra,
+    &idct_row1Intra, &idct_row4Intra, &idct_row3Intra, &idct_row4Intra,
+    &idct_row2Intra, &idct_row4Intra, &idct_row3Intra, &idct_row4Intra
+};
+
+#endif /* SMALL_DCT */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+    /* part in AppVCA_dct.c */
+//void Block1x1DCTzmv (Short *out,UChar *prev,UChar *cur,UChar *rec,Int lx,Int chroma);
+    void Block1x1DCTwSub(Short *out, UChar *cur, UChar *prev, Int pitch_chroma);
+    void Block1x1DCTIntra(Short *out, UChar *cur, UChar *dummy1, Int pitch_chroma);
+    /* This part is in dct_aan.c */
+    Void BlockDCT_AANwSub(Short *out, UChar *cur, UChar *prev, Int pitch_chroma);
+    Void Block4x4DCT_AANwSub(Short *out, UChar *cur, UChar *prev, Int pitch_chroma);
+    Void Block2x2DCT_AANwSub(Short *out, UChar *cur, UChar *prev, Int pitch_chroma);
+//Void BlockDCT_AANzmv(Short *out,UChar *prev,UChar *cur,UChar *rec,Int ColTh,Int lx,Int chroma);
+//Void Block4x4DCT_AANzmv(Short *out,UChar *prev,UChar *cur,UChar *rec,Int ColTh,Int lx,Int chroma);
+//Void Block2x2DCT_AANzmv(Short *out,UChar *prev,UChar *cur,UChar *rec,Int ColTh,Int lx,Int chroma);
+    Void BlockDCT_AANIntra(Short *out, UChar *cur, UChar *dummy1, Int pitch_chroma);
+    Void Block4x4DCT_AANIntra(Short *out, UChar *cur, UChar *dummy1, Int pitch_chroma);
+    Void Block2x2DCT_AANIntra(Short *out, UChar *cur, UChar *dummy1, Int pitch_chroma);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //_DCT_H_
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/dct_inline.h b/media/libstagefright/codecs/m4v_h263/enc/src/dct_inline.h
new file mode 100644
index 0000000..f795bd9
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/dct_inline.h
@@ -0,0 +1,395 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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.
+ * -------------------------------------------------------------------
+ */
+/*  Filename: dct_inline.h                                                      */
+/*  Description: Implementation for in-line functions used in dct.cpp           */
+/*  Modified:                                                                   */
+/*********************************************************************************/
+#ifndef _DCT_INLINE_H_
+#define _DCT_INLINE_H_
+
+#if !defined(PV_ARM_GCC_V5) && !defined(PV_ARM_GCC_V4)
+
+__inline int32 mla724(int32 op1, int32 op2, int32 op3)
+{
+    int32 out;
+
+    OSCL_UNUSED_ARG(op1);
+
+    out = op2 * 724 + op3; /* op1 is not used here */
+
+    return out;
+}
+
+__inline int32 mla392(int32 k0, int32 k14, int32 round)
+{
+    int32 k1;
+
+    OSCL_UNUSED_ARG(k14);
+
+    k1 = k0 * 392 + round;
+
+    return k1;
+}
+
+__inline int32 mla554(int32 k4, int32 k12, int32 k1)
+{
+    int32 k0;
+
+    OSCL_UNUSED_ARG(k12);
+
+    k0 = k4 * 554 + k1;
+
+    return k0;
+}
+
+__inline int32 mla1338(int32 k6, int32 k14, int32 k1)
+{
+    int32 out;
+
+    OSCL_UNUSED_ARG(k14);
+
+    out = k6 * 1338 + k1;
+
+    return out;
+}
+
+__inline int32 mla946(int32 k6, int32 k14, int32 k1)
+{
+    int32 out;
+
+    OSCL_UNUSED_ARG(k14);
+
+    out = k6 * 946 + k1;
+
+    return out;
+}
+
+__inline int32 sum_abs(int32 k0, int32 k1, int32 k2, int32 k3,
+                       int32 k4, int32 k5, int32 k6, int32 k7)
+{
+    int32 carry, abs_sum;
+
+    carry = k0 >> 31;
+    abs_sum = (k0 ^ carry);
+    carry = k1 >> 31;
+    abs_sum += (k1 ^ carry) - carry;
+    carry = k2 >> 31;
+    abs_sum += (k2 ^ carry) - carry;
+    carry = k3 >> 31;
+    abs_sum += (k3 ^ carry) - carry;
+    carry = k4 >> 31;
+    abs_sum += (k4 ^ carry) - carry;
+    carry = k5 >> 31;
+    abs_sum += (k5 ^ carry) - carry;
+    carry = k6 >> 31;
+    abs_sum += (k6 ^ carry) - carry;
+    carry = k7 >> 31;
+    abs_sum += (k7 ^ carry) - carry;
+
+    return abs_sum;
+}
+
+#elif defined(__CC_ARM)  /* only work with arm v5 */
+
+#if defined(__TARGET_ARCH_5TE)
+
+__inline int32 mla724(int32 op1, int32 op2, int32 op3)
+{
+    int32 out;
+
+    __asm
+    {
+        smlabb out, op1, op2, op3
+    }
+
+    return out;
+}
+
+__inline int32 mla392(int32 k0, int32 k14, int32 round)
+{
+    int32 k1;
+
+    __asm
+    {
+        smlabt k1, k0, k14, round
+    }
+
+    return k1;
+}
+
+__inline int32 mla554(int32 k4, int32 k12, int32 k1)
+{
+    int32 k0;
+
+    __asm
+    {
+        smlabt k0, k4, k12, k1
+    }
+
+    return k0;
+}
+
+__inline int32 mla1338(int32 k6, int32 k14, int32 k1)
+{
+    int32 out;
+
+    __asm
+    {
+        smlabb out, k6, k14, k1
+    }
+
+    return out;
+}
+
+__inline int32 mla946(int32 k6, int32 k14, int32 k1)
+{
+    int32 out;
+
+    __asm
+    {
+        smlabb out, k6, k14, k1
+    }
+
+    return out;
+}
+
+#else // not ARM5TE
+
+
+__inline int32 mla724(int32 op1, int32 op2, int32 op3)
+{
+    int32 out;
+
+    __asm
+    {
+        and out, op2, #0xFFFF
+        mla out, op1, out, op3
+    }
+
+    return out;
+}
+
+__inline int32 mla392(int32 k0, int32 k14, int32 round)
+{
+    int32 k1;
+
+    __asm
+    {
+        mov k1, k14, asr #16
+        mla k1, k0, k1, round
+    }
+
+    return k1;
+}
+
+__inline int32 mla554(int32 k4, int32 k12, int32 k1)
+{
+    int32 k0;
+
+    __asm
+    {
+        mov  k0, k12, asr #16
+        mla k0, k4, k0, k1
+    }
+
+    return k0;
+}
+
+__inline int32 mla1338(int32 k6, int32 k14, int32 k1)
+{
+    int32 out;
+
+    __asm
+    {
+        and out, k14, 0xFFFF
+        mla out, k6, out, k1
+    }
+
+    return out;
+}
+
+__inline int32 mla946(int32 k6, int32 k14, int32 k1)
+{
+    int32 out;
+
+    __asm
+    {
+        and out, k14, 0xFFFF
+        mla out, k6, out, k1
+    }
+
+    return out;
+}
+
+#endif
+
+__inline int32 sum_abs(int32 k0, int32 k1, int32 k2, int32 k3,
+                       int32 k4, int32 k5, int32 k6, int32 k7)
+{
+    int32 carry, abs_sum;
+    __asm
+    {
+        eor     carry, k0, k0, asr #31 ;
+        eors    abs_sum, k1, k1, asr #31 ;
+        adc     abs_sum, abs_sum, carry ;
+        eors    carry,  k2, k2, asr #31 ;
+        adc     abs_sum, abs_sum, carry ;
+        eors    carry,  k3, k3, asr #31 ;
+        adc     abs_sum, abs_sum, carry ;
+        eors    carry,  k4, k4, asr #31 ;
+        adc     abs_sum, abs_sum, carry ;
+        eors    carry,  k5, k5, asr #31 ;
+        adc     abs_sum, abs_sum, carry ;
+        eors    carry,  k6, k6, asr #31 ;
+        adc     abs_sum, abs_sum, carry ;
+        eors    carry,  k7, k7, asr #31 ;
+        adc     abs_sum, abs_sum, carry ;
+    }
+
+    return abs_sum;
+}
+
+#elif ( defined(PV_ARM_GCC_V5) || defined(PV_ARM_GCC_V4) )  /* ARM GNU COMPILER  */
+
+__inline int32 mla724(int32 op1, int32 op2, int32 op3)
+{
+    register int32 out;
+    register int32 aa = (int32)op1;
+    register int32 bb = (int32)op2;
+    register int32 cc = (int32)op3;
+
+    asm volatile("smlabb %0, %1, %2, %3"
+             : "=&r"(out)
+                         : "r"(aa),
+                         "r"(bb),
+                         "r"(cc));
+    return out;
+}
+
+
+__inline int32 mla392(int32 k0, int32 k14, int32 round)
+{
+    register int32 out;
+    register int32 aa = (int32)k0;
+    register int32 bb = (int32)k14;
+    register int32 cc = (int32)round;
+
+    asm volatile("smlabt %0, %1, %2, %3"
+             : "=&r"(out)
+                         : "r"(aa),
+                         "r"(bb),
+                         "r"(cc));
+
+    return out;
+}
+
+__inline int32 mla554(int32 k4, int32 k12, int32 k1)
+{
+    register int32 out;
+    register int32 aa = (int32)k4;
+    register int32 bb = (int32)k12;
+    register int32 cc = (int32)k1;
+
+    asm volatile("smlabt %0, %1, %2, %3"
+             : "=&r"(out)
+                         : "r"(aa),
+                         "r"(bb),
+                         "r"(cc));
+
+    return out;
+}
+
+__inline int32 mla1338(int32 k6, int32 k14, int32 k1)
+{
+    register int32 out;
+    register int32 aa = (int32)k6;
+    register int32 bb = (int32)k14;
+    register int32 cc = (int32)k1;
+
+    asm volatile("smlabb %0, %1, %2, %3"
+             : "=&r"(out)
+                         : "r"(aa),
+                         "r"(bb),
+                         "r"(cc));
+    return out;
+}
+
+__inline int32 mla946(int32 k6, int32 k14, int32 k1)
+{
+    register int32 out;
+    register int32 aa = (int32)k6;
+    register int32 bb = (int32)k14;
+    register int32 cc = (int32)k1;
+
+    asm volatile("smlabb %0, %1, %2, %3"
+             : "=&r"(out)
+                         : "r"(aa),
+                         "r"(bb),
+                         "r"(cc));
+    return out;
+}
+
+__inline int32 sum_abs(int32 k0, int32 k1, int32 k2, int32 k3,
+                       int32 k4, int32 k5, int32 k6, int32 k7)
+{
+    register int32 carry;
+    register int32 abs_sum;
+    register int32 aa = (int32)k0;
+    register int32 bb = (int32)k1;
+    register int32 cc = (int32)k2;
+    register int32 dd = (int32)k3;
+    register int32 ee = (int32)k4;
+    register int32 ff = (int32)k5;
+    register int32 gg = (int32)k6;
+    register int32 hh = (int32)k7;
+
+    asm volatile("eor  %0, %2, %2, asr #31\n\t"
+                 "eors %1, %3, %3, asr #31\n\t"
+                 "adc  %1, %1, %0\n\t"
+                 "eors %0, %4, %4, asr #31\n\t"
+                 "adc  %1, %1, %0\n\t"
+                 "eors %0, %5, %5, asr #31\n\t"
+                 "adc  %1, %1, %0\n\t"
+                 "eors %0, %6, %6, asr #31\n\t"
+                 "adc  %1, %1, %0\n\t"
+                 "eors %0, %7, %7, asr #31\n\t"
+                 "adc  %1, %1, %0\n\t"
+                 "eors %0, %8, %8, asr #31\n\t"
+                 "adc  %1, %1, %0\n\t"
+                 "eors %0, %9, %9, asr #31\n\t"
+                 "adc  %1, %1, %0\n\t"
+
+             : "=&r"(carry),
+                 "=&r"(abs_sum):
+                         "r"(aa),
+                         "r"(bb),
+                         "r"(cc),
+                         "r"(dd),
+                         "r"(ee),
+                         "r"(ff),
+                         "r"(gg),
+                         "r"(hh));
+
+    return abs_sum;
+}
+
+#endif // Diff. OS
+
+#endif //_DCT_INLINE_H_
+
+
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/fastcodemb.cpp b/media/libstagefright/codecs/m4v_h263/enc/src/fastcodemb.cpp
new file mode 100644
index 0000000..6fd41c3
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/fastcodemb.cpp
@@ -0,0 +1,622 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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 "mp4def.h"
+#include "mp4lib_int.h"
+#include "mp4enc_lib.h"
+#include "dct.h"
+#include "m4venc_oscl.h"
+
+/* ======================================================================== */
+/*  Function : CodeMB_H263( )                                               */
+/*  Date     : 8/15/2001                                                    */
+/*  Purpose  : Perform residue calc (only zero MV), DCT, H263 Quant/Dequant,*/
+/*              IDCT and motion compensation.Modified from FastCodeMB()     */
+/*  Input    :                                                              */
+/*      video       Video encoder data structure                            */
+/*      function    Approximate DCT function, scaling and threshold         */
+/*      ncoefblck   Array for last nonzero coeff for speedup in VlcEncode   */
+/*      QP      Combined offset from the origin to the current          */
+/*                  macroblock  and QP  for current MB.                     */
+/*    Output     :                                                          */
+/*      video->outputMB     Quantized DCT coefficients.                     */
+/*      currVop->yChan,uChan,vChan  Reconstructed pixels                    */
+/*                                                                          */
+/*  Return   :   PV_STATUS                                                  */
+/*  Modified :                                                              */
+/*           2/26/01
+            -modified threshold based on correlation coeff 0.75 only for mode H.263
+            -ncoefblck[] as input,  to keep position of last non-zero coeff*/
+/*           8/10/01
+            -modified threshold based on correlation coeff 0.5
+            -used column threshold to speedup column DCT.
+            -used bitmap zigzag to speedup RunLevel().                      */
+/* ======================================================================== */
+
+PV_STATUS CodeMB_H263(VideoEncData *video, approxDCT *function, Int QP, Int ncoefblck[])
+{
+    Int sad, k, CBP, mbnum = video->mbnum;
+    Short *output, *dataBlock;
+    UChar Mode = video->headerInfo.Mode[mbnum];
+    UChar *bitmapcol, *bitmaprow = video->bitmaprow;
+    UInt  *bitmapzz ;
+    UChar shortHeader = video->vol[video->currLayer]->shortVideoHeader;
+    Int dc_scaler = 8;
+    Int intra = (Mode == MODE_INTRA || Mode == MODE_INTRA_Q);
+    struct QPstruct QuantParam;
+    Int dctMode, DctTh1;
+    Int ColTh;
+    Int(*BlockQuantDequantH263)(Short *, Short *, struct QPstruct *,
+                                UChar[], UChar *, UInt *, Int, Int, Int, UChar);
+    Int(*BlockQuantDequantH263DC)(Short *, Short *, struct QPstruct *,
+                                  UChar *, UInt *, Int, UChar);
+    void (*BlockDCT1x1)(Short *, UChar *, UChar *, Int);
+    void (*BlockDCT2x2)(Short *, UChar *, UChar *, Int);
+    void (*BlockDCT4x4)(Short *, UChar *, UChar *, Int);
+    void (*BlockDCT8x8)(Short *, UChar *, UChar *, Int);
+
+    /* motion comp. related var. */
+    Vop *currVop = video->currVop;
+    VideoEncFrameIO *inputFrame = video->input;
+    Int ind_x = video->outputMB->mb_x;
+    Int ind_y = video->outputMB->mb_y;
+    Int lx = currVop->pitch;
+    Int width = currVop->width;
+    UChar *rec, *input, *pred;
+    Int offset = QP >> 5;  /* QP is combined offset and QP */
+    Int offsetc = (offset >> 2) + (ind_x << 2); /* offset for chrom */
+    /*****************************/
+
+    OSCL_UNUSED_ARG(function);
+
+    output = video->outputMB->block[0];
+    CBP = 0;
+    QP = QP & 0x1F;
+//  M4VENC_MEMSET(output,0,(sizeof(Short)<<6)*6); /* reset quantized coeff. to zero , 7/24/01*/
+
+    QuantParam.QPx2 = QP << 1;
+    QuantParam.QP = QP;
+    QuantParam.QPdiv2 = QP >> 1;
+    QuantParam.QPx2plus = QuantParam.QPx2 + QuantParam.QPdiv2;
+    QuantParam.Addition = QP - 1 + (QP & 0x1);
+
+    if (intra)
+    {
+        BlockDCT1x1 = &Block1x1DCTIntra;
+        BlockDCT2x2 = &Block2x2DCT_AANIntra;
+        BlockDCT4x4 = &Block4x4DCT_AANIntra;
+        BlockDCT8x8 = &BlockDCT_AANIntra;
+        BlockQuantDequantH263 = &BlockQuantDequantH263Intra;
+        BlockQuantDequantH263DC = &BlockQuantDequantH263DCIntra;
+        if (shortHeader)
+        {
+            dc_scaler = 8;
+        }
+        else
+        {
+            dc_scaler = cal_dc_scalerENC(QP, 1); /* luminance blocks */
+        }
+        DctTh1 = (Int)(dc_scaler * 3);//*1.829
+        ColTh = ColThIntra[QP];
+    }
+    else
+    {
+        BlockDCT1x1 = &Block1x1DCTwSub;
+        BlockDCT2x2 = &Block2x2DCT_AANwSub;
+        BlockDCT4x4 = &Block4x4DCT_AANwSub;
+        BlockDCT8x8 = &BlockDCT_AANwSub;
+
+        BlockQuantDequantH263 = &BlockQuantDequantH263Inter;
+        BlockQuantDequantH263DC = &BlockQuantDequantH263DCInter;
+        ColTh = ColThInter[QP];
+        DctTh1 = (Int)(16 * QP);  //9*QP;
+    }
+
+    rec = currVop->yChan + offset;
+    input = inputFrame->yChan + offset;
+    if (lx != width) input -= (ind_y << 9);  /* non-padded offset */
+
+    dataBlock = video->dataBlock;
+    pred = video->predictedMB;
+
+    for (k = 0; k < 6; k++)
+    {
+        CBP <<= 1;
+        bitmapcol = video->bitmapcol[k];
+        bitmapzz = video->bitmapzz[k];  /*  7/30/01 */
+        if (k < 4)
+        {
+            sad = video->mot[mbnum][k+1].sad;
+            if (k&1)
+            {
+                rec += 8;
+                input += 8;
+            }
+            else if (k == 2)
+            {
+                dctMode = ((width << 3) - 8);
+                input += dctMode;
+                dctMode = ((lx << 3) - 8);
+                rec += dctMode;
+            }
+        }
+        else
+        {
+            if (k == 4)
+            {
+                rec = currVop->uChan + offsetc;
+                input = inputFrame->uChan + offsetc;
+                if (lx != width) input -= (ind_y << 7);
+                lx >>= 1;
+                width >>= 1;
+                if (intra)
+                {
+                    sad = getBlockSum(input, width);
+                    if (shortHeader)
+                        dc_scaler = 8;
+                    else
+                    {
+                        dc_scaler = cal_dc_scalerENC(QP, 2); /* chrominance blocks */
+                    }
+                    DctTh1 = (Int)(dc_scaler * 3);//*1.829
+                }
+                else
+                    sad = Sad8x8(input, pred, width);
+            }
+            else
+            {
+                rec = currVop->vChan + offsetc;
+                input = inputFrame->vChan + offsetc;
+                if (lx != width) input -= (ind_y << 7);
+                if (intra)
+                {
+                    sad = getBlockSum(input, width);
+                }
+                else
+                    sad = Sad8x8(input, pred, width);
+            }
+        }
+
+        if (sad < DctTh1 && !(shortHeader && intra)) /* all-zero */
+        {                       /* For shortHeader intra block, DC value cannot be zero */
+            dctMode = 0;
+            CBP |= 0;
+            ncoefblck[k] = 0;
+        }
+        else if (sad < 18*QP/*(QP<<4)*/) /* DC-only */
+        {
+            dctMode = 1;
+            BlockDCT1x1(dataBlock, input, pred, width);
+
+            CBP |= (*BlockQuantDequantH263DC)(dataBlock, output, &QuantParam,
+                                              bitmaprow + k, bitmapzz, dc_scaler, shortHeader);
+            ncoefblck[k] = 1;
+        }
+        else
+        {
+
+            dataBlock[64] = ColTh;
+
+            if (sad < 22*QP/*(QP<<4)+(QP<<1)*/)  /* 2x2 DCT */
+            {
+                dctMode = 2;
+                BlockDCT2x2(dataBlock, input, pred, width);
+                ncoefblck[k] = 6;
+            }
+            else if (sad < (QP << 5)) /* 4x4 DCT */
+            {
+                dctMode = 4;
+                BlockDCT4x4(dataBlock, input, pred, width);
+                ncoefblck[k] = 26;
+            }
+            else /* Full-DCT */
+            {
+                dctMode = 8;
+                BlockDCT8x8(dataBlock, input, pred, width);
+                ncoefblck[k] = 64;
+            }
+
+            CBP |= (*BlockQuantDequantH263)(dataBlock, output, &QuantParam,
+                                            bitmapcol, bitmaprow + k, bitmapzz, dctMode, k, dc_scaler, shortHeader);
+        }
+        BlockIDCTMotionComp(dataBlock, bitmapcol, bitmaprow[k], dctMode, rec, pred, (lx << 1) | intra);
+        output += 64;
+        if (!(k&1))
+        {
+            pred += 8;
+        }
+        else
+        {
+            pred += 120;
+        }
+    }
+
+    video->headerInfo.CBP[mbnum] = CBP; /*  5/18/2001 */
+    return PV_SUCCESS;
+}
+
+#ifndef NO_MPEG_QUANT
+/* ======================================================================== */
+/*  Function : CodeMB_MPEG( )                                               */
+/*  Date     : 8/15/2001                                                    */
+/*  Purpose  : Perform residue calc (only zero MV), DCT, MPEG Quant/Dequant,*/
+/*              IDCT and motion compensation.Modified from FastCodeMB()     */
+/*  Input    :                                                              */
+/*      video       Video encoder data structure                            */
+/*      function    Approximate DCT function, scaling and threshold         */
+/*      ncoefblck   Array for last nonzero coeff for speedup in VlcEncode   */
+/*      QP      Combined offset from the origin to the current          */
+/*                  macroblock  and QP  for current MB.                     */
+/*    Output     :                                                          */
+/*      video->outputMB     Quantized DCT coefficients.                     */
+/*      currVop->yChan,uChan,vChan  Reconstructed pixels                    */
+/*                                                                          */
+/*  Return   :   PV_STATUS                                                  */
+/*  Modified :                                                              */
+/*           2/26/01
+            -modified threshold based on correlation coeff 0.75 only for mode H.263
+            -ncoefblck[] as input, keep position of last non-zero coeff*/
+/*           8/10/01
+            -modified threshold based on correlation coeff 0.5
+            -used column threshold to speedup column DCT.
+            -used bitmap zigzag to speedup RunLevel().                      */
+/* ======================================================================== */
+
+PV_STATUS CodeMB_MPEG(VideoEncData *video, approxDCT *function, Int QP, Int ncoefblck[])
+{
+    Int sad, k, CBP, mbnum = video->mbnum;
+    Short *output, *dataBlock;
+    UChar Mode = video->headerInfo.Mode[mbnum];
+    UChar *bitmapcol, *bitmaprow = video->bitmaprow;
+    UInt  *bitmapzz ;
+    Int dc_scaler = 8;
+    Vol *currVol = video->vol[video->currLayer];
+    Int intra = (Mode == MODE_INTRA || Mode == MODE_INTRA_Q);
+    Int *qmat;
+    Int dctMode, DctTh1, DctTh2, DctTh3, DctTh4;
+    Int ColTh;
+
+    Int(*BlockQuantDequantMPEG)(Short *, Short *, Int, Int *,
+                                UChar [], UChar *, UInt *, Int,  Int, Int);
+    Int(*BlockQuantDequantMPEGDC)(Short *, Short *, Int, Int *,
+                                  UChar [], UChar *, UInt *, Int);
+
+    void (*BlockDCT1x1)(Short *, UChar *, UChar *, Int);
+    void (*BlockDCT2x2)(Short *, UChar *, UChar *, Int);
+    void (*BlockDCT4x4)(Short *, UChar *, UChar *, Int);
+    void (*BlockDCT8x8)(Short *, UChar *, UChar *, Int);
+
+    /* motion comp. related var. */
+    Vop *currVop = video->currVop;
+    VideoEncFrameIO *inputFrame = video->input;
+    Int ind_x = video->outputMB->mb_x;
+    Int ind_y = video->outputMB->mb_y;
+    Int lx = currVop->pitch;
+    Int width = currVop->width;
+    UChar *rec, *input, *pred;
+    Int offset = QP >> 5;
+    Int offsetc = (offset >> 2) + (ind_x << 2); /* offset for chrom */
+    /*****************************/
+
+    OSCL_UNUSED_ARG(function);
+
+    output = video->outputMB->block[0];
+    CBP = 0;
+    QP = QP & 0x1F;
+//  M4VENC_MEMSET(output,0,(sizeof(Short)<<6)*6); /* reset quantized coeff. to zero ,  7/24/01*/
+
+    if (intra)
+    {
+        BlockDCT1x1 = &Block1x1DCTIntra;
+        BlockDCT2x2 = &Block2x2DCT_AANIntra;
+        BlockDCT4x4 = &Block4x4DCT_AANIntra;
+        BlockDCT8x8 = &BlockDCT_AANIntra;
+
+        BlockQuantDequantMPEG = &BlockQuantDequantMPEGIntra;
+        BlockQuantDequantMPEGDC = &BlockQuantDequantMPEGDCIntra;
+        dc_scaler = cal_dc_scalerENC(QP, 1); /* luminance blocks */
+        qmat = currVol->iqmat;
+        DctTh1 = (Int)(3 * dc_scaler);//2*dc_scaler);
+        DctTh2 = (Int)((1.25 * QP - 1) * qmat[1] * 0.45);//0.567);//0.567);
+        DctTh3 = (Int)((1.25 * QP - 1) * qmat[2] * 0.55);//1.162); /*  8/2/2001 */
+        DctTh4 = (Int)((1.25 * QP - 1) * qmat[32] * 0.8);//1.7583);//0.7942);
+        ColTh = ColThIntra[QP];
+    }
+    else
+    {
+        BlockDCT1x1 = &Block1x1DCTwSub;
+        BlockDCT2x2 = &Block2x2DCT_AANwSub;
+        BlockDCT4x4 = &Block4x4DCT_AANwSub;
+        BlockDCT8x8 = &BlockDCT_AANwSub;
+
+        BlockQuantDequantMPEG = &BlockQuantDequantMPEGInter;
+        BlockQuantDequantMPEGDC = &BlockQuantDequantMPEGDCInter;
+        qmat = currVol->niqmat;
+        DctTh1 = (Int)(((QP << 1) - 0.5) * qmat[0] * 0.4);//0.2286);//0.3062);
+        DctTh2 = (Int)(((QP << 1) - 0.5) * qmat[1] * 0.45);//0.567);//0.4);
+        DctTh3 = (Int)(((QP << 1) - 0.5) * qmat[2] * 0.55);//1.162); /*  8/2/2001 */
+        DctTh4 = (Int)(((QP << 1) - 0.5) * qmat[32] * 0.8);//1.7583);//0.7942);
+        ColTh = ColThInter[QP];
+    }// get qmat, DctTh1, DctTh2, DctTh3
+
+    rec = currVop->yChan + offset;
+    input = inputFrame->yChan + offset;
+    if (lx != width) input -= (ind_y << 9);  /* non-padded offset */
+
+    dataBlock = video->dataBlock;
+    pred = video->predictedMB;
+
+    for (k = 0; k < 6; k++)
+    {
+        CBP <<= 1;
+        bitmapcol = video->bitmapcol[k];
+        bitmapzz = video->bitmapzz[k];  /*  8/2/01 */
+        if (k < 4)
+        {//Y block
+            sad = video->mot[mbnum][k+1].sad;
+            if (k&1)
+            {
+                rec += 8;
+                input += 8;
+            }
+            else if (k == 2)
+            {
+                dctMode = ((width << 3) - 8);
+                input += dctMode;
+                dctMode = ((lx << 3) - 8);
+                rec += dctMode;
+            }
+        }
+        else
+        {// U, V block
+            if (k == 4)
+            {
+                rec = currVop->uChan + offsetc;
+                input = inputFrame->uChan + offsetc;
+                if (lx != width) input -= (ind_y << 7);
+                lx >>= 1;
+                width >>= 1;
+                if (intra)
+                {
+                    dc_scaler = cal_dc_scalerENC(QP, 2); /* luminance blocks */
+                    DctTh1 = dc_scaler * 3;
+                    sad = getBlockSum(input, width);
+                }
+                else
+                    sad = Sad8x8(input, pred, width);
+            }
+            else
+            {
+                rec = currVop->vChan + offsetc;
+                input = inputFrame->vChan + offsetc;
+                if (lx != width) input -= (ind_y << 7);
+                if (intra)
+                    sad = getBlockSum(input, width);
+                else
+                    sad = Sad8x8(input, pred, width);
+            }
+        }
+
+        if (sad < DctTh1) /* all-zero */
+        {
+            dctMode = 0;
+            CBP |= 0;
+            ncoefblck[k] = 0;
+        }
+        else if (sad < DctTh2) /* DC-only */
+        {
+            dctMode = 1;
+            BlockDCT1x1(dataBlock, input, pred, width);
+
+            CBP |= (*BlockQuantDequantMPEGDC)(dataBlock, output, QP, qmat,
+                                              bitmapcol, bitmaprow + k, bitmapzz, dc_scaler);
+            ncoefblck[k] = 1;
+        }
+        else
+        {
+            dataBlock[64] = ColTh;
+
+            if (sad < DctTh3) /* 2x2-DCT */
+            {
+                dctMode = 2;
+                BlockDCT2x2(dataBlock, input, pred, width);
+                ncoefblck[k] = 6;
+            }
+            else if (sad < DctTh4) /* 4x4 DCT */
+            {
+                dctMode = 4;
+                BlockDCT4x4(dataBlock, input, pred, width);
+                ncoefblck[k] = 26;
+            }
+            else /* full-DCT */
+            {
+                dctMode = 8;
+                BlockDCT8x8(dataBlock, input, pred, width);
+                ncoefblck[k] = 64;
+            }
+
+            CBP |= (*BlockQuantDequantMPEG)(dataBlock, output, QP, qmat,
+                                            bitmapcol, bitmaprow + k, bitmapzz, dctMode, k, dc_scaler); //
+        }
+        dctMode = 8; /* for mismatch handle */
+        BlockIDCTMotionComp(dataBlock, bitmapcol, bitmaprow[k], dctMode, rec, pred, (lx << 1) | (intra));
+
+        output += 64;
+        if (!(k&1))
+        {
+            pred += 8;
+        }
+        else
+        {
+            pred += 120;
+        }
+    }
+
+    video->headerInfo.CBP[mbnum] = CBP; /*  5/18/2001 */
+    return PV_SUCCESS;
+}
+
+#endif
+
+/* ======================================================================== */
+/*  Function : getBlockSAV( )                                               */
+/*  Date     : 8/10/2000                                                    */
+/*  Purpose  : Get SAV for one block                                        */
+/*  In/out   : block[64] contain one block data                             */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+/* can be written in MMX or SSE,  2/22/2001 */
+Int getBlockSAV(Short block[])
+{
+    Int i, val, sav = 0;
+
+    i = 8;
+    while (i--)
+    {
+        val = *block++;
+        if (val > 0)    sav += val;
+        else        sav -= val;
+        val = *block++;
+        if (val > 0)    sav += val;
+        else        sav -= val;
+        val = *block++;
+        if (val > 0)    sav += val;
+        else        sav -= val;
+        val = *block++;
+        if (val > 0)    sav += val;
+        else        sav -= val;
+        val = *block++;
+        if (val > 0)    sav += val;
+        else        sav -= val;
+        val = *block++;
+        if (val > 0)    sav += val;
+        else        sav -= val;
+        val = *block++;
+        if (val > 0)    sav += val;
+        else        sav -= val;
+        val = *block++;
+        if (val > 0)    sav += val;
+        else        sav -= val;
+    }
+
+    return sav;
+
+}
+
+/* ======================================================================== */
+/*  Function : Sad8x8( )                                                    */
+/*  Date     : 8/10/2000                                                    */
+/*  Purpose  : Find SAD between prev block and current block                */
+/*  In/out   : Previous and current frame block pointers, and frame width   */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/*      8/15/01,  - do 4 pixel at a time    assuming 32 bit register        */
+/* ======================================================================== */
+Int Sad8x8(UChar *cur, UChar *prev, Int width)
+{
+    UChar *end = cur + (width << 3);
+    Int sad = 0;
+    Int *curInt = (Int*) cur;
+    Int *prevInt = (Int*) prev;
+    Int cur1, cur2, prev1, prev2;
+    UInt mask, sgn_msk = 0x80808080;
+    Int  sum2 = 0, sum4 = 0;
+    Int  tmp;
+    do
+    {
+        mask    = ~(0xFF00);
+        cur1    = curInt[1];        /* load cur[4..7] */
+        cur2    = curInt[0];
+        curInt += (width >> 2);     /* load cur[0..3] and +=lx */
+        prev1   = prevInt[1];
+        prev2   = prevInt[0];
+        prevInt += 4;
+
+        tmp     = prev2 ^ cur2;
+        cur2    = prev2 - cur2;
+        tmp     = tmp ^ cur2;       /* (^)^(-) last bit is one if carry */
+        tmp     = sgn_msk & ((UInt)tmp >> 1); /* check the sign of each byte */
+        if (cur2 < 0)   tmp = tmp | 0x80000000; /* corcurt sign of first byte */
+        tmp     = (tmp << 8) - tmp;     /* carry borrowed bytes are marked with 0x1FE */
+        cur2    = cur2 + (tmp >> 7);     /* negative bytes is added with 0xFF, -1 */
+        cur2    = cur2 ^(tmp >> 7); /* take absolute by inverting bits (EOR) */
+
+        tmp     = prev1 ^ cur1;
+        cur1    = prev1 - cur1;
+        tmp     = tmp ^ cur1;       /* (^)^(-) last bit is one if carry */
+        tmp     = sgn_msk & ((UInt)tmp >> 1); /* check the sign of each byte */
+        if (cur1 < 0)   tmp = tmp | 0x80000000; /* corcurt sign of first byte */
+        tmp     = (tmp << 8) - tmp;     /* carry borrowed bytes are marked with 0x1FE */
+        cur1    = cur1 + (tmp >> 7);     /* negative bytes is added with 0xFF, -1 */
+        cur1    = cur1 ^(tmp >> 7); /* take absolute by inverting bits (EOR) */
+
+        sum4    = sum4 + cur1;
+        cur1    = cur1 & (mask << 8);   /* mask first and third bytes */
+        sum2    = sum2 + ((UInt)cur1 >> 8);
+        sum4    = sum4 + cur2;
+        cur2    = cur2 & (mask << 8);   /* mask first and third bytes */
+        sum2    = sum2 + ((UInt)cur2 >> 8);
+    }
+    while ((UInt)curInt < (UInt)end);
+
+    cur1 = sum4 - (sum2 << 8);  /* get even-sum */
+    cur1 = cur1 + sum2;         /* add 16 bit even-sum and odd-sum*/
+    cur1 = cur1 + (cur1 << 16); /* add upper and lower 16 bit sum */
+    sad  = ((UInt)cur1 >> 16);  /* take upper 16 bit */
+    return sad;
+}
+
+/* ======================================================================== */
+/*  Function : getBlockSum( )                                               */
+/*  Date     : 8/10/2000                                                    */
+/*  Purpose  : Find summation of value within a block.                      */
+/*  In/out   : Pointer to current block in a frame and frame width          */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/*          8/15/01,  - SIMD 4 pixels at a time                         */
+/* ======================================================================== */
+
+Int getBlockSum(UChar *cur, Int width)
+{
+    Int sad = 0, sum4 = 0, sum2 = 0;
+    UChar *end = cur + (width << 3);
+    Int *curInt = (Int*)cur;
+    UInt mask   = ~(0xFF00);
+    Int load1, load2;
+
+    do
+    {
+        load1 = curInt[1];
+        load2 = curInt[0];
+        curInt += (width >> 2);
+        sum4 += load1;
+        load1 = load1 & (mask << 8); /* even bytes */
+        sum2 += ((UInt)load1 >> 8); /* sum even bytes, 16 bit */
+        sum4 += load2;
+        load2 = load2 & (mask << 8); /* even bytes */
+        sum2 += ((UInt)load2 >> 8); /* sum even bytes, 16 bit */
+    }
+    while ((UInt)curInt < (UInt)end);
+    load1 = sum4 - (sum2 << 8);     /* get even-sum */
+    load1 = load1 + sum2;           /* add 16 bit even-sum and odd-sum*/
+    load1 = load1 + (load1 << 16);  /* add upper and lower 16 bit sum */
+    sad  = ((UInt)load1 >> 16); /* take upper 16 bit */
+
+    return sad;
+}
+
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/fastcodemb.h b/media/libstagefright/codecs/m4v_h263/enc/src/fastcodemb.h
new file mode 100644
index 0000000..686a66d
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/fastcodemb.h
@@ -0,0 +1,103 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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.
+ * -------------------------------------------------------------------
+ */
+/*  =====================================================================   */
+/*  File: FastCodeMB.h                                                      */
+/*  Description: This file contains structure and function prototypes used
+            in FastCodeMB() function. When it is decided to use FastCodeMB
+            instead of CodeMB, all of this prototypes should be migrated to
+            mp4enc_lib.h.                                                   */
+/*  Rev:                                                                    */
+/*  Created: 8/14/01                                                        */
+/* //////////////////////////////////////////////////////////////////////// */
+
+typedef struct struct_approxDCT  approxDCT;
+struct struct_approxDCT
+{
+    const Int *scale;
+    Int(*DCT)(Int block[ ], Int coeff[ ], approxDCT *);
+
+    // Threshold value for H.263 Quantizer
+    Int th_app_all[8];
+    Int th_app_odd[8];
+    Int th_app_even[8];
+    Int th_app_even1[8];
+    Int th_app_even2[8];
+};
+
+struct QPstruct
+{
+    Int QPx2 ;
+    Int QP;
+    Int QPdiv2;
+    Int QPx2plus;
+    Int Addition;
+};
+
+/*---- FastCodeMB.c -----*/
+void initCodeMB(approxDCT *function, Int QP);
+PV_STATUS CodeMB_H263(VideoEncData *video, approxDCT *function, Int QP, Int ncoefblck[], Int offset);
+PV_STATUS CodeMB_MPEG(VideoEncData *video, approxDCT *function, Int QP, Int ncoefblck[], Int offset);
+Int getBlockSAV(Int block[]);
+Int Sad8x8(UChar *rec, UChar *prev, Int lx);
+Int getBlockSum(UChar *rec, Int lx);
+
+/*---- AppVCA_dct.c -----*/
+Int     AppVCA1_dct(Int block[], Int out[ ], approxDCT *function);
+Int     AppVCA2_dct(Int block[], Int out[ ], approxDCT *function);
+Int     AppVCA3_dct(Int block[], Int out[ ], approxDCT *function);
+Int     AppVCA4_dct(Int block[], Int out[ ], approxDCT *function);
+Int     AppVCA5_dct(Int block[], Int out[ ], approxDCT *function);
+
+/*---- FastQuant.c -----*/
+Int cal_dc_scalerENC(Int QP, Int type) ;
+Int BlockQuantDequantH263Inter(Int *rcoeff, Int *qcoeff, struct QPstruct *QuantParam,
+                               UChar bitmapcol[ ], UChar *bitmaprow, UInt *bitmapzz,
+                               Int dctMode, Int comp, Int dummy);
+
+Int BlockQuantDequantH263Intra(Int *rcoeff, Int *qcoeff, struct QPstruct *QuantParam,
+                               UChar bitmapcol[ ], UChar *bitmaprow, UInt *bitmapzz,
+                               Int dctMode, Int comp, Int dc_scaler);
+
+Int BlockQuantDequantH263DCInter(Int *rcoeff, Int *qcoeff, struct QPstruct *QuantParam,
+                                 UChar *bitmaprow, UInt *bitmapzz, Int dummy);
+
+Int BlockQuantDequantH263DCIntra(Int *rcoeff, Int *qcoeff, struct QPstruct *QuantParam,
+                                 UChar *bitmaprow, UInt *bitmapzz, Int dc_scaler);
+
+Int BlockQuantDequantMPEGInter(Int *rcoeff, Int *qcoeff, Int QP, Int *qmat,
+                               UChar bitmapcol[ ], UChar *bitmaprow, UInt *bitmapzz,
+                               Int DctMode, Int comp, Int dc_scaler);
+
+Int BlockQuantDequantMPEGIntra(Int *rcoeff, Int *qcoeff, Int QP, Int *qmat,
+                               UChar bitmapcol[ ], UChar *bitmaprow, UInt *bitmapzz,
+                               Int DctMode, Int comp, Int dc_scaler);
+
+Int BlockQuantDequantMPEGDCInter(Int *rcoeff, Int *qcoeff, Int QP, Int *qmat,
+                                 UChar bitmapcol[ ], UChar *bitmaprow, UInt *bitmapzz, Int dummy);
+
+Int BlockQuantDequantMPEGDCIntra(Int *rcoeff, Int *qcoeff, Int QP, Int *qmat,
+                                 UChar bitmapcol[ ], UChar *bitmaprow, UInt *bitmapzz, Int dc_scaler);
+
+/*---- FastIDCT.c -----*/
+void BlockIDCTMotionComp(Int *block, UChar *bitmapcol, UChar bitmaprow,
+                         Int dctMode, UChar *rec, Int lx, Int intra);
+
+/*---- motion_comp.c -----*/
+void PutSkippedBlock(UChar *rec, UChar *prev, Int lx);
+
+
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/fastidct.cpp b/media/libstagefright/codecs/m4v_h263/enc/src/fastidct.cpp
new file mode 100644
index 0000000..21d7427
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/fastidct.cpp
@@ -0,0 +1,2020 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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.
+ * -------------------------------------------------------------------
+ */
+/*
+
+------------------------------------------------------------------------------
+ REVISION HISTORY
+ Who:   Date: July/2001
+ Description:   1. Optimized BlockIDCT bitmap checking.
+                2. Rearranged functions.
+                3. Do column IDCT first, then row IDCT.
+                4. Combine motion comp and IDCT, require
+                   two sets of row IDCTs one for INTRA
+                   and one for INTER.
+                5. Add AAN IDCT
+
+ Who:   Date: 8/16/01
+                1. Increase the input precision to 8 bits, i.e. change RDCTBITS
+                   to 11, have to comment out all in-line assembly since 16 bit
+                    multiplication doesn't work. Try to use diffent precision with
+                    32 bit mult. but hasn't finished. Turns out that without in-line
+                    assembly the performance doesn't change much (only 1%).
+ Who:   Date: 9/04/05
+                1. Replace AAN IDCT with Chen's IDCT to accommodate 16 bit data type.
+
+*/
+#include "mp4def.h"
+#include "mp4enc_lib.h"
+#include "mp4lib_int.h"
+#include "dct.h"
+
+#define ADD_CLIP    { \
+            tmp = *rec + tmp; \
+        if((UInt)tmp > mask) tmp = mask&(~(tmp>>31)); \
+        *rec++ = tmp;   \
+        }
+
+#define INTRA_CLIP  { \
+        if((UInt)tmp > mask) tmp = mask&(~(tmp>>31)); \
+        *rec++ = tmp;   \
+        }
+
+
+#define CLIP_RESULT(x)      if((UInt)x > 0xFF){x = 0xFF & (~(x>>31));}
+#define ADD_AND_CLIP1(x)    x += (pred_word&0xFF); CLIP_RESULT(x);
+#define ADD_AND_CLIP2(x)    x += ((pred_word>>8)&0xFF); CLIP_RESULT(x);
+#define ADD_AND_CLIP3(x)    x += ((pred_word>>16)&0xFF); CLIP_RESULT(x);
+#define ADD_AND_CLIP4(x)    x += ((pred_word>>24)&0xFF); CLIP_RESULT(x);
+
+
+void idct_col0(Short *blk)
+{
+    OSCL_UNUSED_ARG(blk);
+
+    return;
+}
+
+void idct_col1(Short *blk)
+{
+    blk[0] = blk[8] = blk[16] = blk[24] = blk[32] = blk[40] = blk[48] = blk[56] =
+                                              blk[0] << 3;
+    return ;
+}
+
+void idct_col2(Short *blk)
+{
+    int32 x0, x1, x3, x5, x7;//, x8;
+
+    x1 = blk[8];
+    x0 = ((int32)blk[0] << 11) + 128;
+    /* both upper and lower*/
+
+    x7 = W7 * x1;
+    x1 = W1 * x1;
+
+    x3 = x7;
+    x5 = (181 * (x1 - x7) + 128) >> 8;
+    x7 = (181 * (x1 + x7) + 128) >> 8;
+
+    blk[0] = (x0 + x1) >> 8;
+    blk[8] = (x0 + x7) >> 8;
+    blk[16] = (x0 + x5) >> 8;
+    blk[24] = (x0 + x3) >> 8;
+    blk[56] = (x0 - x1) >> 8;
+    blk[48] = (x0 - x7) >> 8;
+    blk[40] = (x0 - x5) >> 8;
+    blk[32] = (x0 - x3) >> 8;
+    return ;
+}
+
+void idct_col3(Short *blk)
+{
+    int32 x0, x1, x2, x3, x4, x5, x6, x7, x8;
+
+    x2 = blk[16];
+    x1 = blk[8];
+    x0 = ((int32)blk[0] << 11) + 128;
+
+    x4 = x0;
+    x6 = W6 * x2;
+    x2 = W2 * x2;
+    x8 = x0 - x2;
+    x0 += x2;
+    x2 = x8;
+    x8 = x4 - x6;
+    x4 += x6;
+    x6 = x8;
+
+    x7 = W7 * x1;
+    x1 = W1 * x1;
+    x3 = x7;
+    x5 = (181 * (x1 - x7) + 128) >> 8;
+    x7 = (181 * (x1 + x7) + 128) >> 8;
+
+    blk[0] = (x0 + x1) >> 8;
+    blk[8] = (x4 + x7) >> 8;
+    blk[16] = (x6 + x5) >> 8;
+    blk[24] = (x2 + x3) >> 8;
+    blk[56] = (x0 - x1) >> 8;
+    blk[48] = (x4 - x7) >> 8;
+    blk[40] = (x6 - x5) >> 8;
+    blk[32] = (x2 - x3) >> 8;
+    return ;
+}
+
+void idct_col4(Short *blk)
+{
+    int32 x0, x1, x2, x3, x4, x5, x6, x7, x8;
+    x2 = blk[16];
+    x1 = blk[8];
+    x3 = blk[24];
+    x0 = ((int32)blk[0] << 11) + 128;
+
+    x4 = x0;
+    x6 = W6 * x2;
+    x2 = W2 * x2;
+    x8 = x0 - x2;
+    x0 += x2;
+    x2 = x8;
+    x8 = x4 - x6;
+    x4 += x6;
+    x6 = x8;
+
+    x7 = W7 * x1;
+    x1 = W1 * x1;
+    x5 = W3 * x3;
+    x3 = -W5 * x3;
+    x8 = x1 - x5;
+    x1 += x5;
+    x5 = x8;
+    x8 = x7 - x3;
+    x3 += x7;
+    x7 = (181 * (x5 + x8) + 128) >> 8;
+    x5 = (181 * (x5 - x8) + 128) >> 8;
+
+
+    blk[0] = (x0 + x1) >> 8;
+    blk[8] = (x4 + x7) >> 8;
+    blk[16] = (x6 + x5) >> 8;
+    blk[24] = (x2 + x3) >> 8;
+    blk[56] = (x0 - x1) >> 8;
+    blk[48] = (x4 - x7) >> 8;
+    blk[40] = (x6 - x5) >> 8;
+    blk[32] = (x2 - x3) >> 8;
+    return ;
+}
+
+#ifndef SMALL_DCT
+void idct_col0x40(Short *blk)
+{
+    int32 x1, x3, x5, x7;//, x8;
+
+    x1 = blk[8];
+    /* both upper and lower*/
+
+    x7 = W7 * x1;
+    x1 = W1 * x1;
+
+    x3 = x7;
+    x5 = (181 * (x1 - x7) + 128) >> 8;
+    x7 = (181 * (x1 + x7) + 128) >> 8;
+
+    blk[0] = (128 + x1) >> 8;
+    blk[8] = (128 + x7) >> 8;
+    blk[16] = (128 + x5) >> 8;
+    blk[24] = (128 + x3) >> 8;
+    blk[56] = (128 - x1) >> 8;
+    blk[48] = (128 - x7) >> 8;
+    blk[40] = (128 - x5) >> 8;
+    blk[32] = (128 - x3) >> 8;
+
+    return ;
+}
+
+void idct_col0x20(Short *blk)
+{
+    int32 x0, x2, x4, x6;
+
+    x2 = blk[16];
+    x6 = W6 * x2;
+    x2 = W2 * x2;
+    x0 = 128 + x2;
+    x2 = 128 - x2;
+    x4 = 128 + x6;
+    x6 = 128 - x6;
+
+    blk[0] = (x0) >> 8;
+    blk[56] = (x0) >> 8;
+    blk[8] = (x4) >> 8;
+    blk[48] = (x4) >> 8;
+    blk[16] = (x6) >> 8;
+    blk[40] = (x6) >> 8;
+    blk[24] = (x2) >> 8;
+    blk[32] = (x2) >> 8;
+
+    return ;
+}
+
+void idct_col0x10(Short *blk)
+{
+    int32 x1, x3, x5,  x7;
+
+    x3 = blk[24];
+    x1 = W3 * x3;
+    x3 = W5 * x3;
+
+    x7 = (181 * (x3 - x1) + 128) >> 8;
+    x5 = (-181 * (x1 + x3) + 128) >> 8;
+
+
+    blk[0] = (128 + x1) >> 8;
+    blk[8] = (128 + x7) >> 8;
+    blk[16] = (128 + x5) >> 8;
+    blk[24] = (128 - x3) >> 8;
+    blk[56] = (128 - x1) >> 8;
+    blk[48] = (128 - x7) >> 8;
+    blk[40] = (128 - x5) >> 8;
+    blk[32] = (128 + x3) >> 8;
+
+    return ;
+}
+
+#endif /* SMALL_DCT */
+
+void idct_col(Short *blk)
+{
+    int32 x0, x1, x2, x3, x4, x5, x6, x7, x8;
+
+    x1 = (int32)blk[32] << 11;
+    x2 = blk[48];
+    x3 = blk[16];
+    x4 = blk[8];
+    x5 = blk[56];
+    x6 = blk[40];
+    x7 = blk[24];
+    x0 = ((int32)blk[0] << 11) + 128;
+
+    /* first stage */
+    x8 = W7 * (x4 + x5);
+    x4 = x8 + (W1 - W7) * x4;
+    x5 = x8 - (W1 + W7) * x5;
+    x8 = W3 * (x6 + x7);
+    x6 = x8 - (W3 - W5) * x6;
+    x7 = x8 - (W3 + W5) * x7;
+
+    /* second stage */
+    x8 = x0 + x1;
+    x0 -= x1;
+    x1 = W6 * (x3 + x2);
+    x2 = x1 - (W2 + W6) * x2;
+    x3 = x1 + (W2 - W6) * x3;
+    x1 = x4 + x6;
+    x4 -= x6;
+    x6 = x5 + x7;
+    x5 -= x7;
+
+    /* third stage */
+    x7 = x8 + x3;
+    x8 -= x3;
+    x3 = x0 + x2;
+    x0 -= x2;
+    x2 = (181 * (x4 + x5) + 128) >> 8;
+    x4 = (181 * (x4 - x5) + 128) >> 8;
+
+    /* fourth stage */
+    blk[0]    = (x7 + x1) >> 8;
+    blk[8] = (x3 + x2) >> 8;
+    blk[16] = (x0 + x4) >> 8;
+    blk[24] = (x8 + x6) >> 8;
+    blk[32] = (x8 - x6) >> 8;
+    blk[40] = (x0 - x4) >> 8;
+    blk[48] = (x3 - x2) >> 8;
+    blk[56] = (x7 - x1) >> 8;
+
+    return ;
+}
+
+/* This function should not be called at all ****/
+void idct_row0Inter(Short *srce, UChar *rec, Int lx)
+{
+    OSCL_UNUSED_ARG(srce);
+
+    OSCL_UNUSED_ARG(rec);
+
+    OSCL_UNUSED_ARG(lx);
+
+    return;
+}
+
+void idct_row1Inter(Short *blk, UChar *rec, Int lx)
+{
+    int tmp;
+    int i = 8;
+    uint32 pred_word, dst_word;
+    int res, res2;
+
+    /* preset the offset, such that we can take advantage pre-offset addressing mode   */
+    rec -= lx;
+    blk -= 8;
+
+    while (i--)
+    {
+        tmp = (*(blk += 8) + 32) >> 6;
+        *blk = 0;
+
+        pred_word = *((uint32*)(rec += lx)); /* read 4 bytes from pred */
+        res = tmp + (pred_word & 0xFF);
+        CLIP_RESULT(res);
+        res2 = tmp + ((pred_word >> 8) & 0xFF);
+        CLIP_RESULT(res2);
+        dst_word = (res2 << 8) | res;
+        res = tmp + ((pred_word >> 16) & 0xFF);
+        CLIP_RESULT(res);
+        dst_word |= (res << 16);
+        res = tmp + ((pred_word >> 24) & 0xFF);
+        CLIP_RESULT(res);
+        dst_word |= (res << 24);
+        *((uint32*)rec) = dst_word; /* save 4 bytes to dst */
+
+        pred_word = *((uint32*)(rec + 4)); /* read 4 bytes from pred */
+        res = tmp + (pred_word & 0xFF);
+        CLIP_RESULT(res);
+        res2 = tmp + ((pred_word >> 8) & 0xFF);
+        CLIP_RESULT(res2);
+        dst_word = (res2 << 8) | res;
+        res = tmp + ((pred_word >> 16) & 0xFF);
+        CLIP_RESULT(res);
+        dst_word |= (res << 16);
+        res = tmp + ((pred_word >> 24) & 0xFF);
+        CLIP_RESULT(res);
+        dst_word |= (res << 24);
+        *((uint32*)(rec + 4)) = dst_word; /* save 4 bytes to dst */
+    }
+    return;
+}
+
+void idct_row2Inter(Short *blk, UChar *rec, Int lx)
+{
+    int32 x0, x1, x2, x4, x5;
+    int i = 8;
+    uint32 pred_word, dst_word;
+    int res, res2;
+
+    /* preset the offset, such that we can take advantage pre-offset addressing mode   */
+    rec -= lx;
+    blk -= 8;
+
+    while (i--)
+    {
+        /* shortcut */
+        x4 = blk[9];
+        blk[9] = 0;
+        x0 = ((*(blk += 8)) << 8) + 8192;
+        *blk = 0;  /* for proper rounding in the fourth stage */
+
+        /* first stage */
+        x5 = (W7 * x4 + 4) >> 3;
+        x4 = (W1 * x4 + 4) >> 3;
+
+        /* third stage */
+        x2 = (181 * (x4 + x5) + 128) >> 8;
+        x1 = (181 * (x4 - x5) + 128) >> 8;
+
+        /* fourth stage */
+        pred_word = *((uint32*)(rec += lx)); /* read 4 bytes from pred */
+        res = (x0 + x4) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (x0 + x2) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (x0 + x1) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (x0 + x5) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)rec) = dst_word; /* save 4 bytes to dst */
+
+        pred_word = *((uint32*)(rec + 4)); /* read 4 bytes from pred */
+        res = (x0 - x5) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (x0 - x1) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (x0 - x2) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (x0 - x4) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)(rec + 4)) = dst_word; /* save 4 bytes to dst */
+    }
+    return ;
+}
+
+void idct_row3Inter(Short *blk, UChar *rec, Int lx)
+{
+    int32 x0, x1, x2, x3, x4, x5, x6, x7, x8;
+    int i = 8;
+    uint32 pred_word, dst_word;
+    int res, res2;
+
+    /* preset the offset, such that we can take advantage pre-offset addressing mode   */
+    rec -= lx;
+    blk -= 8;
+
+    while (i--)
+    {
+        x2 = blk[10];
+        blk[10] = 0;
+        x1 = blk[9];
+        blk[9] = 0;
+        x0 = ((*(blk += 8)) << 8) + 8192;
+        *blk = 0;  /* for proper rounding in the fourth stage */
+        /* both upper and lower*/
+        /* both x2orx6 and x0orx4 */
+
+        x4 = x0;
+        x6 = (W6 * x2 + 4) >> 3;
+        x2 = (W2 * x2 + 4) >> 3;
+        x8 = x0 - x2;
+        x0 += x2;
+        x2 = x8;
+        x8 = x4 - x6;
+        x4 += x6;
+        x6 = x8;
+
+        x7 = (W7 * x1 + 4) >> 3;
+        x1 = (W1 * x1 + 4) >> 3;
+        x3 = x7;
+        x5 = (181 * (x1 - x7) + 128) >> 8;
+        x7 = (181 * (x1 + x7) + 128) >> 8;
+
+        pred_word = *((uint32*)(rec += lx)); /* read 4 bytes from pred */
+        res = (x0 + x1) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (x4 + x7) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (x6 + x5) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (x2 + x3) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)rec) = dst_word; /* save 4 bytes to dst */
+
+        pred_word = *((uint32*)(rec + 4)); /* read 4 bytes from pred */
+        res = (x2 - x3) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (x6 - x5) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (x4 - x7) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (x0 - x1) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)(rec + 4)) = dst_word; /* save 4 bytes to dst */
+    }
+
+    return ;
+}
+
+void idct_row4Inter(Short *blk, UChar *rec, Int lx)
+{
+    int32 x0, x1, x2, x3, x4, x5, x6, x7, x8;
+    int i = 8;
+    uint32 pred_word, dst_word;
+    int res, res2;
+
+    /* preset the offset, such that we can take advantage pre-offset addressing mode   */
+    rec -= lx;
+    blk -= 8;
+
+    while (i--)
+    {
+        x2 = blk[10];
+        blk[10] = 0;
+        x1 = blk[9];
+        blk[9] = 0;
+        x3 = blk[11];
+        blk[11] = 0;
+        x0 = ((*(blk += 8)) << 8) + 8192;
+        *blk = 0;   /* for proper rounding in the fourth stage */
+
+        x4 = x0;
+        x6 = (W6 * x2 + 4) >> 3;
+        x2 = (W2 * x2 + 4) >> 3;
+        x8 = x0 - x2;
+        x0 += x2;
+        x2 = x8;
+        x8 = x4 - x6;
+        x4 += x6;
+        x6 = x8;
+
+        x7 = (W7 * x1 + 4) >> 3;
+        x1 = (W1 * x1 + 4) >> 3;
+        x5 = (W3 * x3 + 4) >> 3;
+        x3 = (- W5 * x3 + 4) >> 3;
+        x8 = x1 - x5;
+        x1 += x5;
+        x5 = x8;
+        x8 = x7 - x3;
+        x3 += x7;
+        x7 = (181 * (x5 + x8) + 128) >> 8;
+        x5 = (181 * (x5 - x8) + 128) >> 8;
+
+        pred_word = *((uint32*)(rec += lx)); /* read 4 bytes from pred */
+        res = (x0 + x1) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (x4 + x7) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (x6 + x5) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (x2 + x3) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)rec) = dst_word; /* save 4 bytes to dst */
+
+        pred_word = *((uint32*)(rec + 4)); /* read 4 bytes from pred */
+        res = (x2 - x3) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (x6 - x5) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (x4 - x7) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (x0 - x1) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)(rec + 4)) = dst_word; /* save 4 bytes to dst */
+    }
+    return ;
+}
+
+#ifndef SMALL_DCT
+void idct_row0x40Inter(Short *blk, UChar *rec, Int lx)
+{
+    int32 x1, x2, x4, x5;
+    int i = 8;
+    uint32 pred_word, dst_word;
+    int res, res2;
+
+    /* preset the offset, such that we can take advantage pre-offset addressing mode   */
+    rec -= lx;
+
+    while (i--)
+    {
+        /* shortcut */
+        x4 = blk[1];
+        blk[1] = 0;
+        blk += 8;  /* for proper rounding in the fourth stage */
+
+        /* first stage */
+        x5 = (W7 * x4 + 4) >> 3;
+        x4 = (W1 * x4 + 4) >> 3;
+
+        /* third stage */
+        x2 = (181 * (x4 + x5) + 128) >> 8;
+        x1 = (181 * (x4 - x5) + 128) >> 8;
+
+        /* fourth stage */
+        pred_word = *((uint32*)(rec += lx)); /* read 4 bytes from pred */
+        res = (8192 + x4) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (8192 + x2) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (8192 + x1) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (8192 + x5) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)rec) = dst_word; /* save 4 bytes to dst */
+
+        pred_word = *((uint32*)(rec + 4)); /* read 4 bytes from pred */
+        res = (8192 - x5) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (8192 - x1) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (8192 - x2) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (8192 - x4) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)(rec + 4)) = dst_word; /* save 4 bytes to dst */
+    }
+    return ;
+}
+
+void idct_row0x20Inter(Short *blk, UChar *rec, Int lx)
+{
+    int32 x0, x2, x4, x6;
+    int i = 8;
+    uint32 pred_word, dst_word;
+    int res, res2;
+
+    /* preset the offset, such that we can take advantage pre-offset addressing mode   */
+    rec -= lx;
+
+    while (i--)
+    {
+        x2 = blk[2];
+        blk[2] = 0;
+        blk += 8; /* for proper rounding in the fourth stage */
+        /* both upper and lower*/
+        /* both x2orx6 and x0orx4 */
+        x6 = (W6 * x2 + 4) >> 3;
+        x2 = (W2 * x2 + 4) >> 3;
+        x0 = 8192 + x2;
+        x2 = 8192 - x2;
+        x4 = 8192 + x6;
+        x6 = 8192 - x6;
+
+        pred_word = *((uint32*)(rec += lx)); /* read 4 bytes from pred */
+        res = (x0) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (x4) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (x6) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (x2) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)rec) = dst_word; /* save 4 bytes to dst */
+
+        pred_word = *((uint32*)(rec + 4)); /* read 4 bytes from pred */
+        res = (x2) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (x6) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (x4) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (x0) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)(rec + 4)) = dst_word; /* save 4 bytes to dst */
+    }
+
+    return ;
+}
+
+void idct_row0x10Inter(Short *blk, UChar *rec, Int lx)
+{
+    int32 x1, x3, x5, x7;
+    int i = 8;
+    uint32 pred_word, dst_word;
+    int res, res2;
+
+    /* preset the offset, such that we can take advantage pre-offset addressing mode   */
+    rec -= lx;
+
+    while (i--)
+    {
+        x3 = blk[3];
+        blk[3] = 0;
+        blk += 8;
+
+        x1 = (W3 * x3 + 4) >> 3;
+        x3 = (-W5 * x3 + 4) >> 3;
+
+        x7 = (-181 * (x3 + x1) + 128) >> 8;
+        x5 = (181 * (x3 - x1) + 128) >> 8;
+
+        pred_word = *((uint32*)(rec += lx)); /* read 4 bytes from pred */
+        res = (8192 + x1) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (8192 + x7) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (8192 + x5) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (8192 + x3) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)rec) = dst_word; /* save 4 bytes to dst */
+
+        pred_word = *((uint32*)(rec + 4)); /* read 4 bytes from pred */
+        res = (8192 - x3) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (8192 - x5) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (8192 - x7) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (8192 - x1) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)(rec + 4)) = dst_word; /* save 4 bytes to dst */
+    }
+    return ;
+}
+
+#endif /* SMALL_DCT */
+
+void idct_rowInter(Short *blk, UChar *rec, Int lx)
+{
+    int32 x0, x1, x2, x3, x4, x5, x6, x7, x8;
+    int i = 8;
+    uint32 pred_word, dst_word;
+    int res, res2;
+
+    /* preset the offset, such that we can take advantage pre-offset addressing mode   */
+    rec -= lx;
+    blk -= 8;
+
+    while (i--)
+    {
+        x1 = (int32)blk[12] << 8;
+        blk[12] = 0;
+        x2 = blk[14];
+        blk[14] = 0;
+        x3 = blk[10];
+        blk[10] = 0;
+        x4 = blk[9];
+        blk[9] = 0;
+        x5 = blk[15];
+        blk[15] = 0;
+        x6 = blk[13];
+        blk[13] = 0;
+        x7 = blk[11];
+        blk[11] = 0;
+        x0 = ((*(blk += 8)) << 8) + 8192;
+        *blk = 0;   /* for proper rounding in the fourth stage */
+
+        /* first stage */
+        x8 = W7 * (x4 + x5) + 4;
+        x4 = (x8 + (W1 - W7) * x4) >> 3;
+        x5 = (x8 - (W1 + W7) * x5) >> 3;
+        x8 = W3 * (x6 + x7) + 4;
+        x6 = (x8 - (W3 - W5) * x6) >> 3;
+        x7 = (x8 - (W3 + W5) * x7) >> 3;
+
+        /* second stage */
+        x8 = x0 + x1;
+        x0 -= x1;
+        x1 = W6 * (x3 + x2) + 4;
+        x2 = (x1 - (W2 + W6) * x2) >> 3;
+        x3 = (x1 + (W2 - W6) * x3) >> 3;
+        x1 = x4 + x6;
+        x4 -= x6;
+        x6 = x5 + x7;
+        x5 -= x7;
+
+        /* third stage */
+        x7 = x8 + x3;
+        x8 -= x3;
+        x3 = x0 + x2;
+        x0 -= x2;
+        x2 = (181 * (x4 + x5) + 128) >> 8;
+        x4 = (181 * (x4 - x5) + 128) >> 8;
+
+        /* fourth stage */
+        pred_word = *((uint32*)(rec += lx)); /* read 4 bytes from pred */
+
+        res = (x7 + x1) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (x3 + x2) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (x0 + x4) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (x8 + x6) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)rec) = dst_word; /* save 4 bytes to dst */
+
+        pred_word = *((uint32*)(rec + 4)); /* read 4 bytes from pred */
+
+        res = (x8 - x6) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (x0 - x4) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (x3 - x2) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (x7 - x1) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)(rec + 4)) = dst_word; /* save 4 bytes to dst */
+    }
+    return;
+}
+
+void idct_row0Intra(Short *srce, UChar *rec, Int lx)
+{
+    OSCL_UNUSED_ARG(srce);
+
+    OSCL_UNUSED_ARG(rec);
+
+    OSCL_UNUSED_ARG(lx);
+
+    return;
+}
+
+void idct_row1Intra(Short *blk, UChar *rec, Int lx)
+{
+    int32 tmp;
+    int i = 8;
+
+    rec -= lx;
+    blk -= 8;
+    while (i--)
+    {
+        tmp = ((*(blk += 8) + 32) >> 6);
+        *blk = 0;
+        CLIP_RESULT(tmp)
+
+        tmp |= (tmp << 8);
+        tmp |= (tmp << 16);
+        *((uint32*)(rec += lx)) = tmp;
+        *((uint32*)(rec + 4)) = tmp;
+    }
+    return;
+}
+
+void idct_row2Intra(Short *blk, UChar *rec, Int lx)
+{
+    int32 x0, x1, x2, x4, x5;
+    int res, res2;
+    uint32 dst_word;
+    int i = 8;
+
+    rec -= lx;
+    blk -= 8;
+    while (i--)
+    {
+        /* shortcut */
+        x4 = blk[9];
+        blk[9] = 0;
+        x0 = ((*(blk += 8)) << 8) + 8192;
+        *blk = 0;   /* for proper rounding in the fourth stage */
+
+        /* first stage */
+        x5 = (W7 * x4 + 4) >> 3;
+        x4 = (W1 * x4 + 4) >> 3;
+
+        /* third stage */
+        x2 = (181 * (x4 + x5) + 128) >> 8;
+        x1 = (181 * (x4 - x5) + 128) >> 8;
+
+        /* fourth stage */
+        res = ((x0 + x4) >> 14);
+        CLIP_RESULT(res)
+        res2 = ((x0 + x2) >> 14);
+        CLIP_RESULT(res2)
+        dst_word = (res2 << 8) | res;
+        res = ((x0 + x1) >> 14);
+        CLIP_RESULT(res)
+        dst_word |= (res << 16);
+        res = ((x0 + x5) >> 14);
+        CLIP_RESULT(res)
+        dst_word |= (res << 24);
+        *((uint32*)(rec += lx)) = dst_word;
+
+        res = ((x0 - x5) >> 14);
+        CLIP_RESULT(res)
+        res2 = ((x0 - x1) >> 14);
+        CLIP_RESULT(res2)
+        dst_word = (res2 << 8) | res;
+        res = ((x0 - x2) >> 14);
+        CLIP_RESULT(res)
+        dst_word |= (res << 16);
+        res = ((x0 - x4) >> 14);
+        CLIP_RESULT(res)
+        dst_word |= (res << 24);
+        *((uint32*)(rec + 4)) = dst_word;
+    }
+    return ;
+}
+
+void idct_row3Intra(Short *blk, UChar *rec, Int lx)
+{
+    int32 x0, x1, x2, x3, x4, x5, x6, x7, x8;
+    int res, res2;
+    uint32 dst_word;
+    int i = 8;
+
+    rec -= lx;
+    blk -= 8;
+    while (i--)
+    {
+        x2 = blk[10];
+        blk[10] = 0;
+        x1 = blk[9];
+        blk[9] = 0;
+        x0 = ((*(blk += 8)) << 8) + 8192;
+        *blk = 0;/* for proper rounding in the fourth stage */
+        /* both upper and lower*/
+        /* both x2orx6 and x0orx4 */
+
+        x4 = x0;
+        x6 = (W6 * x2 + 4) >> 3;
+        x2 = (W2 * x2 + 4) >> 3;
+        x8 = x0 - x2;
+        x0 += x2;
+        x2 = x8;
+        x8 = x4 - x6;
+        x4 += x6;
+        x6 = x8;
+
+        x7 = (W7 * x1 + 4) >> 3;
+        x1 = (W1 * x1 + 4) >> 3;
+        x3 = x7;
+        x5 = (181 * (x1 - x7) + 128) >> 8;
+        x7 = (181 * (x1 + x7) + 128) >> 8;
+
+        res = ((x0 + x1) >> 14);
+        CLIP_RESULT(res)
+        res2 = ((x4 + x7) >> 14);
+        CLIP_RESULT(res2)
+        dst_word = (res2 << 8) | res;
+        res = ((x6 + x5) >> 14);
+        CLIP_RESULT(res)
+        dst_word |= (res << 16);
+        res = ((x2 + x3) >> 14);
+        CLIP_RESULT(res)
+        dst_word |= (res << 24);
+        *((uint32*)(rec += lx)) = dst_word;
+
+        res = ((x2 - x3) >> 14);
+        CLIP_RESULT(res)
+        res2 = ((x6 - x5) >> 14);
+        CLIP_RESULT(res2)
+        dst_word = (res2 << 8) | res;
+        res = ((x4 - x7) >> 14);
+        CLIP_RESULT(res)
+        dst_word |= (res << 16);
+        res = ((x0 - x1) >> 14);
+        CLIP_RESULT(res)
+        dst_word |= (res << 24);
+        *((uint32*)(rec + 4)) = dst_word;
+
+    }
+    return ;
+}
+
+void idct_row4Intra(Short *blk, UChar *rec, Int lx)
+{
+    int32 x0, x1, x2, x3, x4, x5, x6, x7, x8;
+    int res, res2;
+    uint32 dst_word;
+    int i = 8;
+
+    rec -= lx;
+    blk -= 8;
+    while (i--)
+    {
+        x2 = blk[10];
+        blk[10] = 0;
+        x1 = blk[9];
+        blk[9] = 0;
+        x3 = blk[11];
+        blk[11] = 0;
+        x0 = ((*(blk += 8)) << 8) + 8192;
+        *blk = 0; /* for proper rounding in the fourth stage */
+
+        x4 = x0;
+        x6 = (W6 * x2 + 4) >> 3;
+        x2 = (W2 * x2 + 4) >> 3;
+        x8 = x0 - x2;
+        x0 += x2;
+        x2 = x8;
+        x8 = x4 - x6;
+        x4 += x6;
+        x6 = x8;
+
+        x7 = (W7 * x1 + 4) >> 3;
+        x1 = (W1 * x1 + 4) >> 3;
+        x5 = (W3 * x3 + 4) >> 3;
+        x3 = (- W5 * x3 + 4) >> 3;
+        x8 = x1 - x5;
+        x1 += x5;
+        x5 = x8;
+        x8 = x7 - x3;
+        x3 += x7;
+        x7 = (181 * (x5 + x8) + 128) >> 8;
+        x5 = (181 * (x5 - x8) + 128) >> 8;
+
+        res = ((x0 + x1) >> 14);
+        CLIP_RESULT(res)
+        res2 = ((x4 + x7) >> 14);
+        CLIP_RESULT(res2)
+        dst_word = (res2 << 8) | res;
+        res = ((x6 + x5) >> 14);
+        CLIP_RESULT(res)
+        dst_word |= (res << 16);
+        res = ((x2 + x3) >> 14);
+        CLIP_RESULT(res)
+        dst_word |= (res << 24);
+        *((uint32*)(rec += lx)) = dst_word;
+
+        res = ((x2 - x3) >> 14);
+        CLIP_RESULT(res)
+        res2 = ((x6 - x5) >> 14);
+        CLIP_RESULT(res2)
+        dst_word = (res2 << 8) | res;
+        res = ((x4 - x7) >> 14);
+        CLIP_RESULT(res)
+        dst_word |= (res << 16);
+        res = ((x0 - x1) >> 14);
+        CLIP_RESULT(res)
+        dst_word |= (res << 24);
+        *((uint32*)(rec + 4)) = dst_word;
+    }
+
+    return ;
+}
+
+#ifndef SMALL_DCT
+void idct_row0x40Intra(Short *blk, UChar *rec, Int lx)
+{
+    int32  x1, x2, x4, x5;
+    int res, res2;
+    uint32 dst_word;
+    int i = 8;
+
+    rec -= lx;
+
+    while (i--)
+    {
+        /* shortcut */
+        x4 = blk[1];
+        blk[1] = 0;
+        blk += 8;
+
+        /* first stage */
+        x5 = (W7 * x4 + 4) >> 3;
+        x4 = (W1 * x4 + 4) >> 3;
+
+        /* third stage */
+        x2 = (181 * (x4 + x5) + 128) >> 8;
+        x1 = (181 * (x4 - x5) + 128) >> 8;
+
+        /* fourth stage */
+        res = ((8192 + x4) >> 14);
+        CLIP_RESULT(res)
+        res2 = ((8192 + x2) >> 14);
+        CLIP_RESULT(res2)
+        dst_word = (res2 << 8) | res;
+        res = ((8192 + x1) >> 14);
+        CLIP_RESULT(res)
+        dst_word |= (res << 16);
+        res = ((8192 + x5) >> 14);
+        CLIP_RESULT(res)
+        dst_word |= (res << 24);
+        *((uint32*)(rec += lx)) = dst_word;
+
+        res = ((8192 - x5) >> 14);
+        CLIP_RESULT(res)
+        res2 = ((8192 - x1) >> 14);
+        CLIP_RESULT(res2)
+        dst_word = (res2 << 8) | res;
+        res = ((8192 - x2) >> 14);
+        CLIP_RESULT(res)
+        dst_word |= (res << 16);
+        res = ((8192 - x4) >> 14);
+        CLIP_RESULT(res)
+        dst_word |= (res << 24);
+        *((uint32*)(rec + 4)) = dst_word;
+
+    }
+    return ;
+}
+
+void idct_row0x20Intra(Short *blk, UChar *rec, Int lx)
+{
+    int32 x0, x2, x4, x6;
+    int res, res2;
+    uint32 dst_word;
+    int i = 8;
+
+    rec -= lx;
+    while (i--)
+    {
+        x2 = blk[2];
+        blk[2] = 0;
+        blk += 8;
+
+        /* both upper and lower*/
+        /* both x2orx6 and x0orx4 */
+        x6 = (W6 * x2 + 4) >> 3;
+        x2 = (W2 * x2 + 4) >> 3;
+        x0 = 8192 + x2;
+        x2 = 8192 - x2;
+        x4 = 8192 + x6;
+        x6 = 8192 - x6;
+
+        res = ((x0) >> 14);
+        CLIP_RESULT(res)
+        res2 = ((x4) >> 14);
+        CLIP_RESULT(res2)
+        dst_word = (res2 << 8) | res;
+        res = ((x6) >> 14);
+        CLIP_RESULT(res)
+        dst_word |= (res << 16);
+        res = ((x2) >> 14);
+        CLIP_RESULT(res)
+        dst_word |= (res << 24);
+        *((uint32*)(rec += lx)) = dst_word;
+
+        res = ((x2) >> 14);
+        CLIP_RESULT(res)
+        res2 = ((x6) >> 14);
+        CLIP_RESULT(res2)
+        dst_word = (res2 << 8) | res;
+        res = ((x4) >> 14);
+        CLIP_RESULT(res)
+        dst_word |= (res << 16);
+        res = ((x0) >> 14);
+        CLIP_RESULT(res)
+        dst_word |= (res << 24);
+        *((uint32*)(rec + 4)) = dst_word;
+
+    }
+    return ;
+}
+
+void idct_row0x10Intra(Short *blk, UChar *rec, Int lx)
+{
+    int32 x1, x3, x5, x7;
+    int res, res2;
+    uint32 dst_word;
+    int i = 8;
+
+    rec -= lx;
+    while (i--)
+    {
+        x3 = blk[3];
+        blk[3] = 0 ;
+        blk += 8;
+
+        x1 = (W3 * x3 + 4) >> 3;
+        x3 = (W5 * x3 + 4) >> 3;
+
+        x7 = (181 * (x3 - x1) + 128) >> 8;
+        x5 = (-181 * (x1 + x3) + 128) >> 8;
+
+        res = ((8192 + x1) >> 14);
+        CLIP_RESULT(res)
+        res2 = ((8192 + x7) >> 14);
+        CLIP_RESULT(res2)
+        dst_word = (res2 << 8) | res;
+        res = ((8192 + x5) >> 14);
+        CLIP_RESULT(res)
+        dst_word |= (res << 16);
+        res = ((8192 - x3) >> 14);
+        CLIP_RESULT(res)
+        dst_word |= (res << 24);
+        *((uint32*)(rec += lx)) = dst_word;
+
+        res = ((8192 + x3) >> 14);
+        CLIP_RESULT(res)
+        res2 = ((8192 - x5) >> 14);
+        CLIP_RESULT(res2)
+        dst_word = (res2 << 8) | res;
+        res = ((8192 - x7) >> 14);
+        CLIP_RESULT(res)
+        dst_word |= (res << 16);
+        res = ((8192 - x1) >> 14);
+        CLIP_RESULT(res)
+        dst_word |= (res << 24);
+        *((uint32*)(rec + 4)) = dst_word;
+
+    }
+
+    return ;
+}
+
+#endif /* SMALL_DCT */
+void idct_rowIntra(Short *blk, UChar *rec, Int lx)
+{
+    int32 x0, x1, x2, x3, x4, x5, x6, x7, x8;
+    int i = 8;
+    int res, res2;
+    uint32 dst_word;
+
+    blk -= 8;
+    rec -= lx;
+
+    while (i--)
+    {
+        x1 = (int32)blk[12] << 8;
+        blk[12] = 0;
+        x2 = blk[14];
+        blk[14] = 0;
+        x3 = blk[10];
+        blk[10] = 0;
+        x4 = blk[9];
+        blk[9] = 0;
+        x5 = blk[15];
+        blk[15] = 0;
+        x6 = blk[13];
+        blk[13] = 0;
+        x7 = blk[11];
+        blk[11] = 0;
+        x0 = ((*(blk += 8)) << 8) + 8192;
+        *blk = 0;  /* for proper rounding in the fourth stage */
+
+        /* first stage */
+        x8 = W7 * (x4 + x5) + 4;
+        x4 = (x8 + (W1 - W7) * x4) >> 3;
+        x5 = (x8 - (W1 + W7) * x5) >> 3;
+        x8 = W3 * (x6 + x7) + 4;
+        x6 = (x8 - (W3 - W5) * x6) >> 3;
+        x7 = (x8 - (W3 + W5) * x7) >> 3;
+
+        /* second stage */
+        x8 = x0 + x1;
+        x0 -= x1;
+        x1 = W6 * (x3 + x2) + 4;
+        x2 = (x1 - (W2 + W6) * x2) >> 3;
+        x3 = (x1 + (W2 - W6) * x3) >> 3;
+        x1 = x4 + x6;
+        x4 -= x6;
+        x6 = x5 + x7;
+        x5 -= x7;
+
+        /* third stage */
+        x7 = x8 + x3;
+        x8 -= x3;
+        x3 = x0 + x2;
+        x0 -= x2;
+        x2 = (181 * (x4 + x5) + 128) >> 8;
+        x4 = (181 * (x4 - x5) + 128) >> 8;
+
+        /* fourth stage */
+        res = ((x7 + x1) >> 14);
+        CLIP_RESULT(res)
+        res2 = ((x3 + x2) >> 14);
+        CLIP_RESULT(res2)
+        dst_word = res | (res2 << 8);
+        res = ((x0 + x4) >> 14);
+        CLIP_RESULT(res)
+        dst_word |= (res << 16);
+        res = ((x8 + x6) >> 14);
+        CLIP_RESULT(res)
+        dst_word |= (res << 24);
+        *((uint32*)(rec += lx)) = dst_word;
+
+        res = ((x8 - x6) >> 14);
+        CLIP_RESULT(res)
+        res2 = ((x0 - x4) >> 14);
+        CLIP_RESULT(res2)
+        dst_word = res | (res2 << 8);
+        res = ((x3 - x2) >> 14);
+        CLIP_RESULT(res)
+        dst_word |= (res << 16);
+        res = ((x7 - x1) >> 14);
+        CLIP_RESULT(res)
+        dst_word |= (res << 24);
+        *((uint32*)(rec + 4)) = dst_word;
+    }
+    return;
+}
+
+
+/* This function should not be called at all ****/
+void idct_row0zmv(Short *srce, UChar *rec, UChar *pred, Int lx)
+{
+    OSCL_UNUSED_ARG(srce);
+    OSCL_UNUSED_ARG(rec);
+    OSCL_UNUSED_ARG(pred);
+    OSCL_UNUSED_ARG(lx);
+
+    return;
+}
+
+void idct_row1zmv(Short *blk, UChar *rec, UChar *pred, Int lx)
+{
+    int tmp;
+    int i = 8;
+    uint32 pred_word, dst_word;
+    int res, res2;
+
+    /* preset the offset, such that we can take advantage pre-offset addressing mode   */
+    pred -= 16;
+    rec -= lx;
+    blk -= 8;
+
+    while (i--)
+    {
+        tmp = (*(blk += 8) + 32) >> 6;
+        *blk = 0;
+
+        pred_word = *((uint32*)(pred += 16)); /* read 4 bytes from pred */
+        res = tmp + (pred_word & 0xFF);
+        CLIP_RESULT(res);
+        res2 = tmp + ((pred_word >> 8) & 0xFF);
+        CLIP_RESULT(res2);
+        dst_word = (res2 << 8) | res;
+        res = tmp + ((pred_word >> 16) & 0xFF);
+        CLIP_RESULT(res);
+        dst_word |= (res << 16);
+        res = tmp + ((pred_word >> 24) & 0xFF);
+        CLIP_RESULT(res);
+        dst_word |= (res << 24);
+        *((uint32*)(rec += lx)) = dst_word; /* save 4 bytes to dst */
+
+        pred_word = *((uint32*)(pred + 4)); /* read 4 bytes from pred */
+        res = tmp + (pred_word & 0xFF);
+        CLIP_RESULT(res);
+        res2 = tmp + ((pred_word >> 8) & 0xFF);
+        CLIP_RESULT(res2);
+        dst_word = (res2 << 8) | res;
+        res = tmp + ((pred_word >> 16) & 0xFF);
+        CLIP_RESULT(res);
+        dst_word |= (res << 16);
+        res = tmp + ((pred_word >> 24) & 0xFF);
+        CLIP_RESULT(res);
+        dst_word |= (res << 24);
+        *((uint32*)(rec + 4)) = dst_word; /* save 4 bytes to dst */
+    }
+    return;
+}
+
+void idct_row2zmv(Short *blk, UChar *rec, UChar *pred, Int lx)
+{
+    int32 x0, x1, x2, x4, x5;
+    int i = 8;
+    uint32 pred_word, dst_word;
+    int res, res2;
+
+    /* preset the offset, such that we can take advantage pre-offset addressing mode   */
+    rec -= lx;
+    pred -= 16;
+    blk -= 8;
+
+    while (i--)
+    {
+        /* shortcut */
+        x4 = blk[9];
+        blk[9] = 0;
+        x0 = ((*(blk += 8)) << 8) + 8192;
+        *blk = 0;  /* for proper rounding in the fourth stage */
+
+        /* first stage */
+        x5 = (W7 * x4 + 4) >> 3;
+        x4 = (W1 * x4 + 4) >> 3;
+
+        /* third stage */
+        x2 = (181 * (x4 + x5) + 128) >> 8;
+        x1 = (181 * (x4 - x5) + 128) >> 8;
+
+        /* fourth stage */
+        pred_word = *((uint32*)(pred += 16)); /* read 4 bytes from pred */
+        res = (x0 + x4) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (x0 + x2) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (x0 + x1) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (x0 + x5) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)(rec += lx)) = dst_word; /* save 4 bytes to dst */
+
+        pred_word = *((uint32*)(pred + 4)); /* read 4 bytes from pred */
+        res = (x0 - x5) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (x0 - x1) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (x0 - x2) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (x0 - x4) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)(rec + 4)) = dst_word; /* save 4 bytes to dst */
+    }
+    return ;
+}
+
+void idct_row3zmv(Short *blk, UChar *rec, UChar *pred, Int lx)
+{
+    int32 x0, x1, x2, x3, x4, x5, x6, x7, x8;
+    int i = 8;
+    uint32 pred_word, dst_word;
+    int res, res2;
+
+    /* preset the offset, such that we can take advantage pre-offset addressing mode   */
+    rec -= lx;
+    pred -= 16;
+    blk -= 8;
+
+    while (i--)
+    {
+        x2 = blk[10];
+        blk[10] = 0;
+        x1 = blk[9];
+        blk[9] = 0;
+        x0 = ((*(blk += 8)) << 8) + 8192;
+        *blk = 0;  /* for proper rounding in the fourth stage */
+        /* both upper and lower*/
+        /* both x2orx6 and x0orx4 */
+
+        x4 = x0;
+        x6 = (W6 * x2 + 4) >> 3;
+        x2 = (W2 * x2 + 4) >> 3;
+        x8 = x0 - x2;
+        x0 += x2;
+        x2 = x8;
+        x8 = x4 - x6;
+        x4 += x6;
+        x6 = x8;
+
+        x7 = (W7 * x1 + 4) >> 3;
+        x1 = (W1 * x1 + 4) >> 3;
+        x3 = x7;
+        x5 = (181 * (x1 - x7) + 128) >> 8;
+        x7 = (181 * (x1 + x7) + 128) >> 8;
+
+        pred_word = *((uint32*)(pred += 16)); /* read 4 bytes from pred */
+        res = (x0 + x1) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (x4 + x7) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (x6 + x5) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (x2 + x3) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)(rec += lx)) = dst_word; /* save 4 bytes to dst */
+
+        pred_word = *((uint32*)(pred + 4)); /* read 4 bytes from pred */
+        res = (x2 - x3) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (x6 - x5) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (x4 - x7) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (x0 - x1) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)(rec + 4)) = dst_word; /* save 4 bytes to dst */
+    }
+
+    return ;
+}
+
+void idct_row4zmv(Short *blk, UChar *rec, UChar *pred, Int lx)
+{
+    int32 x0, x1, x2, x3, x4, x5, x6, x7, x8;
+    int i = 8;
+    uint32 pred_word, dst_word;
+    int res, res2;
+
+    /* preset the offset, such that we can take advantage pre-offset addressing mode   */
+    rec -= lx;
+    pred -= 16;
+    blk -= 8;
+
+    while (i--)
+    {
+        x2 = blk[10];
+        blk[10] = 0;
+        x1 = blk[9];
+        blk[9] = 0;
+        x3 = blk[11];
+        blk[11] = 0;
+        x0 = ((*(blk += 8)) << 8) + 8192;
+        *blk = 0;   /* for proper rounding in the fourth stage */
+
+        x4 = x0;
+        x6 = (W6 * x2 + 4) >> 3;
+        x2 = (W2 * x2 + 4) >> 3;
+        x8 = x0 - x2;
+        x0 += x2;
+        x2 = x8;
+        x8 = x4 - x6;
+        x4 += x6;
+        x6 = x8;
+
+        x7 = (W7 * x1 + 4) >> 3;
+        x1 = (W1 * x1 + 4) >> 3;
+        x5 = (W3 * x3 + 4) >> 3;
+        x3 = (- W5 * x3 + 4) >> 3;
+        x8 = x1 - x5;
+        x1 += x5;
+        x5 = x8;
+        x8 = x7 - x3;
+        x3 += x7;
+        x7 = (181 * (x5 + x8) + 128) >> 8;
+        x5 = (181 * (x5 - x8) + 128) >> 8;
+
+        pred_word = *((uint32*)(pred += 16)); /* read 4 bytes from pred */
+        res = (x0 + x1) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (x4 + x7) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (x6 + x5) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (x2 + x3) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)(rec += lx)) = dst_word; /* save 4 bytes to dst */
+
+        pred_word = *((uint32*)(pred + 4)); /* read 4 bytes from pred */
+        res = (x2 - x3) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (x6 - x5) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (x4 - x7) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (x0 - x1) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)(rec + 4)) = dst_word; /* save 4 bytes to dst */
+    }
+    return ;
+}
+
+#ifndef SMALL_DCT
+void idct_row0x40zmv(Short *blk, UChar *rec, UChar *pred, Int lx)
+{
+    int32 x1, x2, x4, x5;
+    int i = 8;
+    uint32 pred_word, dst_word;
+    int res, res2;
+
+    /* preset the offset, such that we can take advantage pre-offset addressing mode   */
+    rec -= lx;
+    pred -= 16;
+
+    while (i--)
+    {
+        /* shortcut */
+        x4 = blk[1];
+        blk[1] = 0;
+        blk += 8;  /* for proper rounding in the fourth stage */
+
+        /* first stage */
+        x5 = (W7 * x4 + 4) >> 3;
+        x4 = (W1 * x4 + 4) >> 3;
+
+        /* third stage */
+        x2 = (181 * (x4 + x5) + 128) >> 8;
+        x1 = (181 * (x4 - x5) + 128) >> 8;
+
+        /* fourth stage */
+        pred_word = *((uint32*)(pred += 16)); /* read 4 bytes from pred */
+        res = (8192 + x4) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (8192 + x2) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (8192 + x1) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (8192 + x5) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)(rec += lx)) = dst_word; /* save 4 bytes to dst */
+
+        pred_word = *((uint32*)(pred + 4)); /* read 4 bytes from pred */
+        res = (8192 - x5) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (8192 - x1) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (8192 - x2) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (8192 - x4) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)(rec + 4)) = dst_word; /* save 4 bytes to dst */
+    }
+    return ;
+}
+
+void idct_row0x20zmv(Short *blk, UChar *rec, UChar *pred, Int lx)
+{
+    int32 x0, x2, x4, x6;
+    int i = 8;
+    uint32 pred_word, dst_word;
+    int res, res2;
+
+    /* preset the offset, such that we can take advantage pre-offset addressing mode   */
+    rec -= lx;
+    pred -= 16;
+
+    while (i--)
+    {
+        x2 = blk[2];
+        blk[2] = 0;
+        blk += 8; /* for proper rounding in the fourth stage */
+        /* both upper and lower*/
+        /* both x2orx6 and x0orx4 */
+        x6 = (W6 * x2 + 4) >> 3;
+        x2 = (W2 * x2 + 4) >> 3;
+        x0 = 8192 + x2;
+        x2 = 8192 - x2;
+        x4 = 8192 + x6;
+        x6 = 8192 - x6;
+
+        pred_word = *((uint32*)(pred += 16)); /* read 4 bytes from pred */
+        res = (x0) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (x4) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (x6) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (x2) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)(rec += lx)) = dst_word; /* save 4 bytes to dst */
+
+        pred_word = *((uint32*)(pred + 4)); /* read 4 bytes from pred */
+        res = (x2) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (x6) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (x4) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (x0) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)(rec + 4)) = dst_word; /* save 4 bytes to dst */
+    }
+
+    return ;
+}
+
+void idct_row0x10zmv(Short *blk, UChar *rec, UChar *pred, Int lx)
+{
+    int32 x1, x3, x5, x7;
+    int i = 8;
+    uint32 pred_word, dst_word;
+    int res, res2;
+
+    /* preset the offset, such that we can take advantage pre-offset addressing mode   */
+    rec -= lx;
+    pred -= 16;
+
+    while (i--)
+    {
+        x3 = blk[3];
+        blk[3] = 0;
+        blk += 8;
+
+        x1 = (W3 * x3 + 4) >> 3;
+        x3 = (-W5 * x3 + 4) >> 3;
+
+        x7 = (-181 * (x3 + x1) + 128) >> 8;
+        x5 = (181 * (x3 - x1) + 128) >> 8;
+
+        pred_word = *((uint32*)(pred += 16)); /* read 4 bytes from pred */
+        res = (8192 + x1) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (8192 + x7) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (8192 + x5) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (8192 + x3) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)(rec += lx)) = dst_word; /* save 4 bytes to dst */
+
+        pred_word = *((uint32*)(pred + 4)); /* read 4 bytes from pred */
+        res = (8192 - x3) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (8192 - x5) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (8192 - x7) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (8192 - x1) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)(rec + 4)) = dst_word; /* save 4 bytes to dst */
+    }
+    return ;
+}
+
+#endif /* SMALL_DCT */
+
+void idct_rowzmv(Short *blk, UChar *rec, UChar *pred, Int lx)
+{
+    int32 x0, x1, x2, x3, x4, x5, x6, x7, x8;
+    int i = 8;
+    uint32 pred_word, dst_word;
+    int res, res2;
+
+    /* preset the offset, such that we can take advantage pre-offset addressing mode   */
+    rec -= lx;
+    pred -= 16;
+    blk -= 8;
+
+    while (i--)
+    {
+        x1 = (int32)blk[12] << 8;
+        blk[12] = 0;
+        x2 = blk[14];
+        blk[14] = 0;
+        x3 = blk[10];
+        blk[10] = 0;
+        x4 = blk[9];
+        blk[9] = 0;
+        x5 = blk[15];
+        blk[15] = 0;
+        x6 = blk[13];
+        blk[13] = 0;
+        x7 = blk[11];
+        blk[11] = 0;
+        x0 = ((*(blk += 8)) << 8) + 8192;
+        *blk = 0;   /* for proper rounding in the fourth stage */
+
+        /* first stage */
+        x8 = W7 * (x4 + x5) + 4;
+        x4 = (x8 + (W1 - W7) * x4) >> 3;
+        x5 = (x8 - (W1 + W7) * x5) >> 3;
+        x8 = W3 * (x6 + x7) + 4;
+        x6 = (x8 - (W3 - W5) * x6) >> 3;
+        x7 = (x8 - (W3 + W5) * x7) >> 3;
+
+        /* second stage */
+        x8 = x0 + x1;
+        x0 -= x1;
+        x1 = W6 * (x3 + x2) + 4;
+        x2 = (x1 - (W2 + W6) * x2) >> 3;
+        x3 = (x1 + (W2 - W6) * x3) >> 3;
+        x1 = x4 + x6;
+        x4 -= x6;
+        x6 = x5 + x7;
+        x5 -= x7;
+
+        /* third stage */
+        x7 = x8 + x3;
+        x8 -= x3;
+        x3 = x0 + x2;
+        x0 -= x2;
+        x2 = (181 * (x4 + x5) + 128) >> 8;
+        x4 = (181 * (x4 - x5) + 128) >> 8;
+
+        /* fourth stage */
+        pred_word = *((uint32*)(pred += 16)); /* read 4 bytes from pred */
+
+        res = (x7 + x1) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (x3 + x2) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (x0 + x4) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (x8 + x6) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)(rec += lx)) = dst_word; /* save 4 bytes to dst */
+
+        pred_word = *((uint32*)(pred + 4)); /* read 4 bytes from pred */
+
+        res = (x8 - x6) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (x0 - x4) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (x3 - x2) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (x7 - x1) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)(rec + 4)) = dst_word; /* save 4 bytes to dst */
+    }
+    return;
+}
+
+/*----------------------------------------------------------------------------
+;  End Function: idctcol
+----------------------------------------------------------------------------*/
+/* ======================================================================== */
+/*  Function : BlockIDCTMotionComp                                              */
+/*  Date     : 10/16/2000                                                   */
+/*  Purpose  : fast IDCT routine                                    */
+/*  In/out   :                                                              */
+/*      Int* coeff_in   Dequantized coefficient
+        Int block_out   output IDCT coefficient
+        Int maxval      clip value                                          */
+/*  Modified :   7/31/01, add checking for all-zero and DC-only block.  */
+/*              do 8 columns at a time                                      */
+/*               8/2/01, do column first then row-IDCT.                 */
+/*               8/2/01, remove clipping (included in motion comp).     */
+/*               8/7/01, combine with motion comp.                      */
+/*               8/8/01, use AAN IDCT                                       */
+/*               9/4/05, use Chen's IDCT and 16 bit block                   */
+/* ======================================================================== */
+void BlockIDCTMotionComp(Short *block, UChar *bitmapcol, UChar bitmaprow,
+                         Int dctMode, UChar *rec, UChar *pred, Int lx_intra)
+{
+    Int i;
+    Int tmp, tmp2;
+    ULong tmp4;
+    Int bmap;
+    Short *ptr = block;
+    UChar *endcol;
+    UInt mask = 0xFF;
+    Int lx = lx_intra >> 1;
+    Int intra = (lx_intra & 1);
+
+    /*  all-zero block */
+    if (dctMode == 0 || bitmaprow == 0)
+    {
+        if (intra)
+        {
+            *((ULong*)rec) = *((ULong*)(rec + 4)) = 0;
+            *((ULong*)(rec += lx)) = 0;
+            *((ULong*)(rec + 4)) = 0;
+            *((ULong*)(rec += lx)) = 0;
+            *((ULong*)(rec + 4)) = 0;
+            *((ULong*)(rec += lx)) = 0;
+            *((ULong*)(rec + 4)) = 0;
+            *((ULong*)(rec += lx)) = 0;
+            *((ULong*)(rec + 4)) = 0;
+            *((ULong*)(rec += lx)) = 0;
+            *((ULong*)(rec + 4)) = 0;
+            *((ULong*)(rec += lx)) = 0;
+            *((ULong*)(rec + 4)) = 0;
+            *((ULong*)(rec += lx)) = 0;
+            *((ULong*)(rec + 4)) = 0;
+            return ;
+        }
+        else /* copy from previous frame */
+        {
+            *((ULong*)rec) = *((ULong*)pred);
+            *((ULong*)(rec + 4)) = *((ULong*)(pred + 4));
+            *((ULong*)(rec += lx)) = *((ULong*)(pred += 16));
+            *((ULong*)(rec + 4)) = *((ULong*)(pred + 4));
+            *((ULong*)(rec += lx)) = *((ULong*)(pred += 16));
+            *((ULong*)(rec + 4)) = *((ULong*)(pred + 4));
+            *((ULong*)(rec += lx)) = *((ULong*)(pred += 16));
+            *((ULong*)(rec + 4)) = *((ULong*)(pred + 4));
+            *((ULong*)(rec += lx)) = *((ULong*)(pred += 16));
+            *((ULong*)(rec + 4)) = *((ULong*)(pred + 4));
+            *((ULong*)(rec += lx)) = *((ULong*)(pred += 16));
+            *((ULong*)(rec + 4)) = *((ULong*)(pred + 4));
+            *((ULong*)(rec += lx)) = *((ULong*)(pred += 16));
+            *((ULong*)(rec + 4)) = *((ULong*)(pred + 4));
+            *((ULong*)(rec += lx)) = *((ULong*)(pred += 16));
+            *((ULong*)(rec + 4)) = *((ULong*)(pred + 4));
+            return ;
+        }
+    }
+
+    /* Test for DC only block */
+    if (dctMode == 1 || (bitmaprow == 0x80 && bitmapcol[0] == 0x80))
+    {
+        i = ((block[0] << 3) + 32) >> 6;
+        block[0] = 0;
+        if (intra)
+        {
+            if ((UInt)i > mask) i = mask & (~(i >> 31));
+
+            tmp = i | (i << 8);
+            tmp |= (tmp << 16);
+
+            *((ULong*)rec) = *((ULong*)(rec + 4)) = tmp;
+            *((ULong*)(rec += lx)) = tmp;
+            *((ULong*)(rec + 4)) = tmp;
+            *((ULong*)(rec += lx)) = tmp;
+            *((ULong*)(rec + 4)) = tmp;
+            *((ULong*)(rec += lx)) = tmp;
+            *((ULong*)(rec + 4)) = tmp;
+            *((ULong*)(rec += lx)) = tmp;
+            *((ULong*)(rec + 4)) = tmp;
+            *((ULong*)(rec += lx)) = tmp;
+            *((ULong*)(rec + 4)) = tmp;
+            *((ULong*)(rec += lx)) = tmp;
+            *((ULong*)(rec + 4)) = tmp;
+            *((ULong*)(rec += lx)) = tmp;
+            *((ULong*)(rec + 4)) = tmp;
+
+            return ;
+        }
+        else
+        {
+            endcol = rec + (lx << 3);
+            do
+            {
+                tmp4 = *((ULong*)pred);
+                tmp2 = tmp4 & 0xFF;
+                tmp2 += i;
+                if ((UInt)tmp2 > mask) tmp2 = mask & (~(tmp2 >> 31));
+                tmp = (tmp4 >> 8) & 0xFF;
+                tmp += i;
+                if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
+                tmp2 |= (tmp << 8);
+                tmp = (tmp4 >> 16) & 0xFF;
+                tmp += i;
+                if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
+                tmp2 |= (tmp << 16);
+                tmp = (tmp4 >> 24) & 0xFF;
+                tmp += i;
+                if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
+                tmp2 |= (tmp << 24);
+                *((ULong*)rec) = tmp2;
+
+                tmp4 = *((ULong*)(pred + 4));
+                tmp2 = tmp4 & 0xFF;
+                tmp2 += i;
+                if ((UInt)tmp2 > mask) tmp2 = mask & (~(tmp2 >> 31));
+                tmp = (tmp4 >> 8) & 0xFF;
+                tmp += i;
+                if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
+                tmp2 |= (tmp << 8);
+                tmp = (tmp4 >> 16) & 0xFF;
+                tmp += i;
+                if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
+                tmp2 |= (tmp << 16);
+                tmp = (tmp4 >> 24) & 0xFF;
+                tmp += i;
+                if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
+                tmp2 |= (tmp << 24);
+                *((ULong*)(rec + 4)) = tmp2;
+
+                rec += lx;
+                pred += 16;
+            }
+            while (rec < endcol);
+            return ;
+        }
+    }
+
+    for (i = 0; i < dctMode; i++)
+    {
+        bmap = (Int)bitmapcol[i];
+        if (bmap)
+        {
+            if ((bmap&0xf) == 0)
+                (*(idctcolVCA[bmap>>4]))(ptr);
+            else
+                idct_col(ptr);
+        }
+        ptr++;
+    }
+
+    if ((bitmaprow&0xf) == 0)
+    {
+        if (intra)
+            (*(idctrowVCAIntra[(Int)(bitmaprow>>4)]))(block, rec, lx);
+        else
+            (*(idctrowVCAzmv[(Int)(bitmaprow>>4)]))(block, rec, pred, lx);
+    }
+    else
+    {
+        if (intra)
+            idct_rowIntra(block, rec, lx);
+        else
+            idct_rowzmv(block, rec, pred, lx);
+    }
+}
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/fastquant.cpp b/media/libstagefright/codecs/m4v_h263/enc/src/fastquant.cpp
new file mode 100644
index 0000000..466ce47
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/fastquant.cpp
@@ -0,0 +1,967 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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 "mp4enc_lib.h"
+#include "fastquant_inline.h"
+
+#define siz 63
+#define LSL 18
+
+
+const static UChar imask[8] = {128, 64, 32, 16, 8, 4, 2, 1};
+#define SIGN0(a)        ( ((a)<0) ? -1 : (((a)>0) ? 1  : 0) )
+
+/* variable bit precision quantization scale */
+/* used to avoid using 32-bit multiplication */
+const static Short scaleArrayV[32] = {0, 16384, 8192, 5462,  /* 15 */
+                                      4096, 3277, 2731, 2341,
+                                      4096, 3641, 3277, 2979,  /* 16 */
+                                      2731, 2521, 2341, 2185,
+                                      4096, 3856, 3641, 3450,  /* 17 */
+                                      3277, 3121, 2979, 2850,
+                                      5462, 5243, 5042, 4855,  /* 18 */
+                                      4682, 4520, 4370, 4229
+                                     };
+
+/* scale for dc_scaler and qmat, note, no value smaller than 8 */
+const static Short scaleArrayV2[47] = {0, 0, 0, 0, 0, 0, 0, 0, /* 15 */
+                                       4096, 3641, 3277, 2979, 2731, 2521, 2341, 2185,
+                                       4096, 3856, 3641, 3450, 3277, 3121, 2979, 2850,  /* 16 */
+                                       2731, 2622, 2521, 2428, 2341, 2260, 2185, 2115,
+                                       4096, 3972, 3856, 3745, 3641, 3543, 3450, 3361,  /* 17 */
+                                       3277, 3197, 3121, 3049, 2979, 2913, 2850
+                                      };
+
+/* AAN scale and zigzag */
+const static Short AANScale[64] =
+{
+    /* 0 */ 0x1000, 0x0B89, 0x0C3E, 0x0D9B, 0x1000, 0x0A2E, 0x0EC8, 0x0E7F,
+    /* 1 */ 0x0B89, 0x0851, 0x08D4, 0x09CF, 0x0B89, 0x0757, 0x0AA8, 0x0A73,
+    /* 2 */ 0x0C3E, 0x08D4, 0x095F, 0x0A6A, 0x0C3E, 0x07CB, 0x0B50, 0x0B18,
+    /* 3 */ 0x0D9B, 0x09CF, 0x0A6A, 0x0B92, 0x0D9B, 0x08A8, 0x0C92, 0x0C54,
+    /* 4 */ 0x1000, 0x0B89, 0x0C3E, 0x0D9B, 0x1000, 0x0A2E, 0x0EC8, 0x0E7F,
+    /* 5 */ 0x0A2E, 0x0757, 0x07CB, 0x08A8, 0x0A2E, 0x067A, 0x0968, 0x0939,
+    /* 6 */ 0x0EC8, 0x0AA8, 0x0B50, 0x0C92, 0x0EC8, 0x0968, 0x0DA8, 0x0D64,
+    /* 7 */ 0x0E7F, 0x0A73, 0x0B18, 0x0C54, 0x0E7F, 0x0939, 0x0D64, 0x0D23
+};
+
+const static UShort ZZTab[64] =
+{
+    /* 0 */ 0x0, 0x2, 0xA, 0xC, 0x1C, 0x1E, 0x36, 0x38,
+    /* 1 */ 0x4, 0x8, 0xE, 0x1A, 0x20, 0x34, 0x3A, 0x54,
+    /* 2 */ 0x6, 0x10, 0x18, 0x22, 0x32, 0x3C, 0x52, 0x56,
+    /* 3 */ 0x12, 0x16, 0x24, 0x30, 0x3E, 0x50, 0x58, 0x6A,
+    /* 4 */ 0x14, 0x26, 0x2E, 0x40, 0x4E, 0x5A, 0x68, 0x6C,
+    /* 5 */ 0x28, 0x2C, 0x42, 0x4C, 0x5C, 0x66, 0x6E, 0x78,
+    /* 6 */ 0x2A, 0x44, 0x4A, 0x5E, 0x64, 0x70, 0x76, 0x7A,
+    /* 7 */ 0x46, 0x48, 0x60, 0x62, 0x72, 0x74, 0x7C, 0x7E
+};
+
+
+//Tao need to remove, write another version of abs
+//#include <math.h>
+
+/* ======================================================================== */
+/*  Function : cal_dc_scalerENC                                             */
+/*  Date     : 01/25/2000                                                   */
+/*  Purpose  : calculation of DC quantization scale according to the
+               incoming Q and type;                                         */
+/*  In/out   :                                                              */
+/*      Int Qp      Quantizer                                               */
+/*  Return   :                                                              */
+/*          DC Scaler                                                       */
+/*  Modified :                                                              */
+/* ======================================================================== */
+/* ======================================================================== */
+Int cal_dc_scalerENC(Int QP, Int type)
+{
+
+    Int dc_scaler;
+    if (type == 1)
+    {
+        if (QP > 0 && QP < 5)
+            dc_scaler = 8;
+        else if (QP > 4 && QP < 9)
+            dc_scaler = 2 * QP;
+        else if (QP > 8 && QP < 25)
+            dc_scaler = QP + 8;
+        else
+            dc_scaler = 2 * QP - 16;
+    }
+    else
+    {
+        if (QP > 0 && QP < 5)
+            dc_scaler = 8;
+        else if (QP > 4 && QP < 25)
+            dc_scaler = (QP + 13) / 2;
+        else
+            dc_scaler = QP - 6;
+    }
+    return dc_scaler;
+}
+
+
+/***********************************************************************
+ Function: BlckQuantDequantH263
+ Date:     June 15, 1999
+ Purpose:  Combine BlockQuantH263 and BlockDequantH263ENC
+ Input:   coeff=> DCT coefficient
+ Output:  qcoeff=> quantized coefficient
+          rcoeff=> reconstructed coefficient
+          return CBP for this block
+          4/2/01,  correct dc_scaler for short_header mode.
+          5/14/01,
+          changed the division into LUT multiplication/shift and other
+          modifications to speed up fastQuant/DeQuant (check for zero 1st, rowq LUT,
+          fast bitmaprow mask and borrowed Addition method instead of ifs from , ).
+          6/25/01,
+          Further optimization (~100K/QCIF), need more testing/comment before integration.
+
+          7/4/01,  break up Inter / Intra function and merge for different cases.
+          7/22/01,  combine AAN scaling here and reordering.
+          7/24/01, , reorder already done in FDCT, the input here is in the next block and
+            it's the
+            transpose of the raster scan. Output the same order (for proof of concenpt).
+          8/1/01, , change FDCT to do row/column FDCT without reordering, input is still
+            in the next block. The reconstructed DCT output is current block in normal
+            order. The quantized output is in zigzag scan order for INTER, row/column for
+            INTRA. Use bitmapzz for zigzag RunLevel for INTER.  The quantization is done
+            in column/row scanning order.
+          8/2/01, , change IDCT to do column/row, change bitmaprow/col to the opposite.
+          8/3/01, , add clipping to the reconstructed coefficient [-2047,2047]
+          9/4/05, , removed scaling for AAN IDCT, use Chen IDCT instead.
+ ********************************************************************/
+
+Int BlockQuantDequantH263Inter(Short *rcoeff, Short *qcoeff, struct QPstruct *QuantParam,
+                               UChar bitmapcol[ ], UChar *bitmaprow, UInt *bitmapzz,
+                               Int dctMode, Int comp, Int dummy, UChar shortHeader)
+{
+    Int i, zz;
+    Int tmp, coeff, q_value;
+    Int QPdiv2 = QuantParam->QPdiv2;
+    Int QPx2 = QuantParam->QPx2;
+    Int Addition = QuantParam->Addition;
+    Int QPx2plus = QuantParam->QPx2plus;
+    Int round = 1 << 15;
+    Int q_scale = scaleArrayV[QuantParam->QP];
+    Int shift = 15 + (QPx2 >> 4);
+    Int *temp;
+    UChar *bcolptr = bitmapcol;
+    Int ac_clip;    /* quantized coeff bound */
+
+    OSCL_UNUSED_ARG(comp);
+    OSCL_UNUSED_ARG(dummy);
+
+
+    if (shortHeader) ac_clip = 126; /* clip between [-127,126] (standard allows 127!) */
+    else ac_clip = 2047;  /* clip between [-2048,2047] */
+
+    /* reset all bitmap to zero */
+    temp = (Int*) bitmapcol;
+    temp[0] = temp[1] = 0;
+    bitmapzz[0] = bitmapzz[1] = 0;
+    *bitmaprow = 0;
+    QPx2plus <<= 4;
+    QPx2plus -= 8;
+
+    rcoeff += 64; /* actual data is 64 item ahead */
+    //end  = rcoeff + dctMode - 1;
+    //rcoeff--;
+    bcolptr--;
+    i = 0;
+
+    do
+    {
+        bcolptr++;
+        //rcoeff++;
+        //i=0;
+        coeff = rcoeff[i];
+        if (coeff == 0x7fff) /* all zero column */
+        {
+            i++;
+            continue;
+        }
+
+        do
+        {
+            if (coeff >= -QPx2plus && coeff < QPx2plus)  /* quantize to zero */
+            {
+                i += 8;
+                if (i < (dctMode << 3))
+                {
+                    coeff = rcoeff[i];
+                    if (coeff > -QPx2plus && coeff < QPx2plus)  /* quantize to zero */
+                    {
+                        i += 8;
+                        coeff = rcoeff[i];
+                        continue;
+                    }
+                    else
+                        goto NONZERO1;
+                }
+            }
+            else
+            {
+NONZERO1:
+                /* scaling */
+                q_value = AANScale[i];  /* load scale AAN */
+                zz = ZZTab[i];  /* zigzag order */
+
+                coeff = aan_scale(q_value, coeff, round, QPdiv2);
+                q_value = coeff_quant(coeff, q_scale, shift);
+
+                /* dequantization  */
+                if (q_value)
+                {
+
+                    //coeff = PV_MIN(ac_clip,PV_MAX(-ac_clip-1, q_value));
+                    q_value = coeff_clip(q_value, ac_clip);
+                    qcoeff[zz>>1] = q_value;
+
+                    // dequant and clip
+                    //coeff = PV_MIN(2047,PV_MAX(-2048, q_value));
+                    tmp = 2047;
+                    coeff = coeff_dequant(q_value, QPx2, Addition, tmp);
+                    rcoeff[i-64] = coeff;
+
+                    (*bcolptr) |= imask[i>>3];
+                    if ((zz >> 1) > 31) bitmapzz[1] |= (1 << (63 - (zz >> 1)));
+                    else        bitmapzz[0] |= (1 << (31 - (zz >> 1)));
+                }
+                i += 8;
+                coeff = rcoeff[i];
+            }
+        }
+        while (i < (dctMode << 3));
+
+        i += (1 - (dctMode << 3));
+    }
+    while (i < dctMode) ;
+
+    i = dctMode;
+    tmp = 1 << (8 - i);
+    while (i--)
+    {
+        if (bitmapcol[i])(*bitmaprow) |= tmp;
+        tmp <<= 1;
+    }
+
+    if (*bitmaprow)
+        return 1;
+    else
+        return 0;
+}
+
+Int BlockQuantDequantH263Intra(Short *rcoeff, Short *qcoeff, struct QPstruct *QuantParam,
+                               UChar bitmapcol[ ], UChar *bitmaprow, UInt *bitmapzz,
+                               Int dctMode, Int comp, Int dc_scaler, UChar shortHeader)
+{
+    Int i;
+    Int tmp, coeff, q_value;
+    Int QPx2 = QuantParam->QPx2;
+    Int Addition = QuantParam->Addition;
+    Int QPx2plus = QuantParam->QPx2plus;
+    Int round = 1 << 15;
+    Int q_scale = scaleArrayV[QuantParam->QP];
+    Int shift = 15 + (QPx2 >> 4);
+    UChar *bmcolptr = bitmapcol;
+    Int ac_clip;    /* quantized coeff bound */
+
+    OSCL_UNUSED_ARG(bitmapzz);
+    OSCL_UNUSED_ARG(comp);
+
+
+    if (shortHeader) ac_clip = 126; /* clip between [-127,126] (standard allows 127!) */
+    else ac_clip = 2047;  /* clip between [-2048,2047] */
+
+    *((Int*)bitmapcol) = *((Int*)(bitmapcol + 4)) = 0;
+    *bitmaprow = 0;
+
+    QPx2plus = QPx2 << 4;
+    QPx2plus -= 8;
+
+    rcoeff += 64; /* actual data is 64 element ahead */
+    i = 0;
+
+    /* DC value */
+    coeff = *rcoeff;
+    /* scaling */
+    if (coeff == 0x7fff && !shortHeader) /* all zero column */
+    {
+        bmcolptr++;
+        i++;
+    }
+    else
+    {
+        if (coeff == 0x7fff) /* shortHeader on */
+        {
+            coeff = 1; /* can't be zero */
+            qcoeff[0] = coeff;
+            coeff = coeff * dc_scaler;
+            coeff = PV_MAX(-2048, PV_MIN(2047, coeff));
+            rcoeff[-64] = coeff;
+            bitmapcol[0] |= 128;
+            bmcolptr++;
+            //qcoeff++;
+            //rcoeff++;
+            //i=0;
+            i++;
+        }
+        else
+        {
+            q_value = round + (coeff << 12);
+            coeff = q_value >> 16;
+            if (coeff >= 0) coeff += (dc_scaler >> 1) ;
+            else            coeff -= (dc_scaler >> 1) ;
+            q_value = scaleArrayV2[dc_scaler];
+            coeff = coeff * q_value;
+            coeff >>= (15 + (dc_scaler >> 4));
+            coeff += ((UInt)coeff >> 31);
+
+            if (shortHeader)
+                coeff = PV_MAX(1, PV_MIN(254, coeff));
+
+            if (coeff)
+            {
+                qcoeff[0] = coeff;
+                coeff = coeff * dc_scaler;
+                coeff = PV_MAX(-2048, PV_MIN(2047, coeff));
+                rcoeff[-64] = coeff;
+                bitmapcol[0] |= 128;
+            }
+            i += 8;
+        }
+    }
+    /* AC values */
+    do
+    {
+        coeff = rcoeff[i];
+        if (coeff == 0x7fff) /* all zero row */
+        {
+            bmcolptr++;
+            i++;
+            continue;
+        }
+        do
+        {
+            if (coeff >= -QPx2plus && coeff < QPx2plus)  /* quantize to zero */
+            {
+                i += 8;
+                if (i < dctMode << 3)
+                {
+                    coeff = rcoeff[i];
+                    if (coeff > -QPx2plus && coeff < QPx2plus)  /* quantize to zero */
+                    {
+                        i += 8;
+                        coeff = rcoeff[i];
+                        continue;
+                    }
+                    else
+                        goto NONZERO2;
+                }
+            }
+            else
+            {
+NONZERO2:   /* scaling */
+                q_value = AANScale[i]; /*  09/02/05 */
+
+                /* scale aan */
+                q_value = smlabb(q_value, coeff, round);
+                coeff = q_value >> 16;
+                /* quant */
+                q_value = smulbb(q_scale, coeff); /*mov     q_value, coeff, lsl #14 */
+                /*smull tmp, coeff, q_value, q_scale*/
+                q_value >>= shift;
+                q_value += ((UInt)q_value >> 31); /* add 1 if negative */
+
+                if (q_value)
+                {
+                    //coeff = PV_MIN(ac_clip,PV_MAX(-ac_clip-1, q_value));
+                    q_value = coeff_clip(q_value, ac_clip);
+                    qcoeff[i] = q_value;
+
+                    // dequant and clip
+                    //coeff = PV_MIN(2047,PV_MAX(-2048, q_value));
+                    tmp = 2047;
+                    coeff = coeff_dequant(q_value, QPx2, Addition, tmp);
+                    rcoeff[i-64] = coeff;
+
+                    (*bmcolptr) |= imask[i>>3];
+                }
+                i += 8;
+                coeff = rcoeff[i];
+            }
+        }
+        while (i < (dctMode << 3)) ;
+
+        //qcoeff++; /* next column */
+        bmcolptr++;
+        //rcoeff++;
+        i += (1 - (dctMode << 3)); //i = 0;
+    }
+    while (i < dctMode);//while(rcoeff < end) ;
+
+    i = dctMode;
+    tmp = 1 << (8 - i);
+    while (i--)
+    {
+        if (bitmapcol[i])(*bitmaprow) |= tmp;
+        tmp <<= 1;
+    }
+
+    if (((*bitmaprow)&127) || (bitmapcol[0]&127)) /* exclude DC */
+        return 1;
+    else
+        return 0;
+}
+
+
+/***********************************************************************
+ Function: BlckQuantDequantH263DC
+ Date:     5/3/2001
+ Purpose:   H.263 quantization mode, only for DC component
+ 6/25/01,
+          Further optimization (~100K/QCIF), need more testing/comment before integration.
+
+ ********************************************************************/
+Int BlockQuantDequantH263DCInter(Short *rcoeff, Short *qcoeff, struct QPstruct *QuantParam,
+                                 UChar *bitmaprow, UInt *bitmapzz, Int dummy, UChar shortHeader)
+{
+    Int coeff, scale_q;
+    Int CBP = 0;
+    Int QP = QuantParam->QP;
+    Int QPx2plus = QuantParam->QPx2plus;
+    Int Addition = QuantParam->Addition;
+    Int shift = 15 + (QP >> 3);
+    Int ac_clip;    /* quantized coeff bound */
+    Int tmp;
+
+    OSCL_UNUSED_ARG(dummy);
+
+    if (shortHeader) ac_clip = 126; /* clip between [-127,126] (standard allows 127!) */
+    else ac_clip = 2047;  /* clip between [-2048,2047] */
+
+    *bitmaprow = 0;
+    bitmapzz[0] = bitmapzz[1] = 0;
+    coeff = rcoeff[0];
+
+    if (coeff >= -QPx2plus && coeff < QPx2plus)
+    {
+        rcoeff[0] = 0;
+        return CBP;//rcoeff[0] = 0; not needed since CBP will be zero
+    }
+    else
+    {
+        scale_q = scaleArrayV[QP];
+
+        coeff = aan_dc_scale(coeff, QP);
+
+        scale_q = coeff_quant(coeff, scale_q, shift);
+
+        //coeff = PV_MIN(ac_clip,PV_MAX(-ac_clip-1, tmp));
+        scale_q = coeff_clip(scale_q, ac_clip);
+
+        qcoeff[0] = scale_q;
+
+        QP <<= 1;
+        //coeff = PV_MIN(2047,PV_MAX(-2048, tmp));
+        tmp = 2047;
+        coeff = coeff_dequant(scale_q, QP, Addition, tmp);
+
+        rcoeff[0] = coeff;
+
+        (*bitmaprow) = 128;
+        bitmapzz[0] = (ULong)1 << 31;
+        CBP = 1;
+    }
+    return CBP;
+}
+
+
+Int BlockQuantDequantH263DCIntra(Short *rcoeff, Short *qcoeff, struct QPstruct *QuantParam,
+                                 UChar *bitmaprow, UInt *bitmapzz, Int dc_scaler, UChar shortHeader)
+{
+    Int tmp, coeff;
+
+    OSCL_UNUSED_ARG(QuantParam);
+
+    *bitmaprow = 0;
+    coeff = rcoeff[0];
+
+    if (coeff >= 0) coeff += (dc_scaler >> 1) ;
+    else            coeff -= (dc_scaler >> 1) ;
+    tmp = scaleArrayV2[dc_scaler];
+    tmp = coeff * tmp;
+    tmp >>= (15 + (dc_scaler >> 4));
+    tmp += ((UInt)tmp >> 31);
+
+    if (shortHeader)
+        tmp = PV_MAX(1, PV_MIN(254, tmp));
+
+    if (tmp)
+    {
+        qcoeff[0] = tmp;
+        coeff = tmp * dc_scaler;
+        coeff = PV_MAX(-2048, PV_MIN(2047, coeff));
+        rcoeff[0] = coeff;
+        *bitmaprow = 128;
+        bitmapzz[0] = (ULong)1 << 31;
+    }
+
+    return 0;
+}
+
+#ifndef NO_MPEG_QUANT
+/***********************************************************************
+ Function: BlckQuantDequantMPEG
+ Date:     June 15, 1999
+ Purpose:  Combine BlockQuantMPEG and BlockDequantMPEGENC
+ Input:   coeff=> DCT coefficient
+ Output:  qcoeff=> quantized coefficient
+          rcoeff=> reconstructed coefficient
+ Modified:  7/5/01, break up function for Intra/Inter
+          8/3/01,  update with changes from H263 quant mode.
+          8/3/01,  add clipping to the reconstructed coefficient [-2048,2047]
+          8/6/01,  optimize using multiplicative lookup-table.
+                     can be further optimized using ARM assembly, e.g.,
+                     clipping, 16-bit mult., etc !!!!!!!!!!!!!
+ ********************************************************************/
+
+Int BlockQuantDequantMPEGInter(Short *rcoeff, Short *qcoeff, Int QP, Int *qmat,
+                               UChar bitmapcol[ ], UChar *bitmaprow, UInt *bitmapzz,
+                               Int dctMode, Int comp, Int dc_scaler)
+{
+    Int i, zz;
+    Int tmp, coeff, q_value = 0;
+    Int sum = 0;
+    Int stepsize, QPx2 = QP << 1;
+    Int CBP = 0;
+    Int round = 1 << 15;
+    Int q_scale = scaleArrayV[QP];
+    Int shift = 15 + (QP >> 3);
+    UChar *bcolptr = bitmapcol;
+
+    OSCL_UNUSED_ARG(dc_scaler);
+    OSCL_UNUSED_ARG(comp);
+
+
+    *((Int*)bitmapcol) = *((Int*)(bitmapcol + 4)) = 0;
+    bitmapzz[0] = bitmapzz[1] = 0;
+    *bitmaprow = 0;
+
+    rcoeff += 64;
+    i = 0;
+    bcolptr--;
+
+    do
+    {
+        bcolptr++;
+        coeff = rcoeff[i];
+        if (coeff == 0x7fff) /* all zero column */
+        {
+            i++;
+            continue;
+        }
+        do
+        {
+            q_value = AANScale[i];  /*  09/02/05 scaling for AAN*/
+            /* aan scaling */
+            q_value = smlabb(q_value, coeff, round);
+
+            coeff = q_value >> 16;
+
+            stepsize = qmat[i];
+//          if(coeff>0)     coeff = (16*coeff + (stepsize/2)) / stepsize;
+//          else            coeff = (16*coeff - (stepsize/2)) / stepsize;
+            coeff <<= 4;
+            if (coeff >= 0) coeff += (stepsize >> 1) ;
+            else            coeff -= (stepsize >> 1) ;
+            q_value = scaleArrayV2[stepsize];
+            /* mpeg quant table scale */
+            coeff = smulbb(coeff, q_value);
+
+            coeff >>= (15 + (stepsize >> 4));
+            coeff += ((UInt)coeff >> 31);
+
+            /* QP scale */
+            if (coeff >= -QPx2 && coeff < QPx2)  /* quantized to zero*/
+            {
+                i += 8;
+            }
+            else
+            {
+//              q_value = coeff/(QPx2);
+                q_value = coeff_quant(coeff, q_scale, shift);
+
+                if (q_value)                /* dequant */
+                {
+
+                    zz = ZZTab[i];  /* zigzag order */
+
+                    tmp = 2047;
+
+                    q_value = clip_2047(q_value, tmp);
+
+                    qcoeff[zz>>1] = q_value;
+
+                    //q_value=(((coeff*2)+SIGN0(coeff))*stepsize*QP)/16;
+                    /* no need for SIGN0, no zero coming in this {} */
+                    q_value = coeff_dequant_mpeg(q_value, stepsize, QP, tmp);
+
+                    rcoeff[i-64] = q_value;
+
+                    sum += q_value;
+                    (*bcolptr) |= imask[i>>3];
+                    if ((zz >> 1) > 31) bitmapzz[1] |= (1 << (63 - (zz >> 1)));
+                    else        bitmapzz[0] |= (1 << (31 - (zz >> 1)));
+                }
+                i += 8;
+            }
+            coeff = rcoeff[i];
+        }
+        while (i < (dctMode << 3)) ;
+
+        i += (1 - (dctMode << 3));
+    }
+    while (i < dctMode) ;
+
+    i = dctMode;
+    tmp = 1 << (8 - i);
+    while (i--)
+    {
+        if (bitmapcol[i])(*bitmaprow) |= tmp;
+        tmp <<= 1;
+    }
+
+    if (*bitmaprow)
+        CBP = 1;   /* check CBP before mismatch control,  7/5/01 */
+
+    /* Mismatch control,  5/3/01 */
+    if (CBP)
+    {
+        if ((sum&0x1) == 0)
+        {
+            rcoeff--;  /* rcoeff[63] */
+            coeff = *rcoeff;
+            coeff ^= 0x1;
+            *rcoeff = coeff;
+            if (coeff)
+            {
+                bitmapcol[7] |= 1;
+                (*bitmaprow) |= 1;
+            }
+        }
+    }
+
+    return CBP;
+}
+
+Int BlockQuantDequantMPEGIntra(Short *rcoeff, Short *qcoeff, Int QP, Int *qmat,
+                               UChar bitmapcol[ ], UChar *bitmaprow, UInt *bitmapzz,
+                               Int dctMode, Int comp, Int dc_scaler)
+{
+    Int i;
+    Int tmp, coeff, q_value = 0;
+    Int sum = 0;
+    Int stepsize;
+    Int CBP = 0;
+    Int round = 1 << 15;
+    Int q_scale = scaleArrayV[QP];
+    Int shift = 15 + (QP >> 3);
+    Int round2 = (3 * QP + 2) >> 2;
+    Int QPx2plus = (QP << 1) - round2;
+    UChar *bmcolptr = bitmapcol;
+
+    OSCL_UNUSED_ARG(bitmapzz);
+    OSCL_UNUSED_ARG(comp);
+
+    *((Int*)bitmapcol) = *((Int*)(bitmapcol + 4)) = 0;
+    *bitmaprow = 0;
+
+    rcoeff += 64;
+    i = 0;
+
+    /* DC value */
+    coeff = *rcoeff;
+
+    if (coeff == 0x7fff) /* all zero column */
+    {
+        bmcolptr++;
+        i++;
+    }
+    else
+    {
+        q_value = round + (coeff << 12);
+        coeff = q_value >> 16;
+        /*if (coeff >= 0)   coeff = (coeff + (dc_scaler/2)) / dc_scaler;
+        else            coeff = (coeff - (dc_scaler/2)) / dc_scaler;*/
+        if (coeff >= 0) coeff += (dc_scaler >> 1) ;
+        else            coeff -= (dc_scaler >> 1) ;
+        q_value = scaleArrayV2[dc_scaler];
+
+        /* mpeg quant table scale */
+        coeff = smulbb(coeff, q_value);
+
+        coeff >>= (15 + (dc_scaler >> 4));
+        coeff += ((UInt)coeff >> 31);
+
+        if (coeff)
+        {
+            coeff = PV_MAX(1, PV_MIN(254, coeff));
+            qcoeff[0] = coeff;
+
+            coeff = smulbb(coeff, dc_scaler);
+
+            q_value = clip_2047(coeff, 2047);
+
+            sum = q_value;
+
+            rcoeff[-64] = q_value;
+
+            bitmapcol[0] |= 128;
+        }
+        i += 8;
+    }
+    /* AC values */
+    do
+    {
+        coeff = rcoeff[i];
+        if (coeff == 0x7fff) /* all zero row */
+        {
+            bmcolptr++;
+            i++;
+            continue;
+        }
+        do
+        {
+            /* scaling */
+            q_value = AANScale[i]; /*  09/02/05 */
+
+            /* q_value = coeff*q_value + round */
+            q_value = smlabb(coeff, q_value, round);
+            coeff = q_value >> 16;
+
+            stepsize = qmat[i];
+            /*if(coeff>0)       coeff = (16*coeff + (stepsize/2)) / stepsize;
+            else            coeff = (16*coeff - (stepsize/2)) / stepsize;*/
+            coeff <<= 4;
+            if (coeff >= 0) coeff += (stepsize >> 1) ;
+            else            coeff -= (stepsize >> 1) ;
+            q_value = scaleArrayV2[stepsize];
+
+            /* scale mpeg quant */
+            coeff = smulbb(coeff, q_value);
+
+            coeff >>= (15 + (stepsize >> 4));
+            coeff += ((UInt)coeff >> 31);
+
+            if (coeff >= -QPx2plus && coeff < QPx2plus)
+            {
+                i += 8;
+            }
+            else
+            {
+                //q_value = ( coeff + SIGN0(coeff)*((3*QP+2)/4))/(2*QP);
+                if (coeff > 0) coeff += round2;
+                else if (coeff < 0) coeff -= round2;
+
+                q_value = smulbb(coeff, q_scale);
+                q_value >>= shift;
+                q_value += ((UInt)q_value >> 31);
+
+                if (q_value)
+                {
+                    tmp = 2047;
+                    q_value = clip_2047(q_value, tmp);
+
+                    qcoeff[i] = q_value;
+
+                    stepsize = smulbb(stepsize, QP);
+                    q_value =  smulbb(q_value, stepsize);
+
+                    q_value = coeff_dequant_mpeg_intra(q_value, tmp);
+                    //q_value = (coeff*stepsize*QP*2)/16;
+
+                    rcoeff[i-64] = q_value;
+
+                    sum += q_value;
+                    (*bmcolptr) |= imask[i>>3];
+                }
+                i += 8;
+            }
+            coeff = rcoeff[i];
+        }
+        while (i < (dctMode << 3)) ;
+
+        bmcolptr++;
+        i += (1 - (dctMode << 3));
+    }
+    while (i < dctMode) ;
+
+    i = dctMode;
+    tmp = 1 << (8 - i);
+    while (i--)
+    {
+        if (bitmapcol[i])(*bitmaprow) |= tmp;
+        tmp <<= 1;
+    }
+
+    if (((*bitmaprow) &127) || (bitmapcol[0]&127))
+        CBP = 1;  /* check CBP before mismatch control,  7/5/01 */
+
+    /* Mismatch control,  5/3/01 */
+    if (CBP || bitmapcol[0])
+    {
+        if ((sum&0x1) == 0)
+        {
+            rcoeff--;  /* rcoeff[63] */
+            coeff = *rcoeff;
+            coeff ^= 0x1;
+            *rcoeff = coeff;
+            if (coeff)
+            {
+                bitmapcol[7] |= 1;
+                (*bitmaprow) |= 1;
+            }
+        }
+    }
+
+    return CBP;
+}
+
+
+/***********************************************************************
+ Function: BlckQuantDequantMPEGDC
+ Date:     5/3/2001
+ Purpose:  MPEG Quant/Dequant for DC only block.
+ ********************************************************************/
+Int BlockQuantDequantMPEGDCInter(Short *rcoeff, Short *qcoeff, Int QP, Int *qmat,
+                                 UChar bitmapcol[ ], UChar *bitmaprow, UInt *bitmapzz, Int dummy)
+{
+    Int q_value, coeff, stepsize;
+    Int CBP = 0;
+    Int q_scale = scaleArrayV[QP];
+    Int shift = 15 + (QP >> 3);
+    Int QPx2 = QP << 1;
+
+    OSCL_UNUSED_ARG(dummy);
+
+    *((Int*)bitmapcol) = *((Int*)(bitmapcol + 4)) = 0;
+    *bitmaprow = 0;
+    bitmapzz[0] = bitmapzz[1] = 0;
+    coeff = rcoeff[0];
+    stepsize = qmat[0];
+
+    /*if(coeff>0)       coeff = (16*coeff + (stepsize/2)) / stepsize;
+    else            coeff = (16*coeff - (stepsize/2)) / stepsize;*/
+    coeff <<= 4;
+    if (coeff >= 0) coeff += (stepsize >> 1) ;
+    else            coeff -= (stepsize >> 1) ;
+    q_value = scaleArrayV2[stepsize];
+
+    coeff = smulbb(coeff, q_value);
+
+    coeff >>= (15 + (stepsize >> 4));
+    coeff += ((UInt)coeff >> 31);
+
+    if (coeff >= -QPx2 && coeff < QPx2)
+    {
+        rcoeff[0] = 0;
+        return CBP;
+    }
+    else
+    {
+//      q_value = coeff/(QPx2);
+        q_value = coeff_quant(coeff, q_scale, shift);
+
+        if (q_value)
+        {
+
+            //PV_MIN(2047,PV_MAX(-2048, q_value));
+            q_value = clip_2047(q_value, 2047);
+            qcoeff[0] = q_value;
+            q_value = coeff_dequant_mpeg(q_value, stepsize, QP, 2047);
+            //q_value=(((coeff*2)+SIGN0(coeff))*stepsize*QP)/16;
+            rcoeff[0] = q_value;
+
+            bitmapcol[0] = 128;
+            (*bitmaprow) = 128;
+            bitmapzz[0] = (UInt)1 << 31;
+            CBP = 1;
+
+            /* Mismatch control,  5/3/01 */
+            if ((q_value&0x1) == 0)
+            {
+                rcoeff[63] = 1; /* after scaling it remains the same */
+                bitmapcol[7] |= 1;
+                (*bitmaprow) |= 1;
+            }
+        }
+    }
+    return CBP;
+}
+
+
+Int BlockQuantDequantMPEGDCIntra(Short *rcoeff, Short *qcoeff, Int QP, Int *qmat,
+                                 UChar bitmapcol[ ], UChar *bitmaprow, UInt *bitmapzz,
+                                 Int dc_scaler)
+{
+    Int tmp, coeff, q_value;
+
+    OSCL_UNUSED_ARG(QP);
+    OSCL_UNUSED_ARG(qmat);
+
+
+    *((Int*)bitmapcol) = *((Int*)(bitmapcol + 4)) = 0;
+    *bitmaprow = 0;
+    coeff = rcoeff[0];
+
+    /*if (coeff >= 0)   tmp = (coeff + dc_scaler/2) / dc_scaler;
+    else            tmp = (coeff - dc_scaler/2) / dc_scaler;*/
+    if (coeff >= 0) coeff += (dc_scaler >> 1) ;
+    else            coeff -= (dc_scaler >> 1) ;
+    tmp = scaleArrayV2[dc_scaler];
+
+    tmp = smulbb(tmp, coeff);
+    tmp >>= (15 + (dc_scaler >> 4));
+    tmp += ((UInt)tmp >> 31);
+
+    if (tmp)
+    {
+        coeff = PV_MAX(1, PV_MIN(254, tmp));
+        qcoeff[0] = coeff;
+
+        q_value = smulbb(coeff, dc_scaler);
+        q_value = clip_2047(q_value, 2047);
+        rcoeff[0] = q_value;
+        bitmapcol[0] = 128;
+        *bitmaprow = 128;
+        bitmapzz[0] = (UInt)1 << 31;
+
+        /* Mismatch control,  5/3/01 */
+        if ((q_value&0x1) == 0)
+        {
+            rcoeff[63] = 1; /* after scaling it remains the same */
+            bitmapcol[7] |= 1;
+            (*bitmaprow) |= 1;
+        }
+    }
+
+    return 0;
+}
+#endif
+
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/fastquant_inline.h b/media/libstagefright/codecs/m4v_h263/enc/src/fastquant_inline.h
new file mode 100644
index 0000000..79d0ebf
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/fastquant_inline.h
@@ -0,0 +1,625 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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.
+ * -------------------------------------------------------------------
+ */
+/*********************************************************************************/
+/*  Filename: fastquant_inline.h                                                        */
+/*  Description: Implementation for in-line functions used in dct.cpp           */
+/*  Modified:                                                                   */
+/*********************************************************************************/
+#ifndef _FASTQUANT_INLINE_H_
+#define _FASTQUANT_INLINE_H_
+
+#include "mp4def.h"
+
+#if !defined(PV_ARM_GCC_V5) && !defined(PV_ARM_GCC_V4) /* ARM GNU COMPILER  */
+
+__inline int32 aan_scale(int32 q_value, int32 coeff, int32 round, int32 QPdiv2)
+{
+    q_value = coeff * q_value + round;
+    coeff = q_value >> 16;
+    if (coeff < 0)  coeff += QPdiv2;
+    else            coeff -= QPdiv2;
+
+    return coeff;
+}
+
+
+__inline int32 coeff_quant(int32 coeff, int32 q_scale, int32 shift)
+{
+    int32 q_value;
+
+    q_value = coeff * q_scale;      //q_value = -((-(coeff + QPdiv2)*q_scale)>>LSL);
+    q_value >>= shift;                  //q_value = (((coeff - QPdiv2)*q_scale)>>LSL );
+    q_value += ((UInt)q_value >> 31); /* add one if negative */
+
+    return q_value;
+}
+
+__inline int32  coeff_clip(int32 q_value, int32 ac_clip)
+{
+    int32 coeff = q_value + ac_clip;
+
+    if ((UInt)coeff > (UInt)(ac_clip << 1))
+        q_value = ac_clip ^(q_value >> 31);
+
+    return q_value;
+}
+
+__inline int32 coeff_dequant(int32 q_value, int32 QPx2, int32 Addition, int32 tmp)
+{
+    int32 coeff;
+
+    OSCL_UNUSED_ARG(tmp);
+
+    if (q_value < 0)
+    {
+        coeff = q_value * QPx2 - Addition;
+        if (coeff < -2048)
+            coeff = -2048;
+    }
+    else
+    {
+        coeff = q_value * QPx2 + Addition;
+        if (coeff > 2047)
+            coeff = 2047;
+    }
+    return coeff;
+}
+
+__inline int32 smlabb(int32 q_value, int32 coeff, int32 round)
+{
+    q_value = coeff * q_value + round;
+
+    return q_value;
+}
+
+__inline int32 smulbb(int32 q_scale, int32 coeff)
+{
+    int32 q_value;
+
+    q_value = coeff * q_scale;
+
+    return q_value;
+}
+
+__inline int32 aan_dc_scale(int32 coeff, int32 QP)
+{
+
+    if (coeff < 0)  coeff += (QP >> 1);
+    else            coeff -= (QP >> 1);
+
+    return coeff;
+}
+
+__inline int32 clip_2047(int32 q_value, int32 tmp)
+{
+    OSCL_UNUSED_ARG(tmp);
+
+    if (q_value < -2048)
+    {
+        q_value = -2048;
+    }
+    else if (q_value > 2047)
+    {
+        q_value = 2047;
+    }
+
+    return q_value;
+}
+
+__inline int32 coeff_dequant_mpeg(int32 q_value, int32 stepsize, int32 QP, int32 tmp)
+{
+    int32 coeff;
+
+    OSCL_UNUSED_ARG(tmp);
+
+    coeff = q_value << 1;
+    stepsize *= QP;
+    if (coeff > 0)
+    {
+        q_value = (coeff + 1) * stepsize;
+        q_value >>= 4;
+        if (q_value > 2047) q_value = 2047;
+    }
+    else
+    {
+        q_value = (coeff - 1) * stepsize;
+        q_value += 15;
+        q_value >>= 4;
+        if (q_value < -2048)    q_value = -2048;
+    }
+
+    return q_value;
+}
+
+__inline int32 coeff_dequant_mpeg_intra(int32 q_value, int32 tmp)
+{
+    OSCL_UNUSED_ARG(tmp);
+
+    q_value <<= 1;
+    if (q_value > 0)
+    {
+        q_value >>= 4;
+        if (q_value > 2047) q_value = 2047;
+    }
+    else
+    {
+        q_value += 15;
+        q_value >>= 4;
+        if (q_value < -2048) q_value = -2048;
+    }
+
+    return q_value;
+}
+
+#elif defined(__CC_ARM)  /* only work with arm v5 */
+
+#if defined(__TARGET_ARCH_5TE)
+
+__inline int32 aan_scale(int32 q_value, int32 coeff,
+                         int32 round, int32 QPdiv2)
+{
+    __asm
+    {
+        smlabb q_value, coeff, q_value, round
+        movs       coeff, q_value, asr #16
+        addle   coeff, coeff, QPdiv2
+        subgt   coeff, coeff, QPdiv2
+    }
+
+    return coeff;
+}
+
+__inline int32 coeff_quant(int32 coeff, int32 q_scale, int32 shift)
+{
+    int32 q_value;
+
+    __asm
+    {
+        smulbb  q_value, q_scale, coeff    /*mov    coeff, coeff, lsl #14*/
+        mov     coeff, q_value, asr shift   /*smull tmp, coeff, q_scale, coeff*/
+        add q_value, coeff, coeff, lsr #31
+    }
+
+
+    return q_value;
+}
+
+__inline int32 coeff_dequant(int32 q_value, int32 QPx2, int32 Addition, int32 tmp)
+{
+    int32 coeff;
+
+    __asm
+    {
+        cmp     q_value, #0
+        smulbb  coeff, q_value, QPx2
+        sublt   coeff, coeff, Addition
+        addge   coeff, coeff, Addition
+        add     q_value, coeff, tmp
+        subs    q_value, q_value, #3840
+        subcss  q_value, q_value, #254
+        eorhi   coeff, tmp, coeff, asr #31
+    }
+
+    return coeff;
+}
+
+__inline int32 smlabb(int32 q_value, int32 coeff, int32 round)
+{
+    __asm
+    {
+        smlabb q_value, coeff, q_value, round
+    }
+
+    return q_value;
+}
+
+__inline int32 smulbb(int32 q_scale, int32 coeff)
+{
+    int32 q_value;
+
+    __asm
+    {
+        smulbb  q_value, q_scale, coeff
+    }
+
+    return q_value;
+}
+
+__inline int32 coeff_dequant_mpeg(int32 q_value, int32 stepsize, int32 QP, int32 tmp)
+{
+    /* tmp must have value of 2047 */
+    int32 coeff;
+    __asm
+    {
+        movs    coeff, q_value, lsl #1
+        smulbb  stepsize, stepsize, QP
+        addgt   coeff, coeff, #1
+        sublt   coeff, coeff, #1
+        smulbb  q_value, coeff, stepsize
+        addlt   q_value, q_value, #15
+        mov     q_value, q_value, asr #4
+        add     coeff, q_value, tmp
+        subs    coeff, coeff, #0xf00
+        subcss  coeff, coeff, #0xfe
+        eorhi   q_value, tmp, q_value, asr #31
+    }
+
+    return q_value;
+}
+
+
+#else // not ARMV5TE
+
+__inline int32 aan_scale(int32 q_value, int32 coeff,
+                         int32 round, int32 QPdiv2)
+{
+    __asm
+    {
+        mla q_value, coeff, q_value, round
+        movs       coeff, q_value, asr #16
+        addle   coeff, coeff, QPdiv2
+        subgt   coeff, coeff, QPdiv2
+    }
+
+    return coeff;
+}
+
+__inline int32 coeff_quant(int32 coeff, int32 q_scale, int32 shift)
+{
+    int32 q_value;
+
+    __asm
+    {
+        mul q_value, q_scale, coeff    /*mov    coeff, coeff, lsl #14*/
+        mov     coeff, q_value, asr shift   /*smull tmp, coeff, q_scale, coeff*/
+        add q_value, coeff, coeff, lsr #31
+    }
+
+
+    return q_value;
+}
+
+
+__inline int32 coeff_dequant(int32 q_value, int32 QPx2, int32 Addition, int32 tmp)
+{
+    int32 coeff;
+
+    __asm
+    {
+        cmp     q_value, #0
+        mul coeff, q_value, QPx2
+        sublt   coeff, coeff, Addition
+        addge   coeff, coeff, Addition
+        add     q_value, coeff, tmp
+        subs    q_value, q_value, #3840
+        subcss  q_value, q_value, #254
+        eorhi   coeff, tmp, coeff, asr #31
+    }
+
+    return coeff;
+}
+
+__inline int32 smlabb(int32 q_value, int32 coeff, int32 round)
+{
+    __asm
+    {
+        mla q_value, coeff, q_value, round
+    }
+
+    return q_value;
+}
+
+__inline int32 smulbb(int32 q_scale, int32 coeff)
+{
+    int32 q_value;
+
+    __asm
+    {
+        mul q_value, q_scale, coeff
+    }
+
+    return q_value;
+}
+
+
+__inline int32 coeff_dequant_mpeg(int32 q_value, int32 stepsize, int32 QP, int32 tmp)
+{
+    /* tmp must have value of 2047 */
+    int32 coeff;
+    __asm
+    {
+        movs    coeff, q_value, lsl #1
+        mul  stepsize, stepsize, QP
+        addgt   coeff, coeff, #1
+        sublt   coeff, coeff, #1
+        mul q_value, coeff, stepsize
+        addlt   q_value, q_value, #15
+        mov     q_value, q_value, asr #4
+        add     coeff, q_value, tmp
+        subs    coeff, coeff, #0xf00
+        subcss  coeff, coeff, #0xfe
+        eorhi   q_value, tmp, q_value, asr #31
+    }
+
+    return q_value;
+}
+
+
+#endif
+
+__inline int32  coeff_clip(int32 q_value, int32 ac_clip)
+{
+    int32 coeff;
+
+    __asm
+    {
+        add     coeff, q_value, ac_clip
+        subs    coeff, coeff, ac_clip, lsl #1
+        eorhi   q_value, ac_clip, q_value, asr #31
+    }
+
+    return q_value;
+}
+
+__inline int32 aan_dc_scale(int32 coeff, int32 QP)
+{
+
+    __asm
+    {
+        cmp   coeff, #0
+        addle   coeff, coeff, QP, asr #1
+        subgt   coeff, coeff, QP, asr #1
+    }
+
+    return coeff;
+}
+
+__inline int32 clip_2047(int32 q_value, int32 tmp)
+{
+    /* tmp must have value of 2047 */
+    int32 coeff;
+
+    __asm
+    {
+        add     coeff, q_value, tmp
+        subs    coeff, coeff, #0xf00
+        subcss  coeff, coeff, #0xfe
+        eorhi   q_value, tmp, q_value, asr #31
+    }
+
+    return q_value;
+}
+
+__inline int32 coeff_dequant_mpeg_intra(int32 q_value, int32 tmp)
+{
+    int32 coeff;
+
+    __asm
+    {
+        movs    q_value, q_value, lsl #1
+        addlt   q_value, q_value, #15
+        mov     q_value, q_value, asr #4
+        add     coeff, q_value, tmp
+        subs    coeff, coeff, #0xf00
+        subcss  coeff, coeff, #0xfe
+        eorhi   q_value, tmp, q_value, asr #31
+    }
+
+    return q_value;
+}
+
+#elif ( defined(PV_ARM_GCC_V4) || defined(PV_ARM_GCC_V5) ) /* ARM GNU COMPILER  */
+
+__inline int32 aan_scale(int32 q_value, int32 coeff,
+                         int32 round, int32 QPdiv2)
+{
+    register int32 out;
+    register int32 qv = q_value;
+    register int32 cf = coeff;
+    register int32 rr = round;
+    register int32 qp = QPdiv2;
+
+    asm volatile("smlabb %0, %2, %1, %3\n\t"
+                 "movs %0, %0, asr #16\n\t"
+                 "addle %0, %0, %4\n\t"
+                 "subgt %0, %0, %4"
+             : "=&r"(out)
+                         : "r"(qv),
+                         "r"(cf),
+                         "r"(rr),
+                         "r"(qp));
+    return out;
+}
+
+__inline int32 coeff_quant(int32 coeff, int32 q_scale, int32 shift)
+{
+    register int32 out;
+    register int32 temp1;
+    register int32 cc = coeff;
+    register int32 qs = q_scale;
+    register int32 ss = shift;
+
+    asm volatile("smulbb %0, %3, %2\n\t"
+                 "mov %1, %0, asr %4\n\t"
+                 "add %0, %1, %1, lsr #31"
+             : "=&r"(out),
+                 "=&r"(temp1)
+                         : "r"(cc),
+                         "r"(qs),
+                         "r"(ss));
+
+    return out;
+}
+
+__inline int32 coeff_clip(int32 q_value, int32 ac_clip)
+{
+    register int32 coeff;
+
+    asm volatile("add   %1, %0, %2\n\t"
+                 "subs  %1, %1, %2, lsl #1\n\t"
+                 "eorhi %0, %2, %0, asr #31"
+             : "+r"(q_value),
+                 "=&r"(coeff)
+                         : "r"(ac_clip));
+
+    return q_value;
+}
+
+__inline int32 coeff_dequant(int32 q_value, int32 QPx2, int32 Addition, int32 tmp)
+{
+    register int32 out;
+    register int32 temp1;
+    register int32 qv = q_value;
+    register int32 qp = QPx2;
+    register int32 aa = Addition;
+    register int32 tt = tmp;
+
+    asm volatile("cmp    %2, #0\n\t"
+                 "mul    %0, %2, %3\n\t"
+                 "sublt  %0, %0, %4\n\t"
+                 "addge  %0, %0, %4\n\t"
+                 "add    %1, %0, %5\n\t"
+                 "subs   %1, %1, #3840\n\t"
+                 "subcss %1, %1, #254\n\t"
+                 "eorhi  %0, %5, %0, asr #31"
+             : "=&r"(out),
+                 "=&r"(temp1)
+                         : "r"(qv),
+                         "r"(qp),
+                         "r"(aa),
+                         "r"(tt));
+
+    return out;
+}
+
+__inline int32 smlabb(int32 q_value, int32 coeff, int32 round)
+{
+    register int32 out;
+    register int32 aa = (int32)q_value;
+    register int32 bb = (int32)coeff;
+    register int32 cc = (int32)round;
+
+    asm volatile("smlabb %0, %1, %2, %3"
+             : "=&r"(out)
+                         : "r"(aa),
+                         "r"(bb),
+                         "r"(cc));
+    return out;
+}
+
+__inline int32 smulbb(int32 q_scale, int32 coeff)
+{
+    register int32 out;
+    register int32 aa = (int32)q_scale;
+    register int32 bb = (int32)coeff;
+
+    asm volatile("smulbb %0, %1, %2"
+             : "=&r"(out)
+                         : "r"(aa),
+                         "r"(bb));
+    return out;
+}
+
+__inline int32 aan_dc_scale(int32 coeff, int32 QP)
+{
+    register int32 out;
+    register int32 cc = coeff;
+    register int32 qp = QP;
+
+    asm volatile("cmp %1, #0\n\t"
+                 "addle %0, %1, %2, asr #1\n\t"
+                 "subgt %0, %1, %2, asr #1"
+             : "=&r"(out)
+                         : "r"(cc),
+                         "r"(qp));
+    return out;
+}
+
+__inline int32 clip_2047(int32 q_value, int32 tmp)
+{
+    register int32 coeff;
+    asm volatile("add    %1, %0, %2\n\t"
+                 "subs   %1, %1, #0xF00\n\t"
+                 "subcss %1, %1, #0xFE\n\t"
+                 "eorhi  %0, %2, %0, asr #31"
+             : "+r"(q_value),
+                 "=&r"(coeff)
+                         : "r"(tmp));
+
+    return q_value;
+}
+
+__inline int32 coeff_dequant_mpeg(int32 q_value, int32 stepsize, int32 QP, int32 tmp)
+{
+    register int32 out;
+    register int32 temp1;
+    register int32 qv = q_value;
+    register int32 ss = stepsize;
+    register int32 qp = QP;
+    register int32 tt = tmp;
+
+    asm volatile("movs    %1, %2, lsl #1\n\t"
+                 "mul     %0, %3, %4\n\t"
+                 "addgt   %1, %1, #1\n\t"
+                 "sublt   %1, %1, #1\n\t"
+                 "mul     %0, %1, %0\n\t"
+                 "addlt   %0, %0, #15\n\t"
+                 "mov     %0, %0, asr #4\n\t"
+                 "add     %1, %0, %5\n\t"
+                 "subs    %1, %1, #0xF00\n\t"
+                 "subcss  %1, %1, #0xFE\n\t"
+                 "eorhi   %0, %5, %0, asr #31"
+             : "=&r"(out),
+                 "=&r"(temp1)
+                         : "r"(qv),
+                         "r"(ss),
+                         "r"(qp),
+                         "r"(tt));
+
+    return out;
+
+}
+
+__inline int32 coeff_dequant_mpeg_intra(int32 q_value, int32 tmp)
+{
+    register int32 out;
+    register int32 temp1;
+    register int32 qv = q_value;
+    register int32 tt = tmp;
+
+    asm volatile("movs    %1, %2, lsl #1\n\t"
+                 "addlt   %1, %1, #15\n\t"
+                 "mov     %0, %1, asr #4\n\t"
+                 "add     %1, %0, %3\n\t"
+                 "subs    %1, %1, #0xF00\n\t"
+                 "subcss  %1, %1, #0xFE\n\t"
+                 "eorhi   %0, %3, %0, asr #31"
+             : "=&r"(out),
+                 "=&r"(temp1)
+                         : "r"(qv),
+                         "r"(tt));
+    return out;
+}
+
+
+#endif // Platform
+
+
+#endif //_FASTQUANT_INLINE_H_
+
+
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/findhalfpel.cpp b/media/libstagefright/codecs/m4v_h263/enc/src/findhalfpel.cpp
new file mode 100644
index 0000000..319c76f
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/findhalfpel.cpp
@@ -0,0 +1,287 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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 "mp4def.h"
+#include "mp4enc_lib.h"
+#include "mp4lib_int.h"
+#include "m4venc_oscl.h"
+
+/* 3/29/01 fast half-pel search based on neighboring guess */
+/* value ranging from 0 to 4, high complexity (more accurate) to
+   low complexity (less accurate) */
+#define HP_DISTANCE_TH      2  /* half-pel distance threshold */
+
+#define PREF_16_VEC 129     /* 1MV bias versus 4MVs*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+    void GenerateSearchRegion(UChar *searchPadding, UChar *ref, Int width, Int height,
+    Int ilow, Int ihigh, Int jlow, Int jhigh);
+
+    void InterpDiag(UChar *prev, Int lx, UChar *pred_block);
+    void InterpHorz(UChar *prev, Int lx, UChar *pred_block);
+    void InterpVert(UChar *prev, Int lx, UChar *pred_block);
+#ifdef __cplusplus
+}
+#endif
+
+
+const static Int distance_tab[9][9] =   /* [hp_guess][k] */
+{
+    {0, 1, 1, 1, 1, 1, 1, 1, 1},
+    {1, 0, 1, 2, 3, 4, 3, 2, 1},
+    {1, 0, 0, 0, 1, 2, 3, 2, 1},
+    {1, 2, 1, 0, 1, 2, 3, 4, 3},
+    {1, 2, 1, 0, 0, 0, 1, 2, 3},
+    {1, 4, 3, 2, 1, 0, 1, 2, 3},
+    {1, 2, 3, 2, 1, 0, 0, 0, 1},
+    {1, 2, 3, 4, 3, 2, 1, 0, 1},
+    {1, 0, 1, 2, 3, 2, 1, 0, 0}
+};
+
+
+/*=====================================================================
+    Function:   FindHalfPelMB
+    Date:       10/7/2000
+    Purpose:    Find half pel resolution MV surrounding the full-pel MV
+=====================================================================*/
+
+void FindHalfPelMB(VideoEncData *video, UChar *cur, MOT *mot, UChar *ncand,
+                   Int xpos, Int ypos, Int *xhmin, Int *yhmin, Int hp_guess)
+{
+//  hp_mem = ULong *vertArray; /* 20x17 */
+//           ULong *horzArray; /* 20x16 */
+//           ULong *diagArray; /* 20x17 */
+    Int dmin, d;
+
+    Int xh, yh;
+    Int k, kmin = 0;
+    Int imin, jmin, ilow, jlow;
+    Int h263_mode = video->encParams->H263_Enabled; /*  3/29/01 */
+    Int in_range[9] = {0, 1, 1, 1, 1, 1, 1, 1, 1}; /*  3/29/01 */
+    Int range = video->encParams->SearchRange;
+    Int lx = video->currVop->pitch;
+    Int width = video->currVop->width; /*  padding */
+    Int height = video->vol[video->currLayer]->height;
+    Int(**SAD_MB_HalfPel)(UChar*, UChar*, Int, void*) =
+        video->functionPointer->SAD_MB_HalfPel;
+    void *extra_info = video->sad_extra_info;
+
+    Int next_hp_pos[9][2] = {{0, 0}, {2, 0}, {1, 1}, {0, 2}, { -1, 1}, { -2, 0}, { -1, -1}, {0, -2}, {0, -1}};
+    Int next_ncand[9] = {0, 1 , lx, lx, 0, -1, -1, -lx, -lx};
+
+    cur = video->currYMB;
+
+    /**************** check range ***************************/
+    /*  3/29/01 */
+    imin = xpos + (mot[0].x >> 1);
+    jmin = ypos + (mot[0].y >> 1);
+    ilow = xpos - range;
+    jlow = ypos - range;
+
+    if (!h263_mode)
+    {
+        if (imin <= -15 || imin == ilow)
+            in_range[1] = in_range[7] = in_range[8] = 0;
+        else if (imin >= width - 1)
+            in_range[3] = in_range[4] = in_range[5] = 0;
+        if (jmin <= -15 || jmin == jlow)
+            in_range[1] = in_range[2] = in_range[3] = 0;
+        else if (jmin >= height - 1)
+            in_range[5] = in_range[6] = in_range[7] = 0;
+    }
+    else
+    {
+        if (imin <= 0 || imin == ilow)
+            in_range[1] = in_range[7] = in_range[8] = 0;
+        else if (imin >= width - 16)
+            in_range[3] = in_range[4] = in_range[5] = 0;
+        if (jmin <= 0 || jmin == jlow)
+            in_range[1] = in_range[2] = in_range[3] = 0;
+        else if (jmin >= height - 16)
+            in_range[5] = in_range[6] = in_range[7] = 0;
+    }
+
+    xhmin[0] = 0;
+    yhmin[0] = 0;
+    dmin = mot[0].sad;
+
+    xh = 0;
+    yh = -1;
+    ncand -= lx; /* initial position */
+
+    for (k = 2; k <= 8; k += 2)
+    {
+        if (distance_tab[hp_guess][k] < HP_DISTANCE_TH)
+        {
+            if (in_range[k])
+            {
+                d = (*(SAD_MB_HalfPel[((yh&1)<<1)+(xh&1)]))(ncand, cur, (dmin << 16) | lx, extra_info);
+
+                if (d < dmin)
+                {
+                    dmin = d;
+                    xhmin[0] = xh;
+                    yhmin[0] = yh;
+                    kmin = k;
+                }
+                else if (d == dmin &&
+                         PV_ABS(mot[0].x + xh) + PV_ABS(mot[0].y + yh) < PV_ABS(mot[0].x + xhmin[0]) + PV_ABS(mot[0].y + yhmin[0]))
+                {
+                    xhmin[0] = xh;
+                    yhmin[0] = yh;
+                    kmin = k;
+                }
+
+            }
+        }
+        xh += next_hp_pos[k][0];
+        yh += next_hp_pos[k][1];
+        ncand += next_ncand[k];
+
+        if (k == 8)
+        {
+            if (xhmin[0] != 0 || yhmin[0] != 0)
+            {
+                k = -1;
+                hp_guess = kmin;
+            }
+        }
+    }
+
+    mot[0].sad = dmin;
+    mot[0].x += xhmin[0];
+    mot[0].y += yhmin[0];
+
+    return ;
+}
+
+#ifndef NO_INTER4V
+/*=====================================================================
+    Function:   FindHalfPelBlk
+    Date:       10/7/2000
+    Purpose:    Find half pel resolution MV surrounding the full-pel MV
+                And decide between 1MV or 4MV mode
+=====================================================================*/
+///// THIS FUNCTION IS NOT WORKING!!! NEED TO BE RIVISITED
+
+Int FindHalfPelBlk(VideoEncData *video, UChar *cur, MOT *mot, Int sad16, UChar *ncand8[],
+                   UChar *mode, Int xpos, Int ypos, Int *xhmin, Int *yhmin, UChar *hp_mem)
+{
+    Int k, comp;
+    Int xh, yh;//, xhmin, yhmin;
+    Int imin, jmin, ilow, jlow;
+    Int height;
+    UChar *cand, *cur8;
+    UChar *hmem;//[17*17]; /* half-pel memory */
+    Int d, dmin, sad8;
+    Int lx = video->currVop->pitch;
+    Int width = video->currVop->width; /* , padding */
+    Int(*SAD_Blk_HalfPel)(UChar*, UChar*, Int, Int, Int, Int, Int, void*) = video->functionPointer->SAD_Blk_HalfPel;
+    void *extra_info = video->sad_extra_info;
+    Int in_range[8]; /*  3/29/01 */
+    Int range = video->encParams->SearchRange;
+    Int swidth;
+    Int next_hp_pos[8][2] = {{1, 0}, {1, 0}, {0, 1}, {0, 1}, { -1, 0}, { -1, 0}, {0, -1}, {0, -1}};
+
+    height = video->vol[video->currLayer]->height;
+
+    hmem = hp_mem;
+    sad8 = 0;
+    for (comp = 0; comp < 4; comp++)
+    {
+#ifdef _SAD_STAT
+        num_HP_Blk++;
+#endif
+        /**************** check range ***************************/
+        /*  3/29/01 */
+        M4VENC_MEMSET(in_range, 1, sizeof(Int) << 3);
+        imin = xpos + ((comp & 1) << 3) + (mot[comp+1].x >> 1);
+        jmin = ypos + ((comp & 2) << 2) + (mot[comp+1].y >> 1);
+        ilow = xpos + ((comp & 1) << 3) - range;
+        jlow = ypos + ((comp & 2) << 2) - range;
+
+        if (imin <= -15 || imin == ilow)
+            in_range[0] = in_range[6] = in_range[7] = 0;
+        else if (imin >= width - 1)
+            in_range[2] = in_range[3] = in_range[4] = 0;
+
+        if (jmin <= -15 || jmin == jlow)
+            in_range[0] = in_range[1] = in_range[2] = 0;
+        else if (jmin >= height - 1)
+            in_range[4] = in_range[5] = in_range[6] = 0;
+
+        /**************** half-pel search ***********************/
+        cur8 = cur + ((comp & 1) << 3) + ((comp & 2) << 2) * width ;
+
+        /* generate half-pel search region */
+        {
+            cand = ncand8[comp+1];
+            swidth = lx;
+        }
+
+        xhmin[comp+1] = 0;
+        yhmin[comp+1] = 0;
+        dmin = mot[comp+1].sad;
+
+        xh = -1;
+        yh = -1;
+        for (k = 0; k < 8; k++)
+        {
+            if (in_range[k])
+            {
+                d = (*SAD_Blk_HalfPel)(cand, cur8, dmin, lx, swidth, xh, yh, extra_info);
+
+                if (d < dmin)
+                {
+                    dmin = d;
+                    xhmin[comp+1] = xh;
+                    yhmin[comp+1] = yh;
+                }
+            }
+            xh += next_hp_pos[k][0];
+            yh += next_hp_pos[k][1];
+        }
+        /********************************************/
+        mot[comp+1].x += xhmin[comp+1];
+        mot[comp+1].y += yhmin[comp+1];
+        mot[comp+1].sad = dmin;
+        sad8 += dmin;
+
+        if (sad8 >= sad16 - PREF_16_VEC)
+        {
+            *mode = MODE_INTER;
+            for (k = 1; k <= 4; k++)
+            {
+                mot[k].sad = (mot[0].sad + 2) >> 2;
+                mot[k].x = mot[0].x;
+                mot[k].y = mot[0].y;
+            }
+            return sad8;
+        }
+
+        hmem += (10 * 10);
+    }
+
+    *mode = MODE_INTER4V;
+
+    return sad8;
+}
+#endif /* NO_INTER4V */
+
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/m4venc_oscl.h b/media/libstagefright/codecs/m4v_h263/enc/src/m4venc_oscl.h
new file mode 100644
index 0000000..c9e18d5
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/m4venc_oscl.h
@@ -0,0 +1,43 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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.
+ * -------------------------------------------------------------------
+ */
+/*********************************************************************************/
+/* Revision History                                                             */
+/* Date: 11/04/05                                                               */
+/* Description: Created for abstracting out OSCL such that the code can be used */
+/*          by both V3 and V4 OSCL library. This file is for V4.                */
+/*********************************************************************************/
+
+#ifndef _M4VENC_OSCL_H_
+#define _M4VENC_OSCL_H_
+
+#include <stdlib.h>
+#include <math.h>
+
+#define M4VENC_MALLOC(size)             malloc(size)
+#define M4VENC_FREE(ptr)                free(ptr)
+
+#define M4VENC_MEMSET(ptr,val,size)     memset(ptr,val,size)
+#define M4VENC_MEMCPY(dst,src,size)     memcpy(dst,src,size)
+
+#define M4VENC_LOG(x)                   log(x)
+#define M4VENC_SQRT(x)                  sqrt(x)
+#define M4VENC_POW(x,y)                 pow(x,y)
+
+#define M4VENC_HAS_SYMBIAN_SUPPORT  OSCL_HAS_SYMBIAN_SUPPORT
+
+#endif //_M4VENC_OSCL_H_
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/me_utils.cpp b/media/libstagefright/codecs/m4v_h263/enc/src/me_utils.cpp
new file mode 100644
index 0000000..6dab31a
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/me_utils.cpp
@@ -0,0 +1,386 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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 "mp4def.h"
+#include "mp4enc_lib.h"
+#include "mp4lib_int.h"
+#include "m4venc_oscl.h"
+
+#define VOP_OFFSET  ((lx<<4)+16)  /* for offset to image area */
+#define CVOP_OFFSET ((lx<<2)+8)
+
+#define PREF_INTRA  512     /* bias for INTRA coding */
+
+/*===============================================================
+    Function:   ChooseMode
+    Date:       09/21/2000
+    Purpose:    Choosing between INTRA or INTER
+    Input/Output: Pointer to the starting point of the macroblock.
+    Note:
+===============================================================*/
+void ChooseMode_C(UChar *Mode, UChar *cur, Int lx, Int min_SAD)
+{
+    Int i, j;
+    Int MB_mean, A, tmp, Th;
+    Int offset = (lx >> 2) - 4;
+    UChar *p = cur;
+    Int *pint = (Int *) cur, temp = 0;
+    MB_mean = 0;
+    A = 0;
+    Th = (min_SAD - PREF_INTRA) >> 1;
+
+    for (j = 0; j < 8; j++)
+    {
+
+        /* Odd Rows */
+        temp += (*pint++) & 0x00FF00FF;
+        temp += (*pint++) & 0x00FF00FF;
+        temp += (*pint++) & 0x00FF00FF;
+        temp += (*pint++) & 0x00FF00FF;
+        pint += offset;
+
+        /* Even Rows */
+        temp += (*pint++ >> 8) & 0x00FF00FF;
+        temp += (*pint++ >> 8) & 0x00FF00FF;
+        temp += (*pint++ >> 8) & 0x00FF00FF;
+        temp += (*pint++ >> 8) & 0x00FF00FF;
+        pint += offset;
+
+    }
+
+    MB_mean = (((temp & 0x0000FFFF)) + ((temp & 0xFFFF0000) >> 16)) >> 7;
+
+    p = cur;
+    offset = lx - 16;
+    for (j = 0; j < 16; j++)
+    {
+        temp = (j & 1);
+        p += temp;
+        i = 8;
+        while (i--)
+        {
+            tmp = *p - MB_mean;
+            p += 2;
+            if (tmp > 0) A += tmp;
+            else    A -= tmp;
+        }
+
+        if (A >= Th)
+        {
+            *Mode = MODE_INTER;
+            return ;
+        }
+        p += (offset - temp);
+    }
+
+    if (A < Th)
+        *Mode = MODE_INTRA;
+    else
+        *Mode = MODE_INTER;
+
+    return ;
+}
+
+
+/*===============================================================
+    Function:   GetHalfPelMBRegion
+    Date:       09/17/2000
+    Purpose:    Interpolate the search region for half-pel search
+    Input/Output:   Center of the search, Half-pel memory, width
+    Note:       rounding type should be parameterized.
+                Now fixed it to zero!!!!!!
+
+===============================================================*/
+
+
+void GetHalfPelMBRegion_C(UChar *cand, UChar *hmem, Int lx)
+{
+    Int i, j;
+    UChar *p1, *p2, *p3, *p4;
+    UChar *hmem1 = hmem;
+    UChar *hmem2 = hmem1 + 33;
+    Int offset = lx - 17;
+
+    p1 = cand - lx - 1;
+    p2 = cand - lx;
+    p3 = cand - 1;
+    p4 = cand;
+
+    for (j = 0; j < 16; j++)
+    {
+        for (i = 0; i < 16; i++)
+        {
+            *hmem1++ = ((*p1++) + *p2 + *p3 + *p4 + 2) >> 2;
+            *hmem1++ = ((*p2++) + *p4 + 1) >> 1;
+            *hmem2++ = ((*p3++) + *p4 + 1) >> 1;
+            *hmem2++ = *p4++;
+        }
+        /*  last pixel */
+        *hmem1++ = ((*p1++) + (*p2++) + *p3 + *p4 + 2) >> 2;
+        *hmem2++ = ((*p3++) + (*p4++) + 1) >> 1;
+        hmem1 += 33;
+        hmem2 += 33;
+        p1 += offset;
+        p2 += offset;
+        p3 += offset;
+        p4 += offset;
+    }
+    /* last row */
+    for (i = 0; i < 16; i++)
+    {
+        *hmem1++ = ((*p1++) + *p2 + (*p3++) + *p4 + 2) >> 2;
+        *hmem1++ = ((*p2++) + (*p4++) + 1) >> 1;
+
+    }
+    *hmem1 = (*p1 + *p2 + *p3 + *p4 + 2) >> 2;
+
+    return ;
+}
+
+/*===============================================================
+   Function:    GetHalfPelBlkRegion
+   Date:        09/20/2000
+   Purpose: Interpolate the search region for half-pel search
+            in 4MV mode.
+   Input/Output:    Center of the search, Half-pel memory, width
+   Note:        rounding type should be parameterized.
+            Now fixed it to zero!!!!!!
+
+===============================================================*/
+
+
+void GetHalfPelBlkRegion(UChar *cand, UChar *hmem, Int lx)
+{
+    Int i, j;
+    UChar *p1, *p2, *p3, *p4;
+    UChar *hmem1 = hmem;
+    UChar *hmem2 = hmem1 + 17;
+    Int offset = lx - 9;
+
+    p1 = cand - lx - 1;
+    p2 = cand - lx;
+    p3 = cand - 1;
+    p4 = cand;
+
+    for (j = 0; j < 8; j++)
+    {
+        for (i = 0; i < 8; i++)
+        {
+            *hmem1++ = ((*p1++) + *p2 + *p3 + *p4 + 2) >> 2;
+            *hmem1++ = ((*p2++) + *p4 + 1) >> 1;
+            *hmem2++ = ((*p3++) + *p4 + 1) >> 1;
+            *hmem2++ = *p4++;
+        }
+        /*  last pixel */
+        *hmem1++ = ((*p1++) + (*p2++) + *p3 + *p4 + 2) >> 2;
+        *hmem2++ = ((*p3++) + (*p4++) + 1) >> 1;
+        hmem1 += 17;
+        hmem2 += 17;
+        p1 += offset;
+        p2 += offset;
+        p3 += offset;
+        p4 += offset;
+    }
+    /* last row */
+    for (i = 0; i < 8; i++)
+    {
+        *hmem1++ = ((*p1++) + *p2 + (*p3++) + *p4 + 2) >> 2;
+        *hmem1++ = ((*p2++) + (*p4++) + 1) >> 1;
+
+    }
+    *hmem1 = (*p1 + *p2 + *p3 + *p4 + 2) >> 2;
+
+    return ;
+}
+
+
+/*=====================================================================
+    Function:   PaddingEdge
+    Date:       09/16/2000
+    Purpose:    Pad edge of a Vop
+    Modification: 09/20/05.
+=====================================================================*/
+
+void  PaddingEdge(Vop *refVop)
+{
+    UChar *src, *dst;
+    Int i;
+    Int pitch, width, height;
+    ULong temp1, temp2;
+
+    width = refVop->width;
+    height = refVop->height;
+    pitch = refVop->pitch;
+
+    /* pad top */
+    src = refVop->yChan;
+
+    temp1 = *src; /* top-left corner */
+    temp2 = src[width-1]; /* top-right corner */
+    temp1 |= (temp1 << 8);
+    temp1 |= (temp1 << 16);
+    temp2 |= (temp2 << 8);
+    temp2 |= (temp2 << 16);
+
+    dst = src - (pitch << 4);
+
+    *((ULong*)(dst - 16)) = temp1;
+    *((ULong*)(dst - 12)) = temp1;
+    *((ULong*)(dst - 8)) = temp1;
+    *((ULong*)(dst - 4)) = temp1;
+
+    M4VENC_MEMCPY(dst, src, width);
+
+    *((ULong*)(dst += width)) = temp2;
+    *((ULong*)(dst + 4)) = temp2;
+    *((ULong*)(dst + 8)) = temp2;
+    *((ULong*)(dst + 12)) = temp2;
+
+    dst = dst - width - 16;
+
+    i = 15;
+    while (i--)
+    {
+        M4VENC_MEMCPY(dst + pitch, dst, pitch);
+        dst += pitch;
+    }
+
+    /* pad sides */
+    dst += (pitch + 16);
+    src = dst;
+    i = height;
+    while (i--)
+    {
+        temp1 = *src;
+        temp2 = src[width-1];
+        temp1 |= (temp1 << 8);
+        temp1 |= (temp1 << 16);
+        temp2 |= (temp2 << 8);
+        temp2 |= (temp2 << 16);
+
+        *((ULong*)(dst - 16)) = temp1;
+        *((ULong*)(dst - 12)) = temp1;
+        *((ULong*)(dst - 8)) = temp1;
+        *((ULong*)(dst - 4)) = temp1;
+
+        *((ULong*)(dst += width)) = temp2;
+        *((ULong*)(dst + 4)) = temp2;
+        *((ULong*)(dst + 8)) = temp2;
+        *((ULong*)(dst + 12)) = temp2;
+
+        src += pitch;
+        dst = src;
+    }
+
+    /* pad bottom */
+    dst -= 16;
+    i = 16;
+    while (i--)
+    {
+        M4VENC_MEMCPY(dst, dst - pitch, pitch);
+        dst += pitch;
+    }
+
+
+    return ;
+}
+
+/*===================================================================
+    Function:   ComputeMBSum
+    Date:       10/28/2000
+    Purpose:    Compute sum of absolute value (SAV) of blocks in a macroblock
+                in INTRA mode needed for rate control. Thus, instead of
+                computing the SAV, we can compute first order moment or
+                variance .
+
+    11/28/00:    add MMX
+    9/3/01:      do parallel comp for C function.
+===================================================================*/
+void ComputeMBSum_C(UChar *cur, Int lx, MOT *mot_mb)
+{
+    Int j;
+    Int *cInt, *cInt2;
+    Int sad1 = 0, sad2 = 0, sad3 = 0, sad4 = 0;
+    Int tmp, tmp2, mask = 0x00FF00FF;
+
+    cInt = (Int*)cur;   /* make sure this is word-align */
+    cInt2 = (Int*)(cur + (lx << 3));
+    j = 8;
+    while (j--)
+    {
+        tmp = cInt[3];  /* load 4 pixels at a time */
+        tmp2 = tmp & mask;
+        tmp = (tmp >> 8) & mask;
+        tmp += tmp2;
+        sad2 += tmp;
+        tmp = cInt[2];
+        tmp2 = tmp & mask;
+        tmp = (tmp >> 8) & mask;
+        tmp += tmp2;
+        sad2 += tmp;
+        tmp = cInt[1];
+        tmp2 = tmp & mask;
+        tmp = (tmp >> 8) & mask;
+        tmp += tmp2;
+        sad1 += tmp;
+        tmp = *cInt;
+        cInt += (lx >> 2);
+        tmp2 = tmp & mask;
+        tmp = (tmp >> 8) & mask;
+        tmp += tmp2;
+        sad1 += tmp;
+
+        tmp = cInt2[3];
+        tmp2 = tmp & mask;
+        tmp = (tmp >> 8) & mask;
+        tmp += tmp2;
+        sad4 += tmp;
+        tmp = cInt2[2];
+        tmp2 = tmp & mask;
+        tmp = (tmp >> 8) & mask;
+        tmp += tmp2;
+        sad4 += tmp;
+        tmp = cInt2[1];
+        tmp2 = tmp & mask;
+        tmp = (tmp >> 8) & mask;
+        tmp += tmp2;
+        sad3 += tmp;
+        tmp = *cInt2;
+        cInt2 += (lx >> 2);
+        tmp2 = tmp & mask;
+        tmp = (tmp >> 8) & mask;
+        tmp += tmp2;
+        sad3 += tmp;
+    }
+    sad1 += (sad1 << 16);
+    sad2 += (sad2 << 16);
+    sad3 += (sad3 << 16);
+    sad4 += (sad4 << 16);
+    sad1 >>= 16;
+    sad2 >>= 16;
+    sad3 >>= 16;
+    sad4 >>= 16;
+
+    mot_mb[1].sad = sad1;
+    mot_mb[2].sad = sad2;
+    mot_mb[3].sad = sad3;
+    mot_mb[4].sad = sad4;
+    mot_mb[0].sad = sad1 + sad2 + sad3 + sad4;
+
+    return ;
+}
+
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/motion_comp.cpp b/media/libstagefright/codecs/m4v_h263/enc/src/motion_comp.cpp
new file mode 100644
index 0000000..b81d278
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/motion_comp.cpp
@@ -0,0 +1,1965 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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 "mp4lib_int.h"
+#include "mp4enc_lib.h"
+
+//const static Int roundtab4[] = {0,1,1,1};
+//const static Int roundtab8[] = {0,0,1,1,1,1,1,2};
+//const static Int roundtab12[] = {0,0,0,1,1,1,1,1,1,1,2,2};
+const static Int roundtab16[] = {0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2};
+
+#define FORWARD_MODE    1
+#define BACKWARD_MODE   2
+#define BIDIRECTION_MODE    3
+#define DIRECT_MODE         4
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+    /*Function Prototype */
+    /* no-edge padding */
+    Int EncGetPredOutside(Int xpos, Int ypos, UChar *c_prev, UChar *rec,
+    Int width, Int height, Int rnd1);
+
+    void Copy_MB_from_Vop(UChar *comp, Int yChan[][NCOEFF_BLOCK], Int width);
+    void Copy_B_from_Vop(UChar *comp, Int cChan[], Int width);
+    void Copy_MB_into_Vop(UChar *comp, Int yChan[][NCOEFF_BLOCK], Int width);
+    void Copy_B_into_Vop(UChar *comp, Int cChan[], Int width);
+    void get_MB(UChar *c_prev, UChar *c_prev_u  , UChar *c_prev_v,
+                Short mb[6][64], Int lx, Int lx_uv);
+
+    Int GetPredAdvBy0x0(
+        UChar *c_prev,      /* i */
+        UChar *pred_block,      /* i */
+        Int lx,     /* i */
+        Int rnd1 /* i */
+    );
+
+    Int GetPredAdvBy0x1(
+        UChar *c_prev,      /* i */
+        UChar *pred_block,      /* i */
+        Int lx,     /* i */
+        Int rnd1 /* i */
+    );
+
+    Int GetPredAdvBy1x0(
+        UChar *c_prev,      /* i */
+        UChar *pred_block,      /* i */
+        Int lx,     /* i */
+        Int rnd1 /* i */
+    );
+
+    Int GetPredAdvBy1x1(
+        UChar *c_prev,      /* i */
+        UChar *pred_block,      /* i */
+        Int lx,     /* i */
+        Int rnd1 /* i */
+    );
+
+    static Int(*const GetPredAdvBTable[2][2])(UChar*, UChar*, Int, Int) =
+    {
+        {&GetPredAdvBy0x0, &GetPredAdvBy0x1},
+        {&GetPredAdvBy1x0, &GetPredAdvBy1x1}
+    };
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+/* ======================================================================== */
+/*  Function : getMotionCompensatedMB( )                                    */
+/*  Date     : 4/17/2001                                                    */
+/*  Purpose  : Get the motion compensate block into video->predictionMB     */
+/*              and generate video->predictionErrorMB                       */
+/*              modified from MBMotionComp() function in the decoder        */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+
+void getMotionCompensatedMB(VideoEncData *video, Int ind_x, Int ind_y, Int offset)
+{
+    Vop *prevVop = video->forwardRefVop; //reference frame
+    Vop *currVop = video->currVop;
+    Int mbnum = video->mbnum;       //mb index
+    MOT *mot = video->mot[mbnum];
+    Int ypos, xpos;
+    UChar *c_prev, *cu_prev, *cv_prev;
+    UChar *c_rec, *cu_rec, *cv_rec;
+    Int height, pitch, pitch_uv, height_uv;
+    Int mode = video->headerInfo.Mode[mbnum];  /* get mode */
+    Int dx, dy;
+    Int xpred, ypred;
+    Int xsum, ysum;
+    Int round1;
+
+    OSCL_UNUSED_ARG(offset);
+
+    round1 = (Int)(1 - video->currVop->roundingType);
+
+    pitch  = currVop->pitch;
+    height = currVop->height;
+    pitch_uv  = pitch >> 1;
+    height_uv = height >> 1;
+
+    ypos = ind_y << 4 ;
+    xpos = ind_x << 4 ;
+
+    c_rec = video->predictedMB;
+    cu_rec = video->predictedMB + 256;
+    cv_rec = video->predictedMB + 264;
+
+    if (mode == MODE_INTER || mode == MODE_INTER_Q)
+    {
+        /* Motion vector in x direction       */
+        dx = mot[0].x;
+        dy = mot[0].y;
+
+        c_prev  = prevVop->yChan;
+
+        xpred = (xpos << 1) + dx ;
+        ypred = (ypos << 1) + dy ;
+
+        /* Call function that performs luminance prediction */
+        EncPrediction_INTER(xpred, ypred, c_prev, c_rec,
+                            pitch, round1);
+
+        if ((dx & 3) == 0)  dx = dx >> 1;
+        else        dx = (dx >> 1) | 1;
+
+        if ((dy & 3) == 0)      dy = dy >> 1;
+        else        dy = (dy >> 1) | 1;
+
+        xpred = xpos + dx;
+        ypred = ypos + dy;
+
+        cu_prev = prevVop->uChan;
+        cv_prev = prevVop->vChan;
+
+        EncPrediction_Chrom(xpred, ypred, cu_prev, cv_prev, cu_rec, cv_rec,
+                            pitch_uv, (currVop->width) >> 1, height_uv, round1);
+    }
+#ifndef NO_INTER4V
+    else if (mode == MODE_INTER4V)
+    {
+        c_prev  = prevVop->yChan;
+        cu_prev = prevVop->uChan;
+        cv_prev = prevVop->vChan;
+
+        EncPrediction_INTER4V(xpos, ypos, mot, c_prev, c_rec,
+                              pitch, round1);
+
+        xsum = mot[1].x + mot[2].x + mot[3].x + mot[4].x;
+        ysum = mot[1].y + mot[2].y + mot[3].y + mot[4].y;
+
+        dx = PV_SIGN(xsum) * (roundtab16[(PV_ABS(xsum)) & 0xF] +
+                              (((PV_ABS(xsum)) >> 4) << 1));
+        dy = PV_SIGN(ysum) * (roundtab16[(PV_ABS(ysum)) & 0xF] +
+                              (((PV_ABS(ysum)) >> 4) << 1));
+
+        ypred = ypos + dy;
+        xpred = xpos + dx;
+
+        EncPrediction_Chrom(xpred, ypred, cu_prev, cv_prev, cu_rec, cv_rec,
+                            pitch_uv, (currVop->width) >> 1, height_uv, round1);
+    }
+#endif
+    else
+    {
+        ;//printf("Error, MODE_SKIPPED is not decided yet!\n");
+    }
+
+    return ;
+}
+
+/***************************************************************************
+    Function:   EncPrediction_INTER
+    Date:       04/17/2001
+    Purpose:    Get predicted area for luminance and compensate with the residue.
+                Modified from luminance_pred_mode_inter() in decoder.
+***************************************************************************/
+
+void EncPrediction_INTER(
+    Int xpred,          /* i */
+    Int ypred,          /* i */
+    UChar *c_prev,          /* i */
+    UChar *c_rec,       /* i */
+    Int lx,         /* i */
+    Int round1          /* i */
+)
+{
+    c_prev += (xpred >> 1) + ((ypred >> 1) * lx);
+
+    GetPredAdvBTable[ypred&1][xpred&1](c_prev, c_rec, lx, round1);
+
+    c_prev += B_SIZE;
+    c_rec += B_SIZE;
+
+    GetPredAdvBTable[ypred&1][xpred&1](c_prev, c_rec, lx, round1);
+
+    c_prev += (lx << 3) - B_SIZE;
+    c_rec += (16 << 3) - B_SIZE; /* padding */
+
+    GetPredAdvBTable[ypred&1][xpred&1](c_prev, c_rec, lx, round1);
+
+    c_prev += B_SIZE;
+    c_rec += B_SIZE;
+
+    GetPredAdvBTable[ypred&1][xpred&1](c_prev, c_rec, lx, round1);
+
+    return;
+}
+
+#ifndef NO_INTER4V
+/***************************************************************************
+    Function:   EncPrediction_INTER4V
+    Date:       04/17/2001
+    Purpose:    Get predicted area for luminance and compensate with the residue.
+                Modified from luminance_pred_mode_inter4v() in decoder.
+***************************************************************************/
+
+void EncPrediction_INTER4V(
+    Int xpos,           /* i */
+    Int ypos,           /* i */
+    MOT *mot,           /* i */
+    UChar *c_prev,          /* i */
+    UChar *c_rec,           /* i */
+    Int lx,         /* i */
+    Int round1          /* i */
+)
+{
+    Int ypred, xpred;
+
+    xpred = (Int)((xpos << 1) + mot[1].x);
+    ypred = (Int)((ypos << 1) + mot[1].y);
+
+    GetPredAdvBTable[ypred&1][xpred&1](c_prev + (xpred >> 1) + ((ypred >> 1)*lx),
+                                       c_rec, lx, round1);
+
+    c_rec += B_SIZE;
+
+    xpred = (Int)(((xpos + B_SIZE) << 1) + mot[2].x);
+    ypred = (Int)((ypos << 1) + mot[2].y);
+
+    GetPredAdvBTable[ypred&1][xpred&1](c_prev + (xpred >> 1) + ((ypred >> 1)*lx),
+                                       c_rec, lx, round1);
+
+    c_rec += (16 << 3) - B_SIZE; /* padding */
+
+    xpred = (Int)((xpos << 1) + mot[3].x);
+    ypred = (Int)(((ypos + B_SIZE) << 1) + mot[3].y);
+
+    GetPredAdvBTable[ypred&1][xpred&1](c_prev + (xpred >> 1) + ((ypred >> 1)*lx),
+                                       c_rec, lx, round1);
+
+    c_rec += B_SIZE;
+
+    xpred = (Int)(((xpos + B_SIZE) << 1) + mot[4].x);
+    ypred = (Int)(((ypos + B_SIZE) << 1) + mot[4].y);
+
+    GetPredAdvBTable[ypred&1][xpred&1](c_prev + (xpred >> 1) + ((ypred >> 1)*lx),
+                                       c_rec, lx, round1);
+
+    return;
+}
+#endif /* NO_INTER4V */
+
+/***************************************************************************
+    Function:   EncPrediction_Chrom
+    Date:       04/17/2001
+    Purpose:    Get predicted area for chrominance and compensate with the residue.
+                Modified from chrominance_pred() in decoder.
+***************************************************************************/
+
+void EncPrediction_Chrom(
+    Int xpred,          /* i */
+    Int ypred,          /* i */
+    UChar *cu_prev,         /* i */
+    UChar *cv_prev,         /* i */
+    UChar *cu_rec,
+    UChar *cv_rec,
+    Int lx,
+    Int width_uv,           /* i */
+    Int height_uv,          /* i */
+    Int round1          /* i */
+)
+{
+    /* check whether the MV points outside the frame */
+    /* Compute prediction for Chrominance b block (block[4]) */
+    if (xpred >= 0 && xpred <= ((width_uv << 1) - (2*B_SIZE)) && ypred >= 0 &&
+            ypred <= ((height_uv << 1) - (2*B_SIZE)))
+    {
+        /*****************************/
+        /* (x,y) is inside the frame */
+        /*****************************/
+
+        /* Compute prediction for Chrominance b (block[4]) */
+        GetPredAdvBTable[ypred&1][xpred&1](cu_prev + (xpred >> 1) + ((ypred >> 1)*lx),
+                                           cu_rec, lx, round1);
+
+        /* Compute prediction for Chrominance r (block[5]) */
+        GetPredAdvBTable[ypred&1][xpred&1](cv_prev + (xpred >> 1) + ((ypred >> 1)*lx),
+                                           cv_rec,  lx, round1);
+    }
+    else
+    {
+        /******************************/
+        /* (x,y) is outside the frame */
+        /******************************/
+
+        /* Compute prediction for Chrominance b (block[4]) */
+        EncGetPredOutside(xpred, ypred,
+                          cu_prev, cu_rec,
+                          width_uv, height_uv, round1);
+
+        /* Compute prediction for Chrominance r (block[5]) */
+        EncGetPredOutside(xpred, ypred,
+                          cv_prev, cv_rec,
+                          width_uv, height_uv, round1);
+    }
+
+    return;
+}
+/***************************************************************************
+    Function:   GetPredAdvancedB
+    Date:       04/17/2001
+    Purpose:    Get predicted area (block) and compensate with the residue.
+                - modified from GetPredAdvancedBAdd in decoder.
+    Intput/Output:
+    Modified:
+***************************************************************************/
+
+Int GetPredAdvBy0x0(
+    UChar *prev,        /* i */
+    UChar *rec,     /* i */
+    Int lx,     /* i */
+    Int rnd /* i */
+)
+{
+    Int i;      /* loop variable */
+    ULong  pred_word, word1, word2;
+    Int tmp;
+
+    OSCL_UNUSED_ARG(rnd);
+
+    /* initialize offset to adjust pixel counter */
+    /*    the next row; full-pel resolution      */
+
+    tmp = (ULong)prev & 0x3;
+
+    if (tmp == 0)  /* word-aligned */
+    {
+        rec -= 16; /* preset */
+        prev -= lx;
+
+        for (i = 8; i > 0; i--)
+        {
+            *((ULong*)(rec += 16)) = *((ULong*)(prev += lx));
+            *((ULong*)(rec + 4)) = *((ULong*)(prev + 4));
+        }
+        return 1;
+    }
+    else if (tmp == 1) /* first position */
+    {
+        prev--; /* word-aligned */
+        rec -= 16; /* preset */
+        prev -= lx;
+
+        for (i = 8; i > 0; i--)
+        {
+            word1 = *((ULong*)(prev += lx)); /* read 4 bytes, b4 b3 b2 b1 */
+            word2 = *((ULong*)(prev + 4));  /* read 4 bytes, b8 b7 b6 b5 */
+            word1 >>= 8; /* 0 b4 b3 b2 */
+            pred_word = word1 | (word2 << 24);  /* b5 b4 b3 b2 */
+            *((ULong*)(rec += 16)) = pred_word;
+
+            word1 = *((ULong*)(prev + 8)); /* b12 b11 b10 b9 */
+            word2 >>= 8; /* 0 b8 b7 b6 */
+            pred_word = word2 | (word1 << 24); /* b9 b8 b7 b6 */
+            *((ULong*)(rec + 4)) = pred_word;
+        }
+
+        return 1;
+    }
+    else if (tmp == 2) /* second position */
+    {
+        prev -= 2; /* word1-aligned */
+        rec -= 16; /* preset */
+        prev -= lx;
+
+        for (i = 8; i > 0; i--)
+        {
+            word1 = *((ULong*)(prev += lx)); /* read 4 bytes, b4 b3 b2 b1 */
+            word2 = *((ULong*)(prev + 4));  /* read 4 bytes, b8 b7 b6 b5 */
+            word1 >>= 16; /* 0 0 b4 b3 */
+            pred_word = word1 | (word2 << 16);  /* b6 b5 b4 b3 */
+            *((ULong*)(rec += 16)) = pred_word;
+
+            word1 = *((ULong*)(prev + 8)); /* b12 b11 b10 b9 */
+            word2 >>= 16; /* 0 0 b8 b7 */
+            pred_word = word2 | (word1 << 16); /* b10 b9 b8 b7 */
+            *((ULong*)(rec + 4)) = pred_word;
+        }
+
+        return 1;
+    }
+    else /* third position */
+    {
+        prev -= 3; /* word1-aligned */
+        rec -= 16; /* preset */
+        prev -= lx;
+
+        for (i = 8; i > 0; i--)
+        {
+            word1 = *((ULong*)(prev += lx)); /* read 4 bytes, b4 b3 b2 b1 */
+            word2 = *((ULong*)(prev + 4));  /* read 4 bytes, b8 b7 b6 b5 */
+            word1 >>= 24; /* 0 0 0 b4 */
+            pred_word = word1 | (word2 << 8);   /* b7 b6 b5 b4 */
+            *((ULong*)(rec += 16)) = pred_word;
+
+            word1 = *((ULong*)(prev + 8)); /* b12 b11 b10 b9 */
+            word2 >>= 24; /* 0 0 0 b8 */
+            pred_word = word2 | (word1 << 8); /* b11 b10 b9 b8 */
+            *((ULong*)(rec + 4)) = pred_word;
+
+        }
+
+        return 1;
+    }
+}
+/**************************************************************************/
+Int GetPredAdvBy0x1(
+    UChar *prev,        /* i */
+    UChar *rec,     /* i */
+    Int lx,     /* i */
+    Int rnd1 /* i */
+)
+{
+    Int i;      /* loop variable */
+    Int offset;
+    ULong word1, word2, word3, word12;
+    Int tmp;
+    ULong mask;
+
+    /* initialize offset to adjust pixel counter */
+    /*    the next row; full-pel resolution      */
+    offset = lx - B_SIZE; /* offset for prev */
+
+    /* Branch based on pixel location (half-pel or full-pel) for x and y */
+    rec -= 12; /* preset */
+
+    tmp = (ULong)prev & 3;
+    mask = 254;
+    mask |= (mask << 8);
+    mask |= (mask << 16); /* 0xFEFEFEFE */
+
+    if (tmp == 0) /* word-aligned */
+    {
+        if (rnd1 == 1)
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word1 = *((ULong*)prev); /* b4 b3 b2 b1 */
+                word2 = *((ULong*)(prev += 4)); /* b8 b7 b6 b5 */
+                word12 = (word1 >> 8); /* 0 b4 b3 b2 */
+                word12 |= (word2 << 24); /* b5 b4 b3 b2 */
+                word3 = word1 | word12; // rnd1 = 1; otherwise word3 = word1&word12
+                word1 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 &= mask;
+                word1 >>= 1;
+                word1 = word1 + (word12 >> 1);
+                word1 += word3;
+                *((ULong*)(rec += 12)) = word1; /* write 4 pixels */
+
+                word1 = *((ULong*)(prev += 4)); /* b12 b11 b10 b9 */
+                word12 = (word2 >> 8); /* 0 b8 b7 b6 */
+                word12 |= (word1 << 24); /* b9 b8 b7 b6 */
+                word3 = word2 | word12;
+                word2 &= mask;
+                word3 &= (~mask);  /* 0x1010101, check last bit */
+                word12 &= mask;
+                word2 >>= 1;
+                word2 = word2 + (word12 >> 1);
+                word2 += word3;
+                *((ULong*)(rec += 4)) = word2; /* write 4 pixels */
+
+                prev += offset;
+            }
+            return 1;
+        }
+        else /* rnd1 == 0 */
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word1 = *((ULong*)prev); /* b4 b3 b2 b1 */
+
+                word2 = *((ULong*)(prev += 4)); /* b8 b7 b6 b5 */
+                word12 = (word1 >> 8); /* 0 b4 b3 b2 */
+                word12 |= (word2 << 24); /* b5 b4 b3 b2 */
+                word3 = word1 & word12; // rnd1 = 1; otherwise word3 = word1&word12
+                word1 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 &= mask;
+                word1 >>= 1;
+                word1 = word1 + (word12 >> 1);
+                word1 += word3;
+                *((ULong*)(rec += 12)) = word1; /* write 4 pixels */
+
+                word1 = *((ULong*)(prev += 4)); /* b12 b11 b10 b9 */
+                word12 = (word2 >> 8); /* 0 b8 b7 b6 */
+                word12 |= (word1 << 24); /* b9 b8 b7 b6 */
+                word3 = word2 & word12;
+                word2 &= mask;
+                word3 &= (~mask);  /* 0x1010101, check last bit */
+                word12 &= mask;
+                word2 >>= 1;
+                word2 = word2 + (word12 >> 1);
+                word2 += word3;
+                *((ULong*)(rec += 4)) = word2; /* write 4 pixels */
+
+                prev += offset;
+            }
+            return 1;
+        } /* rnd1 */
+    }
+    else if (tmp == 1)
+    {
+        prev--; /* word-aligned */
+        if (rnd1 == 1)
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word1 = *((ULong*)prev); /* b3 b2 b1 b0 */
+                word2 = *((ULong*)(prev += 4)); /* b7 b6 b5 b4 */
+                word12 = (word1 >> 8); /* 0 b3 b2 b1 */
+                word1 >>= 16; /* 0 0 b3 b2 */
+                word12 |= (word2 << 24); /* b4 b3 b2 b1 */
+                word1 |= (word2 << 16); /* b5 b4 b3 b2 */
+                word3 = word1 | word12; // rnd1 = 1; otherwise word3 = word1&word12
+                word1 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 &= mask;
+                word1 >>= 1;
+                word1 = word1 + (word12 >> 1);
+                word1 += word3;
+                *((ULong*)(rec += 12)) = word1; /* write 4 pixels */
+
+                word1 = *((ULong*)(prev += 4)); /* b11 b10 b9 b8 */
+                word12 = (word2 >> 8); /* 0 b7 b6 b5 */
+                word2 >>= 16; /* 0 0 b7 b6 */
+                word12 |= (word1 << 24); /* b8 b7 b6 b5 */
+                word2 |= (word1 << 16); /* b9 b8 b7 b6 */
+                word3 = word2 | word12; // rnd1 = 1; otherwise word3 = word2&word12
+                word2 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 &= mask;
+                word2 >>= 1;
+                word2 = word2 + (word12 >> 1);
+                word2 += word3;
+                *((ULong*)(rec += 4)) = word2; /* write 4 pixels */
+
+                prev += offset;
+            }
+            return 1;
+        }
+        else /* rnd1 = 0 */
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word1 = *((ULong*)prev); /* b3 b2 b1 b0 */
+
+                word2 = *((ULong*)(prev += 4)); /* b7 b6 b5 b4 */
+                word12 = (word1 >> 8); /* 0 b3 b2 b1 */
+                word1 >>= 16; /* 0 0 b3 b2 */
+                word12 |= (word2 << 24); /* b4 b3 b2 b1 */
+                word1 |= (word2 << 16); /* b5 b4 b3 b2 */
+                word3 = word1 & word12;
+                word1 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 &= mask;
+                word1 >>= 1;
+                word1 = word1 + (word12 >> 1);
+                word1 += word3;
+                *((ULong*)(rec += 12)) = word1; /* write 4 pixels */
+
+                word1 = *((ULong*)(prev += 4)); /* b11 b10 b9 b8 */
+                word12 = (word2 >> 8); /* 0 b7 b6 b5 */
+                word2 >>= 16; /* 0 0 b7 b6 */
+                word12 |= (word1 << 24); /* b8 b7 b6 b5 */
+                word2 |= (word1 << 16); /* b9 b8 b7 b6 */
+                word3 = word2 & word12;
+                word2 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 &= mask;
+                word2 >>= 1;
+                word2 = word2 + (word12 >> 1);
+                word2 += word3;
+                *((ULong*)(rec += 4)) = word2; /* write 4 pixels */
+
+                prev += offset;
+            }
+            return 1;
+        } /* rnd1 */
+    }
+    else if (tmp == 2)
+    {
+        prev -= 2; /* word-aligned */
+        if (rnd1 == 1)
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word1 = *((ULong*)prev); /* b2 b1 b0 bN1 */
+                word2 = *((ULong*)(prev += 4)); /* b6 b5 b4 b3 */
+                word12 = (word1 >> 16); /* 0 0 b2 b1 */
+                word1 >>= 24; /* 0 0 0 b2 */
+                word12 |= (word2 << 16); /* b4 b3 b2 b1 */
+                word1 |= (word2 << 8); /* b5 b4 b3 b2 */
+                word3 = word1 | word12; // rnd1 = 1; otherwise word3 = word1&word12
+                word1 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 &= mask;
+                word1 >>= 1;
+                word1 = word1 + (word12 >> 1);
+                word1 += word3;
+                *((ULong*)(rec += 12)) = word1; /* write 4 pixels */
+
+                word1 = *((ULong*)(prev += 4)); /* b10 b9 b8 b7 */
+                word12 = (word2 >> 16); /* 0 0 b6 b5 */
+                word2 >>= 24; /* 0 0 0 b6 */
+                word12 |= (word1 << 16); /* b8 b7 b6 b5 */
+                word2 |= (word1 << 8); /* b9 b8 b7 b6 */
+                word3 = word2 | word12; // rnd1 = 1; otherwise word3 = word1&word12
+                word2 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 &= mask;
+                word2 >>= 1;
+                word2 = word2 + (word12 >> 1);
+                word2 += word3;
+                *((ULong*)(rec += 4)) = word2; /* write 4 pixels */
+                prev += offset;
+            }
+            return 1;
+        }
+        else /* rnd1 == 0 */
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word1 = *((ULong*)prev); /* b2 b1 b0 bN1 */
+                word2 = *((ULong*)(prev += 4)); /* b6 b5 b4 b3 */
+                word12 = (word1 >> 16); /* 0 0 b2 b1 */
+                word1 >>= 24; /* 0 0 0 b2 */
+                word12 |= (word2 << 16); /* b4 b3 b2 b1 */
+                word1 |= (word2 << 8); /* b5 b4 b3 b2 */
+                word3 = word1 & word12; // rnd1 = 1; otherwise word3 = word1&word12
+                word1 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 &= mask;
+                word1 >>= 1;
+                word1 = word1 + (word12 >> 1);
+                word1 += word3;
+                *((ULong*)(rec += 12)) = word1; /* write 4 pixels */
+
+                word1 = *((ULong*)(prev += 4)); /* b10 b9 b8 b7 */
+                word12 = (word2 >> 16); /* 0 0 b6 b5 */
+                word2 >>= 24; /* 0 0 0 b6 */
+                word12 |= (word1 << 16); /* b8 b7 b6 b5 */
+                word2 |= (word1 << 8); /* b9 b8 b7 b6 */
+                word3 = word2 & word12; // rnd1 = 1; otherwise word3 = word1&word12
+                word2 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 &= mask;
+                word2 >>= 1;
+                word2 = word2 + (word12 >> 1);
+                word2 += word3;
+                *((ULong*)(rec += 4)) = word2; /* write 4 pixels */
+                prev += offset;
+            }
+            return 1;
+        }
+    }
+    else /* tmp = 3 */
+    {
+        prev -= 3; /* word-aligned */
+        if (rnd1 == 1)
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word1 = *((ULong*)prev); /* b1 b0 bN1 bN2 */
+                word2 = *((ULong*)(prev += 4)); /* b5 b4 b3 b2 */
+                word12 = (word1 >> 24); /* 0 0 0 b1 */
+                word12 |= (word2 << 8); /* b4 b3 b2 b1 */
+                word1 = word2;
+                word3 = word1 | word12; // rnd1 = 1; otherwise word3 = word1&word12
+                word1 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 &= mask;
+                word1 >>= 1;
+                word1 = word1 + (word12 >> 1);
+                word1 += word3;
+                *((ULong*)(rec += 12)) = word1; /* write 4 pixels */
+
+                word1 = *((ULong*)(prev += 4)); /* b9 b8 b7 b6 */
+                word12 = (word2 >> 24); /* 0 0 0 b5 */
+                word12 |= (word1 << 8); /* b8 b7 b6 b5 */
+                word2 = word1; /* b9 b8 b7 b6 */
+                word3 = word2 | word12; // rnd1 = 1; otherwise word3 = word1&word12
+                word2 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 &= mask;
+                word2 >>= 1;
+                word2 = word2 + (word12 >> 1);
+                word2 += word3;
+                *((ULong*)(rec += 4)) = word2; /* write 4 pixels */
+                prev += offset;
+            }
+            return 1;
+        }
+        else
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word1 = *((ULong*)prev); /* b1 b0 bN1 bN2 */
+                word2 = *((ULong*)(prev += 4)); /* b5 b4 b3 b2 */
+                word12 = (word1 >> 24); /* 0 0 0 b1 */
+                word12 |= (word2 << 8); /* b4 b3 b2 b1 */
+                word1 = word2;
+                word3 = word1 & word12; // rnd1 = 1; otherwise word3 = word1&word12
+                word1 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 &= mask;
+                word1 >>= 1;
+                word1 = word1 + (word12 >> 1);
+                word1 += word3;
+                *((ULong*)(rec += 12)) = word1; /* write 4 pixels */
+
+                word1 = *((ULong*)(prev += 4)); /* b9 b8 b7 b6 */
+                word12 = (word2 >> 24); /* 0 0 0 b5 */
+                word12 |= (word1 << 8); /* b8 b7 b6 b5 */
+                word2 = word1; /* b9 b8 b7 b6 */
+                word3 = word2 & word12; // rnd1 = 1; otherwise word3 = word1&word12
+                word2 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 &= mask;
+                word2 >>= 1;
+                word2 = word2 + (word12 >> 1);
+                word2 += word3;
+                *((ULong*)(rec += 4)) = word2; /* write 4 pixels */
+                prev += offset;
+            }
+            return 1;
+        }
+    }
+}
+
+/**************************************************************************/
+Int GetPredAdvBy1x0(
+    UChar *prev,        /* i */
+    UChar *rec,     /* i */
+    Int lx,     /* i */
+    Int rnd1 /* i */
+)
+{
+    Int i;      /* loop variable */
+    Int offset;
+    ULong  word1, word2, word3, word12, word22;
+    Int tmp;
+    ULong mask;
+
+    /* initialize offset to adjust pixel counter */
+    /*    the next row; full-pel resolution      */
+    offset = lx - B_SIZE; /* offset for prev */
+
+    /* Branch based on pixel location (half-pel or full-pel) for x and y */
+    rec -= 12; /* preset */
+
+    tmp = (ULong)prev & 3;
+    mask = 254;
+    mask |= (mask << 8);
+    mask |= (mask << 16); /* 0xFEFEFEFE */
+
+    if (tmp == 0) /* word-aligned */
+    {
+        prev -= 4;
+        if (rnd1 == 1)
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word1 = *((ULong*)(prev += 4));
+                word2 = *((ULong*)(prev + lx));
+                word3 = word1 | word2; // rnd1 = 1; otherwise word3 = word1&word2
+                word1 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word2 &= mask;
+                word1 >>= 1;
+                word1 = word1 + (word2 >> 1);
+                word1 += word3;
+                *((ULong*)(rec += 12)) = word1;
+                word1 = *((ULong*)(prev += 4));
+                word2 = *((ULong*)(prev + lx));
+                word3 = word1 | word2; // rnd1 = 1; otherwise word3 = word1&word2
+                word1 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word2 &= mask;
+                word1 >>= 1;
+                word1 = word1 + (word2 >> 1);
+                word1 += word3;
+                *((ULong*)(rec += 4)) = word1;
+
+                prev += offset;
+            }
+            return 1;
+        }
+        else   /* rnd1 = 0 */
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word1 = *((ULong*)(prev += 4));
+                word2 = *((ULong*)(prev + lx));
+                word3 = word1 & word2;  /* rnd1 = 0; */
+                word1 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word2 &= mask;
+                word1 >>= 1;
+                word1 = word1 + (word2 >> 1);
+                word1 += word3;
+                *((ULong*)(rec += 12)) = word1;
+                word1 = *((ULong*)(prev += 4));
+                word2 = *((ULong*)(prev + lx));
+                word3 = word1 & word2;  /* rnd1 = 0; */
+                word1 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word2 &= mask;
+                word1 >>= 1;
+                word1 = word1 + (word2 >> 1);
+                word1 += word3;
+                *((ULong*)(rec += 4)) = word1;
+
+                prev += offset;
+            }
+            return 1;
+        }
+    }
+    else if (tmp == 1)
+    {
+        prev--; /* word-aligned */
+        if (rnd1 == 1)
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word12 = *((ULong*)prev); /* read b4 b3 b2 b1 */
+                word22 = *((ULong*)(prev + lx));
+
+                word1 = *((ULong*)(prev += 4)); /* read b8 b7 b6 b5 */
+                word2 = *((ULong*)(prev + lx));
+                word12 >>= 8; /* 0 b4 b3 b2 */
+                word22 >>= 8;
+                word12 = word12 | (word1 << 24); /* b5 b4 b3 b2 */
+                word22 = word22 | (word2 << 24);
+                word3 = word12 | word22;
+                word12 &= mask;
+                word22 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 >>= 1;
+                word12 = word12 + (word22 >> 1);
+                word12 += word3;
+                *((ULong*)(rec += 12)) = word12;
+
+                word12 = *((ULong*)(prev += 4)); /* read b12 b11 b10 b9 */
+                word22 = *((ULong*)(prev + lx));
+                word1 >>= 8; /* 0 b8 b7 b6 */
+                word2 >>= 8;
+                word1 = word1 | (word12 << 24); /* b9 b8 b7 b6 */
+                word2 = word2 | (word22 << 24);
+                word3 = word1 | word2;
+                word1 &= mask;
+                word2 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word1 >>= 1;
+                word1 = word1 + (word2 >> 1);
+                word1 += word3;
+                *((ULong*)(rec += 4)) = word1;
+                prev += offset;
+            }
+            return 1;
+        }
+        else /* rnd1 = 0 */
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word12 = *((ULong*)prev); /* read b4 b3 b2 b1 */
+                word22 = *((ULong*)(prev + lx));
+
+                word1 = *((ULong*)(prev += 4)); /* read b8 b7 b6 b5 */
+                word2 = *((ULong*)(prev + lx));
+                word12 >>= 8; /* 0 b4 b3 b2 */
+                word22 >>= 8;
+                word12 = word12 | (word1 << 24); /* b5 b4 b3 b2 */
+                word22 = word22 | (word2 << 24);
+                word3 = word12 & word22;
+                word12 &= mask;
+                word22 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 >>= 1;
+                word12 = word12 + (word22 >> 1);
+                word12 += word3;
+                *((ULong*)(rec += 12)) = word12;
+
+                word12 = *((ULong*)(prev += 4)); /* read b12 b11 b10 b9 */
+                word22 = *((ULong*)(prev + lx));
+                word1 >>= 8; /* 0 b8 b7 b6 */
+                word2 >>= 8;
+                word1 = word1 | (word12 << 24); /* b9 b8 b7 b6 */
+                word2 = word2 | (word22 << 24);
+                word3 = word1 & word2;
+                word1 &= mask;
+                word2 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word1 >>= 1;
+                word1 = word1 + (word2 >> 1);
+                word1 += word3;
+                *((ULong*)(rec += 4)) = word1;
+                prev += offset;
+            }
+            return 1;
+        }
+    }
+    else if (tmp == 2)
+    {
+        prev -= 2; /* word-aligned */
+        if (rnd1 == 1)
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word12 = *((ULong*)prev); /* read b4 b3 b2 b1 */
+                word22 = *((ULong*)(prev + lx));
+
+                word1 = *((ULong*)(prev += 4)); /* read b8 b7 b6 b5 */
+                word2 = *((ULong*)(prev + lx));
+                word12 >>= 16; /* 0 0 b4 b3 */
+                word22 >>= 16;
+                word12 = word12 | (word1 << 16); /* b6 b5 b4 b3 */
+                word22 = word22 | (word2 << 16);
+                word3 = word12 | word22;
+                word12 &= mask;
+                word22 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 >>= 1;
+                word12 = word12 + (word22 >> 1);
+                word12 += word3;
+                *((ULong*)(rec += 12)) = word12;
+
+                word12 = *((ULong*)(prev += 4)); /* read b12 b11 b10 b9 */
+                word22 = *((ULong*)(prev + lx));
+                word1 >>= 16; /* 0 0 b8 b7 */
+                word2 >>= 16;
+                word1 = word1 | (word12 << 16); /* b10 b9 b8 b7 */
+                word2 = word2 | (word22 << 16);
+                word3 = word1 | word2;
+                word1 &= mask;
+                word2 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word1 >>= 1;
+                word1 = word1 + (word2 >> 1);
+                word1 += word3;
+                *((ULong*)(rec += 4)) = word1;
+                prev += offset;
+            }
+            return 1;
+        }
+        else /* rnd1 = 0 */
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word12 = *((ULong*)prev); /* read b4 b3 b2 b1 */
+                word22 = *((ULong*)(prev + lx));
+
+                word1 = *((ULong*)(prev += 4)); /* read b8 b7 b6 b5 */
+                word2 = *((ULong*)(prev + lx));
+                word12 >>= 16; /* 0 0 b4 b3 */
+                word22 >>= 16;
+                word12 = word12 | (word1 << 16); /* b6 b5 b4 b3 */
+                word22 = word22 | (word2 << 16);
+                word3 = word12 & word22;
+                word12 &= mask;
+                word22 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 >>= 1;
+                word12 = word12 + (word22 >> 1);
+                word12 += word3;
+                *((ULong*)(rec += 12)) = word12;
+
+                word12 = *((ULong*)(prev += 4)); /* read b12 b11 b10 b9 */
+                word22 = *((ULong*)(prev + lx));
+                word1 >>= 16; /* 0 0 b8 b7 */
+                word2 >>= 16;
+                word1 = word1 | (word12 << 16); /* b10 b9 b8 b7 */
+                word2 = word2 | (word22 << 16);
+                word3 = word1 & word2;
+                word1 &= mask;
+                word2 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word1 >>= 1;
+                word1 = word1 + (word2 >> 1);
+                word1 += word3;
+                *((ULong*)(rec += 4)) = word1;
+                prev += offset;
+            }
+
+            return 1;
+        }
+    }
+    else /* tmp == 3 */
+    {
+        prev -= 3; /* word-aligned */
+        if (rnd1 == 1)
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word12 = *((ULong*)prev); /* read b4 b3 b2 b1 */
+                word22 = *((ULong*)(prev + lx));
+
+                word1 = *((ULong*)(prev += 4)); /* read b8 b7 b6 b5 */
+                word2 = *((ULong*)(prev + lx));
+                word12 >>= 24; /* 0 0 0 b4 */
+                word22 >>= 24;
+                word12 = word12 | (word1 << 8); /* b7 b6 b5 b4 */
+                word22 = word22 | (word2 << 8);
+                word3 = word12 | word22;
+                word12 &= mask;
+                word22 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 >>= 1;
+                word12 = word12 + (word22 >> 1);
+                word12 += word3;
+                *((ULong*)(rec += 12)) = word12;
+
+                word12 = *((ULong*)(prev += 4)); /* read b12 b11 b10 b9 */
+                word22 = *((ULong*)(prev + lx));
+                word1 >>= 24; /* 0 0 0 b8 */
+                word2 >>= 24;
+                word1 = word1 | (word12 << 8); /* b11 b10 b9 b8 */
+                word2 = word2 | (word22 << 8);
+                word3 = word1 | word2;
+                word1 &= mask;
+                word2 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word1 >>= 1;
+                word1 = word1 + (word2 >> 1);
+                word1 += word3;
+                *((ULong*)(rec += 4)) = word1;
+                prev += offset;
+            }
+            return 1;
+        }
+        else /* rnd1 = 0 */
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word12 = *((ULong*)prev); /* read b4 b3 b2 b1 */
+                word22 = *((ULong*)(prev + lx));
+
+                word1 = *((ULong*)(prev += 4)); /* read b8 b7 b6 b5 */
+                word2 = *((ULong*)(prev + lx));
+                word12 >>= 24; /* 0 0 0 b4 */
+                word22 >>= 24;
+                word12 = word12 | (word1 << 8); /* b7 b6 b5 b4 */
+                word22 = word22 | (word2 << 8);
+                word3 = word12 & word22;
+                word12 &= mask;
+                word22 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 >>= 1;
+                word12 = word12 + (word22 >> 1);
+                word12 += word3;
+                *((ULong*)(rec += 12)) = word12;
+
+                word12 = *((ULong*)(prev += 4)); /* read b12 b11 b10 b9 */
+                word22 = *((ULong*)(prev + lx));
+                word1 >>= 24; /* 0 0 0 b8 */
+                word2 >>= 24;
+                word1 = word1 | (word12 << 8); /* b11 b10 b9 b8 */
+                word2 = word2 | (word22 << 8);
+                word3 = word1 & word2;
+                word1 &= mask;
+                word2 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word1 >>= 1;
+                word1 = word1 + (word2 >> 1);
+                word1 += word3;
+                *((ULong*)(rec += 4)) = word1;
+                prev += offset;
+            }
+            return 1;
+        } /* rnd */
+    } /* tmp */
+}
+
+/**********************************************************************************/
+Int GetPredAdvBy1x1(
+    UChar *prev,        /* i */
+    UChar *rec,     /* i */
+    Int lx,     /* i */
+    Int rnd1 /* i */
+)
+{
+    Int i;      /* loop variable */
+    Int offset;
+    ULong  x1, x2, x1m, x2m, y1, y2, y1m, y2m; /* new way */
+    Int tmp;
+    Int rnd2;
+    ULong mask;
+
+    /* initialize offset to adjust pixel counter */
+    /*    the next row; full-pel resolution      */
+    offset = lx - B_SIZE; /* offset for prev */
+
+    rnd2 = rnd1 + 1;
+    rnd2 |= (rnd2 << 8);
+    rnd2 |= (rnd2 << 16);
+
+    mask = 0x3F;
+    mask |= (mask << 8);
+    mask |= (mask << 16); /* 0x3f3f3f3f */
+
+    tmp = (ULong)prev & 3;
+
+    rec -= 4; /* preset */
+
+    if (tmp == 0) /* word-aligned */
+    {
+        for (i = B_SIZE; i > 0; i--)
+        {
+            x1 = *((ULong*)prev); /* load a3 a2 a1 a0 */
+            x2 = *((ULong*)(prev + lx)); /* load b3 b2 b1 b0, another line */
+            y1 = *((ULong*)(prev += 4)); /* a7 a6 a5 a4 */
+            y2 = *((ULong*)(prev + lx)); /* b7 b6 b5 b4 */
+
+            x1m = (x1 >> 2) & mask; /* zero out last 2 bits */
+            x2m = (x2 >> 2) & mask;
+            x1 = x1 ^(x1m << 2);
+            x2 = x2 ^(x2m << 2);
+            x1m += x2m;
+            x1 += x2;
+
+            /* x2m, x2 free */
+            y1m = (y1 >> 2) & mask; /* zero out last 2 bits */
+            y2m = (y2 >> 2) & mask;
+            y1 = y1 ^(y1m << 2);
+            y2 = y2 ^(y2m << 2);
+            y1m += y2m;
+            y1 += y2;
+
+            /* y2m, y2 free */
+            /* x2m, x2 free */
+            x2 = *((ULong*)(prev += 4)); /* a11 a10 a9 a8 */
+            y2 = *((ULong*)(prev + lx)); /* b11 b10 b9 b8 */
+            x2m = (x2 >> 2) & mask;
+            y2m = (y2 >> 2) & mask;
+            x2 = x2 ^(x2m << 2);
+            y2 = y2 ^(y2m << 2);
+            x2m += y2m;
+            x2 += y2;
+            /* y2m, y2 free */
+
+            /* now operate on x1m, x1, y1m, y1, x2m, x2 */
+            /* x1m = a3+b3, a2+b2, a1+b1, a0+b0 */
+            /* y1m = a7+b7, a6+b6, a5+b5, a4+b4 */
+            /* x2m = a11+b11, a10+b10, a9+b9, a8+b8 */
+            /* x1, y1, x2 */
+
+            y2m = x1m >> 8;
+            y2 = x1 >> 8;
+            y2m |= (y1m << 24);  /* a4+b4, a3+b3, a2+b2, a1+b1 */
+            y2 |= (y1 << 24);
+            x1m += y2m;  /* a3+b3+a4+b4, ....., a0+b0+a1+b1 */
+            x1 += y2;
+            x1 += rnd2;
+            x1 &= (mask << 2);
+            x1m += (x1 >> 2);
+            *((ULong*)(rec += 4)) = x1m; /* save x1m */
+
+            y2m = y1m >> 8;
+            y2 = y1 >> 8;
+            y2m |= (x2m << 24); /* a8+b8, a7+b7, a6+b6, a5+b5 */
+            y2 |= (x2 << 24);
+            y1m += y2m;  /* a7+b7+a8+b8, ....., a4+b4+a5+b5 */
+            y1 += y2;
+            y1 += rnd2;
+            y1 &= (mask << 2);
+            y1m += (y1 >> 2);
+            *((ULong*)(rec += 4)) = y1m; /* save y1m */
+
+            rec += 8;
+            prev += offset;
+        }
+
+        return 1;
+    }
+    else if (tmp == 1)
+    {
+        prev--; /* to word-aligned */
+        for (i = B_SIZE; i > 0; i--)
+        {
+            x1 = *((ULong*)prev); /* load a3 a2 a1 a0 */
+            x2 = *((ULong*)(prev + lx)); /* load b3 b2 b1 b0, another line */
+            y1 = *((ULong*)(prev += 4)); /* a7 a6 a5 a4 */
+            y2 = *((ULong*)(prev + lx)); /* b7 b6 b5 b4 */
+
+            x1m = (x1 >> 2) & mask; /* zero out last 2 bits */
+            x2m = (x2 >> 2) & mask;
+            x1 = x1 ^(x1m << 2);
+            x2 = x2 ^(x2m << 2);
+            x1m += x2m;
+            x1 += x2;
+
+            /* x2m, x2 free */
+            y1m = (y1 >> 2) & mask; /* zero out last 2 bits */
+            y2m = (y2 >> 2) & mask;
+            y1 = y1 ^(y1m << 2);
+            y2 = y2 ^(y2m << 2);
+            y1m += y2m;
+            y1 += y2;
+
+            /* y2m, y2 free */
+            /* x2m, x2 free */
+            x2 = *((ULong*)(prev += 4)); /* a11 a10 a9 a8 */
+            y2 = *((ULong*)(prev + lx)); /* b11 b10 b9 b8 */
+            x2m = (x2 >> 2) & mask;
+            y2m = (y2 >> 2) & mask;
+            x2 = x2 ^(x2m << 2);
+            y2 = y2 ^(y2m << 2);
+            x2m += y2m;
+            x2 += y2;
+            /* y2m, y2 free */
+
+            /* now operate on x1m, x1, y1m, y1, x2m, x2 */
+            /* x1m = a3+b3, a2+b2, a1+b1, a0+b0 */
+            /* y1m = a7+b7, a6+b6, a5+b5, a4+b4 */
+            /* x2m = a11+b11, a10+b10, a9+b9, a8+b8 */
+            /* x1, y1, x2 */
+
+            x1m >>= 8 ;
+            x1 >>= 8;
+            x1m |= (y1m << 24);  /* a4+b4, a3+b3, a2+b2, a1+b1 */
+            x1 |= (y1 << 24);
+            y2m = (y1m << 16);
+            y2 = (y1 << 16);
+            y2m |= (x1m >> 8); /* a5+b5, a4+b4, a3+b3, a2+b2 */
+            y2 |= (x1 >> 8);
+            x1 += rnd2;
+            x1m += y2m;  /* a4+b4+a5+b5, ....., a1+b1+a2+b2 */
+            x1 += y2;
+            x1 &= (mask << 2);
+            x1m += (x1 >> 2);
+            *((ULong*)(rec += 4)) = x1m; /* save x1m */
+
+            y1m >>= 8;
+            y1 >>= 8;
+            y1m |= (x2m << 24); /* a8+b8, a7+b7, a6+b6, a5+b5 */
+            y1 |= (x2 << 24);
+            y2m = (x2m << 16);
+            y2 = (x2 << 16);
+            y2m |= (y1m >> 8); /*  a9+b9, a8+b8, a7+b7, a6+b6,*/
+            y2 |= (y1 >> 8);
+            y1 += rnd2;
+            y1m += y2m;  /* a8+b8+a9+b9, ....., a5+b5+a6+b6 */
+            y1 += y2;
+            y1 &= (mask << 2);
+            y1m += (y1 >> 2);
+            *((ULong*)(rec += 4)) = y1m; /* save y1m */
+
+            rec += 8;
+            prev += offset;
+        }
+        return 1;
+    }
+    else if (tmp == 2)
+    {
+        prev -= 2; /* to word-aligned */
+        for (i = B_SIZE; i > 0; i--)
+        {
+            x1 = *((ULong*)prev); /* load a3 a2 a1 a0 */
+            x2 = *((ULong*)(prev + lx)); /* load b3 b2 b1 b0, another line */
+            y1 = *((ULong*)(prev += 4)); /* a7 a6 a5 a4 */
+            y2 = *((ULong*)(prev + lx)); /* b7 b6 b5 b4 */
+
+            x1m = (x1 >> 2) & mask; /* zero out last 2 bits */
+            x2m = (x2 >> 2) & mask;
+            x1 = x1 ^(x1m << 2);
+            x2 = x2 ^(x2m << 2);
+            x1m += x2m;
+            x1 += x2;
+
+            /* x2m, x2 free */
+            y1m = (y1 >> 2) & mask; /* zero out last 2 bits */
+            y2m = (y2 >> 2) & mask;
+            y1 = y1 ^(y1m << 2);
+            y2 = y2 ^(y2m << 2);
+            y1m += y2m;
+            y1 += y2;
+
+            /* y2m, y2 free */
+            /* x2m, x2 free */
+            x2 = *((ULong*)(prev += 4)); /* a11 a10 a9 a8 */
+            y2 = *((ULong*)(prev + lx)); /* b11 b10 b9 b8 */
+            x2m = (x2 >> 2) & mask;
+            y2m = (y2 >> 2) & mask;
+            x2 = x2 ^(x2m << 2);
+            y2 = y2 ^(y2m << 2);
+            x2m += y2m;
+            x2 += y2;
+            /* y2m, y2 free */
+
+            /* now operate on x1m, x1, y1m, y1, x2m, x2 */
+            /* x1m = a3+b3, a2+b2, a1+b1, a0+b0 */
+            /* y1m = a7+b7, a6+b6, a5+b5, a4+b4 */
+            /* x2m = a11+b11, a10+b10, a9+b9, a8+b8 */
+            /* x1, y1, x2 */
+
+            x1m >>= 16 ;
+            x1 >>= 16;
+            x1m |= (y1m << 16);  /* a5+b5, a4+b4, a3+b3, a2+b2 */
+            x1 |= (y1 << 16);
+            y2m = (y1m << 8);
+            y2 = (y1 << 8);
+            y2m |= (x1m >> 8); /* a6+b6, a5+b5, a4+b4, a3+b3 */
+            y2 |= (x1 >> 8);
+            x1 += rnd2;
+            x1m += y2m;  /* a5+b5+a6+b6, ....., a2+b2+a3+b3 */
+            x1 += y2;
+            x1 &= (mask << 2);
+            x1m += (x1 >> 2);
+            *((ULong*)(rec += 4)) = x1m; /* save x1m */
+
+            y1m >>= 16;
+            y1 >>= 16;
+            y1m |= (x2m << 16); /* a9+b9, a8+b8, a7+b7, a6+b6 */
+            y1 |= (x2 << 16);
+            y2m = (x2m << 8);
+            y2 = (x2 << 8);
+            y2m |= (y1m >> 8); /*  a10+b10, a9+b9, a8+b8, a7+b7,*/
+            y2 |= (y1 >> 8);
+            y1 += rnd2;
+            y1m += y2m;  /* a9+b9+a10+b10, ....., a6+b6+a7+b7 */
+            y1 += y2;
+            y1 &= (mask << 2);
+            y1m += (y1 >> 2);
+            *((ULong*)(rec += 4)) = y1m; /* save y1m */
+
+            rec += 8;
+            prev += offset;
+        }
+        return 1;
+    }
+    else /* tmp == 3 */
+    {
+        prev -= 3; /* to word-aligned */
+        for (i = B_SIZE; i > 0; i--)
+        {
+            x1 = *((ULong*)prev); /* load a3 a2 a1 a0 */
+            x2 = *((ULong*)(prev + lx)); /* load b3 b2 b1 b0, another line */
+            y1 = *((ULong*)(prev += 4)); /* a7 a6 a5 a4 */
+            y2 = *((ULong*)(prev + lx)); /* b7 b6 b5 b4 */
+
+            x1m = (x1 >> 2) & mask; /* zero out last 2 bits */
+            x2m = (x2 >> 2) & mask;
+            x1 = x1 ^(x1m << 2);
+            x2 = x2 ^(x2m << 2);
+            x1m += x2m;
+            x1 += x2;
+
+            /* x2m, x2 free */
+            y1m = (y1 >> 2) & mask; /* zero out last 2 bits */
+            y2m = (y2 >> 2) & mask;
+            y1 = y1 ^(y1m << 2);
+            y2 = y2 ^(y2m << 2);
+            y1m += y2m;
+            y1 += y2;
+
+            /* y2m, y2 free */
+            /* x2m, x2 free */
+            x2 = *((ULong*)(prev += 4)); /* a11 a10 a9 a8 */
+            y2 = *((ULong*)(prev + lx)); /* b11 b10 b9 b8 */
+            x2m = (x2 >> 2) & mask;
+            y2m = (y2 >> 2) & mask;
+            x2 = x2 ^(x2m << 2);
+            y2 = y2 ^(y2m << 2);
+            x2m += y2m;
+            x2 += y2;
+            /* y2m, y2 free */
+
+            /* now operate on x1m, x1, y1m, y1, x2m, x2 */
+            /* x1m = a3+b3, a2+b2, a1+b1, a0+b0 */
+            /* y1m = a7+b7, a6+b6, a5+b5, a4+b4 */
+            /* x2m = a11+b11, a10+b10, a9+b9, a8+b8 */
+            /* x1, y1, x2 */
+
+            x1m >>= 24 ;
+            x1 >>= 24;
+            x1m |= (y1m << 8);  /* a6+b6, a5+b5, a4+b4, a3+b3 */
+            x1 |= (y1 << 8);
+
+            x1m += y1m;  /* a6+b6+a7+b7, ....., a3+b3+a4+b4 */
+            x1 += y1;
+            x1 += rnd2;
+            x1 &= (mask << 2);
+            x1m += (x1 >> 2);
+            *((ULong*)(rec += 4)) = x1m; /* save x1m */
+
+            y1m >>= 24;
+            y1 >>= 24;
+            y1m |= (x2m << 8); /* a10+b10, a9+b9, a8+b8, a7+b7 */
+            y1 |= (x2 << 8);
+            y1m += x2m;  /* a10+b10+a11+b11, ....., a7+b7+a8+b8 */
+            y1 += x2;
+            y1 += rnd2;
+            y1 &= (mask << 2);
+            y1m += (y1 >> 2);
+            *((ULong*)(rec += 4)) = y1m; /* save y1m */
+
+            rec += 8;
+            prev += offset;
+        }
+        return 1;
+    }
+}
+
+
+/*=============================================================================
+    Function:   EncGetPredOutside
+    Date:       04/17/2001
+    Purpose:    - modified from GetPredOutside in the decoder.
+    Modified:    09/24/05
+                use the existing non-initialized padded region
+=============================================================================*/
+// not really needed since padding is included
+#define PAD_CORNER  { temp = *src; \
+                     temp |= (temp<<8); \
+                     temp |= (temp<<16); \
+                     *((ULong*)dst) = temp; \
+                     *((ULong*)(dst+4)) = temp; \
+                     *((ULong*)(dst+=lx)) = temp; \
+                     *((ULong*)(dst+4)) = temp; \
+                     *((ULong*)(dst+=lx)) = temp; \
+                     *((ULong*)(dst+4)) = temp; \
+                     *((ULong*)(dst+=lx)) = temp; \
+                     *((ULong*)(dst+4)) = temp; \
+                     *((ULong*)(dst+=lx)) = temp; \
+                     *((ULong*)(dst+4)) = temp; \
+                     *((ULong*)(dst+=lx)) = temp; \
+                     *((ULong*)(dst+4)) = temp; \
+                     *((ULong*)(dst+=lx)) = temp; \
+                     *((ULong*)(dst+4)) = temp; \
+                     *((ULong*)(dst+=lx)) = temp; \
+                     *((ULong*)(dst+4)) = temp; }
+
+#define PAD_ROW     { temp = *((ULong*)src); \
+                      temp2 = *((ULong*)(src+4)); \
+                      *((ULong*)dst) = temp; \
+                      *((ULong*)(dst+4)) = temp2; \
+                      *((ULong*)(dst+=lx)) = temp; \
+                      *((ULong*)(dst+4)) = temp2; \
+                      *((ULong*)(dst+=lx)) = temp; \
+                      *((ULong*)(dst+4)) = temp2; \
+                      *((ULong*)(dst+=lx)) = temp; \
+                      *((ULong*)(dst+4)) = temp2; \
+                      *((ULong*)(dst+=lx)) = temp; \
+                      *((ULong*)(dst+4)) = temp2; \
+                      *((ULong*)(dst+=lx)) = temp; \
+                      *((ULong*)(dst+4)) = temp2; \
+                      *((ULong*)(dst+=lx)) = temp; \
+                      *((ULong*)(dst+4)) = temp2; \
+                      *((ULong*)(dst+=lx)) = temp; \
+                      *((ULong*)(dst+4)) = temp2; }
+
+#define PAD_COL     { temp = *src;   temp |= (temp<<8);  temp |= (temp<<16); \
+                      *((ULong*)dst) = temp; \
+                     *((ULong*)(dst+4)) = temp; \
+                      temp = *(src+=lx);     temp |= (temp<<8);  temp |= (temp<<16); \
+                      *((ULong*)(dst+=lx)) = temp; \
+                     *((ULong*)(dst+4)) = temp; \
+                      temp = *(src+=lx);     temp |= (temp<<8);  temp |= (temp<<16); \
+                      *((ULong*)(dst+=lx)) = temp; \
+                     *((ULong*)(dst+4)) = temp; \
+                      temp = *(src+=lx);     temp |= (temp<<8);  temp |= (temp<<16); \
+                      *((ULong*)(dst+=lx)) = temp; \
+                     *((ULong*)(dst+4)) = temp; \
+                      temp = *(src+=lx);     temp |= (temp<<8);  temp |= (temp<<16); \
+                      *((ULong*)(dst+=lx)) = temp; \
+                     *((ULong*)(dst+4)) = temp; \
+                      temp = *(src+=lx);     temp |= (temp<<8);  temp |= (temp<<16); \
+                      *((ULong*)(dst+=lx)) = temp; \
+                     *((ULong*)(dst+4)) = temp; \
+                      temp = *(src+=lx);     temp |= (temp<<8);  temp |= (temp<<16); \
+                      *((ULong*)(dst+=lx)) = temp; \
+                     *((ULong*)(dst+4)) = temp; \
+                      temp = *(src+=lx);     temp |= (temp<<8);  temp |= (temp<<16); \
+                      *((ULong*)(dst+=lx)) = temp; \
+                      *((ULong*)(dst+4)) = temp; }
+
+
+Int EncGetPredOutside(Int xpos, Int ypos, UChar *c_prev, UChar *rec,
+                      Int width, Int height, Int rnd1)
+{
+    Int lx;
+    UChar *src, *dst;
+    ULong temp, temp2;
+    Int xoffset;
+
+    lx = width + 16; /* only works for chroma */
+
+    if (xpos < 0)
+    {
+        if (ypos < 0) /* pad top-left */
+        {
+            /* pad corner */
+            src = c_prev;
+            dst = c_prev - (lx << 3) - 8;
+            PAD_CORNER
+
+            /* pad top */
+            dst = c_prev - (lx << 3);
+            PAD_ROW
+
+            /* pad left */
+            dst = c_prev - 8;
+            PAD_COL
+
+            GetPredAdvBTable[ypos&1][xpos&1](c_prev + (xpos >> 1) + ((ypos >> 1)*lx),
+                                             rec, lx, rnd1);
+
+            return 1;
+        }
+        else if ((ypos >> 1) < (height - 8)) /* pad left of frame */
+        {
+            /* pad left */
+            src = c_prev + (ypos >> 1) * lx;
+            dst = src - 8;
+            PAD_COL
+            /* pad extra row */
+            temp = *(src += lx);
+            temp |= (temp << 8);
+            temp |= (temp << 16);
+            *((ULong*)(dst += lx)) = temp;
+            *((ULong*)(dst + 4)) = temp;
+
+            GetPredAdvBTable[ypos&1][xpos&1](c_prev + (xpos >> 1) + ((ypos >> 1)*lx),
+                                             rec, lx, rnd1);
+
+            return 1;
+        }
+        else /* pad bottom-left */
+        {
+            /* pad corner */
+            src = c_prev + (height - 1) * lx;
+            dst = src + lx - 8;
+            PAD_CORNER
+
+            /* pad bottom */
+            dst = src + lx;
+            PAD_ROW
+
+            /* pad left */
+            src -= (lx << 3);
+            src += lx;
+            dst = src - 8;
+            PAD_COL
+
+            GetPredAdvBTable[ypos&1][xpos&1](c_prev + (xpos >> 1) + ((ypos >> 1)*lx),
+                                             rec, lx, rnd1);
+
+            return 1;
+        }
+    }
+    else if ((xpos >> 1) < (width - 8))
+    {
+        if (ypos < 0) /* pad top of frame */
+        {
+            xoffset = (xpos >> 1) & 0x3;
+            src = c_prev + (xpos >> 1) - xoffset;
+            dst = src - (lx << 3);
+            PAD_ROW
+            if (xoffset || (xpos&1))
+            {
+                temp = *((ULong*)(src + 8));
+                dst = src - (lx << 3) + 8;
+                *((ULong*)dst) = temp;
+                *((ULong*)(dst += lx)) = temp;
+                *((ULong*)(dst += lx)) = temp;
+                *((ULong*)(dst += lx)) = temp;
+                *((ULong*)(dst += lx)) = temp;
+                *((ULong*)(dst += lx)) = temp;
+                *((ULong*)(dst += lx)) = temp;
+                *((ULong*)(dst += lx)) = temp;
+            }
+
+            GetPredAdvBTable[ypos&1][xpos&1](c_prev + (xpos >> 1) + ((ypos >> 1)*lx),
+                                             rec, lx, rnd1);
+
+            return 1;
+        }
+        else /* pad bottom of frame */
+        {
+            xoffset = (xpos >> 1) & 0x3;
+            src = c_prev + (xpos >> 1) - xoffset + (height - 1) * lx;
+            dst = src + lx;
+            PAD_ROW
+            if (xoffset || (xpos&1))
+            {
+                temp = *((ULong*)(src + 8));
+                dst = src + lx + 8;
+                *((ULong*)dst) = temp;
+                *((ULong*)(dst += lx)) = temp;
+                *((ULong*)(dst += lx)) = temp;
+                *((ULong*)(dst += lx)) = temp;
+                *((ULong*)(dst += lx)) = temp;
+                *((ULong*)(dst += lx)) = temp;
+                *((ULong*)(dst += lx)) = temp;
+                *((ULong*)(dst += lx)) = temp;
+            }
+
+            GetPredAdvBTable[ypos&1][xpos&1](c_prev + (xpos >> 1) + ((ypos >> 1)*lx),
+                                             rec, lx, rnd1);
+
+            return 1;
+        }
+    }
+    else
+    {
+        if (ypos < 0) /* pad top-right */
+        {
+            /* pad corner */
+            src = c_prev + width - 1;
+            dst = src - (lx << 3) + 1;
+            PAD_CORNER
+
+            /* pad top */
+            src -= 7;
+            dst = src - (lx << 3);
+            PAD_ROW
+
+            /* pad left */
+            src += 7;
+            dst = src + 1;
+            PAD_COL
+
+            GetPredAdvBTable[ypos&1][xpos&1](c_prev + (xpos >> 1) + ((ypos >> 1)*lx),
+                                             rec, lx, rnd1);
+
+            return 1;
+        }
+        else if ((ypos >> 1) < (height - B_SIZE)) /* pad right of frame */
+        {
+            /* pad left */
+            src = c_prev + (ypos >> 1) * lx + width - 1;
+            dst = src + 1;
+            PAD_COL
+            /* pad extra row */
+            temp = *(src += lx);
+            temp |= (temp << 8);
+            temp |= (temp << 16);
+            *((ULong*)(dst += lx)) = temp;
+            *((ULong*)(dst + 4)) = temp;
+
+            GetPredAdvBTable[ypos&1][xpos&1](c_prev + (xpos >> 1) + ((ypos >> 1)*lx),
+                                             rec, lx, rnd1);
+
+            return 1;
+        }
+        else /* pad bottom-right */
+        {
+            /* pad left */
+            src = c_prev + (height - 8) * lx + width - 1;
+            dst = src + 1;
+            PAD_COL
+
+            /* pad corner */
+            dst = src + lx + 1;
+            PAD_CORNER
+
+            /* pad bottom */
+            src -= 7;
+            dst = src + lx;
+            PAD_ROW
+
+            GetPredAdvBTable[ypos&1][xpos&1](c_prev + (xpos >> 1) + ((ypos >> 1)*lx),
+                                             rec, lx, rnd1);
+
+            return 1;
+        }
+    }
+}
+
+/* ====================================================================== /
+    Function : Copy_MB_from_Vop()
+    Date     : 04/17/2001
+ ====================================================================== */
+
+void Copy_MB_from_Vop(UChar *comp, Int yChan[][NCOEFF_BLOCK], Int pitch)
+{
+    Int row, col, i;
+    Int *src1, *src2;
+    Int offset = pitch - MB_SIZE;
+    ULong temp;
+
+    for (i = 0; i < 4; i += 2)
+    {
+        src1 = yChan[i];
+        src2 = yChan[i+1];
+
+        row = B_SIZE;
+        while (row--)
+        {
+            col = B_SIZE;
+            while (col)
+            {
+                temp = *((ULong*)comp);
+                *src1++ = (Int)(temp & 0xFF);
+                *src1++ = (Int)((temp >> 8) & 0xFF);
+                *src1++ = (Int)((temp >> 16) & 0xFF);
+                *src1++ = (Int)((temp >> 24) & 0xFF);
+                comp += 4;
+                col -= 4;
+            }
+            col = B_SIZE;
+            while (col)
+            {
+                temp = *((ULong*)comp);
+                *src2++ = (Int)(temp & 0xFF);
+                *src2++ = (Int)((temp >> 8) & 0xFF);
+                *src2++ = (Int)((temp >> 16) & 0xFF);
+                *src2++ = (Int)((temp >> 24) & 0xFF);
+                comp += 4;
+                col -= 4;
+            }
+            comp += offset;
+        }
+    }
+    return ;
+}
+
+/* ====================================================================== /
+    Function : Copy_B_from_Vop()
+    Date     : 04/17/2001
+/ ====================================================================== */
+
+void Copy_B_from_Vop(UChar *comp, Int cChan[], Int pitch)
+{
+    Int row, col;
+    Int offset = pitch - B_SIZE;
+    ULong temp;
+
+    row = B_SIZE;
+    while (row--)
+    {
+        col = B_SIZE;
+        while (col)
+        {
+            temp = *((ULong*)comp);
+            *cChan++ = (Int)(temp & 0xFF);
+            *cChan++ = (Int)((temp >> 8) & 0xFF);
+            *cChan++ = (Int)((temp >> 16) & 0xFF);
+            *cChan++ = (Int)((temp >> 24) & 0xFF);
+            comp += 4;
+            col -= 4;
+        }
+        comp += offset;
+    }
+}
+
+/* ====================================================================== /
+    Function : Copy_MB_into_Vop()
+    Date     : 04/17/2001
+    History  : From decoder
+/ ====================================================================== */
+
+void Copy_MB_into_Vop(UChar *comp, Int yChan[][NCOEFF_BLOCK], Int pitch)
+{
+    Int row, col, i;
+    Int *src1, *src2;
+    Int offset = pitch - MB_SIZE;
+    UChar mask = 0xFF;
+    Int tmp;
+    ULong temp;
+
+    for (i = 0; i < 4; i += 2)
+    {
+        src1 = yChan[i];
+        src2 = yChan[i+1];
+
+        row = B_SIZE;
+        while (row--)
+        {
+            col = B_SIZE;
+            while (col)
+            {
+                tmp = (*src1++);
+                if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
+                temp = tmp << 24;
+                tmp = (*src1++);
+                if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
+                temp |= (tmp << 16);
+                tmp = (*src1++);
+                if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
+                temp |= (tmp << 8);
+                tmp = (*src1++);
+                if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
+                temp |= tmp;
+                *((ULong*)comp) = temp;
+                comp += 4;
+                col -= 4;
+            }
+            col = B_SIZE;
+            while (col)
+            {
+                tmp = (*src2++);
+                if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
+                temp = tmp << 24;
+                tmp = (*src2++);
+                if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
+                temp |= (tmp << 16);
+                tmp = (*src2++);
+                if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
+                temp |= (tmp << 8);
+                tmp = (*src2++);
+                if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
+                temp |= tmp;
+                *((ULong*)comp) = temp;
+                comp += 4;
+                col -= 4;
+            }
+            comp += offset;
+        }
+    }
+    return ;
+}
+
+
+/* ====================================================================== /
+    Function : Copy_B_into_Vop()
+    Date     : 04/17/2001
+    History  : From decoder
+/ ====================================================================== */
+
+void Copy_B_into_Vop(UChar *comp, Int cChan[], Int pitch)
+{
+    Int row, col;
+    Int offset = pitch - B_SIZE;
+    Int tmp;
+    UChar mask = 0xFF;
+    ULong temp;
+
+    row = B_SIZE;
+    while (row--)
+    {
+        col = B_SIZE;
+        while (col)
+        {
+            tmp = (*cChan++);
+            if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
+            temp = tmp << 24;
+            tmp = (*cChan++);
+            if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
+            temp |= (tmp << 16);
+            tmp = (*cChan++);
+            if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
+            temp |= (tmp << 8);
+            tmp = (*cChan++);
+            if ((UInt)tmp > mask) tmp = mask & (~(tmp >> 31));
+            temp |= tmp;
+            *((ULong*)comp) = temp;
+            comp += 4;
+            col -= 4;
+        }
+        comp += offset;
+    }
+}
+
+/* ======================================================================== */
+/*  Function : get_MB( )                                                    */
+/*  Date     : 10/03/2000                                                   */
+/*  Purpose  : Copy 4 Y to reference frame                                  */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+void get_MB(UChar *c_prev, UChar *c_prev_u  , UChar *c_prev_v,
+            Short mb[6][64], Int lx, Int lx_uv)
+
+{
+    Int i, j, count = 0, count1 = 0;
+    Int k1 = lx - MB_SIZE, k2 = lx_uv - B_SIZE;
+
+    for (i = 0; i < B_SIZE; i++)
+    {
+        for (j = 0; j < B_SIZE; j++)
+        {
+            mb[0][count] = (Int)(*c_prev++);
+            mb[4][count] = (Int)(*c_prev_u++);
+            mb[5][count++] = (Int)(*c_prev_v++);
+        }
+
+        for (j = 0; j < B_SIZE; j++)
+            mb[1][count1++] = (Int)(*c_prev++);
+
+        c_prev += k1;
+        c_prev_u += k2;
+        c_prev_v += k2;
+
+
+    }
+
+    count = count1 = 0;
+    for (i = 0; i < B_SIZE; i++)
+    {
+        for (j = 0; j < B_SIZE; j++)
+            mb[2][count++] = (Int)(*c_prev++);
+
+        for (j = 0; j < B_SIZE; j++)
+            mb[3][count1++] = (Int)(*c_prev++);
+
+        c_prev += k1;
+    }
+}
+
+void PutSkippedBlock(UChar *rec, UChar *prev, Int lx)
+{
+    UChar *end;
+    Int offset = (lx - 8) >> 2;
+    Int *src, *dst;
+
+    dst = (Int*)rec;
+    src = (Int*)prev;
+
+    end = prev + (lx << 3);
+
+    do
+    {
+        *dst++ = *src++;
+        *dst++ = *src++;
+        dst += offset;
+        src += offset;
+    }
+    while ((UInt)src < (UInt)end);
+
+    return ;
+}
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/motion_est.cpp b/media/libstagefright/codecs/m4v_h263/enc/src/motion_est.cpp
new file mode 100644
index 0000000..997b78d
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/motion_est.cpp
@@ -0,0 +1,1741 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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 "mp4def.h"
+#include "mp4enc_lib.h"
+#include "mp4lib_int.h"
+#include "m4venc_oscl.h"
+
+//#define PRINT_MV
+#define MIN_GOP 1   /* minimum size of GOP,  1/23/01, need to be tested */
+
+#define CANDIDATE_DISTANCE  0 /* distance candidate from one another to consider as a distinct one */
+/* shouldn't be more than 3 */
+
+#define ZERO_MV_PREF    0 /* 0: bias (0,0)MV before full-pel search, lowest complexity*/
+/* 1: bias (0,0)MV after full-pel search, before half-pel, highest comp */
+/* 2: bias (0,0)MV after half-pel, high comp, better PSNR */
+
+#define RASTER_REFRESH  /* instead of random INTRA refresh, do raster scan,  2/26/01 */
+
+#ifdef RASTER_REFRESH
+#define TARGET_REFRESH_PER_REGION 4 /* , no. MB per frame to be INTRA refreshed */
+#else
+#define TARGET_REFRESH_PER_REGION 1 /* , no. MB per region to be INTRA refreshed */
+#endif
+
+#define ALL_CAND_EQUAL  10  /*  any number greater than 5 will work */
+
+#define NumPixelMB  256     /*  number of pixels used in SAD calculation */
+
+#define DEF_8X8_WIN 3   /* search region for 8x8 MVs around the 16x16 MV */
+#define MB_Nb  256
+
+#define PREF_NULL_VEC 129   /* for zero vector bias */
+#define PREF_16_VEC 129     /* 1MV bias versus 4MVs*/
+#define PREF_INTRA  512     /* bias for INTRA coding */
+
+const static Int tab_exclude[9][9] =  // [last_loc][curr_loc]
+{
+    {0, 0, 0, 0, 0, 0, 0, 0, 0},
+    {0, 0, 0, 0, 1, 1, 1, 0, 0},
+    {0, 0, 0, 0, 1, 1, 1, 1, 1},
+    {0, 0, 0, 0, 0, 0, 1, 1, 1},
+    {0, 1, 1, 0, 0, 0, 1, 1, 1},
+    {0, 1, 1, 0, 0, 0, 0, 0, 1},
+    {0, 1, 1, 1, 1, 0, 0, 0, 1},
+    {0, 0, 1, 1, 1, 0, 0, 0, 0},
+    {0, 0, 1, 1, 1, 1, 1, 0, 0}
+}; //to decide whether to continue or compute
+
+const static Int refine_next[8][2] =    /* [curr_k][increment] */
+{
+    {0, 0}, {2, 0}, {1, 1}, {0, 2}, { -1, 1}, { -2, 0}, { -1, -1}, {0, -2}
+};
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    void MBMotionSearch(VideoEncData *video, UChar *cur, UChar *best_cand[],
+    Int i0, Int j0, Int type_pred, Int fullsearch, Int *hp_guess);
+
+    Int  fullsearch(VideoEncData *video, Vol *currVol, UChar *ref, UChar *cur,
+                    Int *imin, Int *jmin, Int ilow, Int ihigh, Int jlow, Int jhigh);
+    Int fullsearchBlk(VideoEncData *video, Vol *currVol, UChar *cent, UChar *cur,
+                      Int *imin, Int *jmin, Int ilow, Int ihigh, Int jlow, Int jhigh, Int range);
+    void CandidateSelection(Int *mvx, Int *mvy, Int *num_can, Int imb, Int jmb,
+                            VideoEncData *video, Int type_pred);
+    void RasterIntraUpdate(UChar *intraArray, UChar *Mode, Int totalMB, Int numRefresh);
+    void ResetIntraUpdate(UChar *intraArray, Int totalMB);
+    void ResetIntraUpdateRegion(UChar *intraArray, Int start_i, Int rwidth,
+                                Int start_j, Int rheight, Int mbwidth, Int mbheight);
+
+    void MoveNeighborSAD(Int dn[], Int new_loc);
+    Int FindMin(Int dn[]);
+    void PrepareCurMB(VideoEncData *video, UChar *cur);
+
+#ifdef __cplusplus
+}
+#endif
+
+/***************************************/
+/*  2/28/01, for HYPOTHESIS TESTING */
+#ifdef HTFM     /* defined in mp4def.h */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+    void CalcThreshold(double pf, double exp_lamda[], Int nrmlz_th[]);
+    void    HTFMPrepareCurMB(VideoEncData *video, HTFM_Stat *htfm_stat, UChar *cur);
+#ifdef __cplusplus
+}
+#endif
+
+
+#define HTFM_Pf  0.25   /* 3/2/1, probability of false alarm, can be varied from 0 to 0.5 */
+/***************************************/
+#endif
+
+#ifdef _SAD_STAT
+ULong num_MB = 0;
+ULong num_HP_MB = 0;
+ULong num_Blk = 0;
+ULong num_HP_Blk = 0;
+ULong num_cand = 0;
+ULong num_better_hp = 0;
+ULong i_dist_from_guess = 0;
+ULong j_dist_from_guess = 0;
+ULong num_hp_not_zero = 0;
+#endif
+
+
+
+/*==================================================================
+    Function:   MotionEstimation
+    Date:       10/3/2000
+    Purpose:    Go through all macroblock for motion search and
+                determine scene change detection.
+====================================================================*/
+
+void MotionEstimation(VideoEncData *video)
+{
+    UChar use_4mv = video->encParams->MV8x8_Enabled;
+    Vol *currVol = video->vol[video->currLayer];
+    Vop *currVop = video->currVop;
+    VideoEncFrameIO *currFrame = video->input;
+    Int i, j, comp;
+    Int mbwidth = currVol->nMBPerRow;
+    Int mbheight = currVol->nMBPerCol;
+    Int totalMB = currVol->nTotalMB;
+    Int width = currFrame->pitch;
+    UChar *mode_mb, *Mode = video->headerInfo.Mode;
+    MOT *mot_mb, **mot = video->mot;
+    UChar *intraArray = video->intraArray;
+    Int FS_en = video->encParams->FullSearch_Enabled;
+    void (*ComputeMBSum)(UChar *, Int, MOT *) = video->functionPointer->ComputeMBSum;
+    void (*ChooseMode)(UChar*, UChar*, Int, Int) = video->functionPointer->ChooseMode;
+
+    Int numIntra, start_i, numLoop, incr_i;
+    Int mbnum, offset;
+    UChar *cur, *best_cand[5];
+    Int sad8 = 0, sad16 = 0;
+    Int totalSAD = 0;   /* average SAD for rate control */
+    Int skip_halfpel_4mv;
+    Int f_code_p, f_code_n, max_mag = 0, min_mag = 0;
+    Int type_pred;
+    Int xh[5] = {0, 0, 0, 0, 0};
+    Int yh[5] = {0, 0, 0, 0, 0}; /* half-pel */
+    UChar hp_mem4MV[17*17*4];
+
+#ifdef HTFM
+    /***** HYPOTHESIS TESTING ********/  /* 2/28/01 */
+    Int collect = 0;
+    HTFM_Stat htfm_stat;
+    double newvar[16];
+    double exp_lamda[15];
+    /*********************************/
+#endif
+    Int hp_guess = 0;
+#ifdef PRINT_MV
+    FILE *fp_debug;
+#endif
+
+//  FILE *fstat;
+//  static int frame_num = 0;
+
+    offset = 0;
+
+    if (video->currVop->predictionType == I_VOP)
+    {   /* compute the SAV */
+        mbnum = 0;
+        cur = currFrame->yChan;
+
+        for (j = 0; j < mbheight; j++)
+        {
+            for (i = 0; i < mbwidth; i++)
+            {
+                video->mbnum = mbnum;
+                mot_mb = mot[mbnum];
+
+                (*ComputeMBSum)(cur + (i << 4), width, mot_mb);
+
+                totalSAD += mot_mb[0].sad;
+
+                mbnum++;
+            }
+            cur += (width << 4);
+        }
+
+        video->sumMAD = (float)totalSAD / (float)NumPixelMB;
+
+        ResetIntraUpdate(intraArray, totalMB);
+
+        return  ;
+    }
+
+    /* 09/20/05 */
+    if (video->prevBaseVop->padded == 0 && !video->encParams->H263_Enabled)
+    {
+        PaddingEdge(video->prevBaseVop);
+        video->prevBaseVop->padded = 1;
+    }
+
+    /* Random INTRA update */
+    /*  suggest to do it in CodeMB */
+    /*  2/21/2001 */
+    //if(video->encParams->RC_Type == CBR_1 || video->encParams->RC_Type == CBR_2)
+    if (video->currLayer == 0 && video->encParams->Refresh)
+    {
+        RasterIntraUpdate(intraArray, Mode, totalMB, video->encParams->Refresh);
+    }
+
+    video->sad_extra_info = NULL;
+
+#ifdef HTFM
+    /***** HYPOTHESIS TESTING ********/  /* 2/28/01 */
+    InitHTFM(video, &htfm_stat, newvar, &collect);
+    /*********************************/
+#endif
+
+    if ((video->encParams->SceneChange_Det == 1) /*&& video->currLayer==0 */
+            && ((video->encParams->LayerFrameRate[0] < 5.0) || (video->numVopsInGOP > MIN_GOP)))
+        /* do not try to detect a new scene if low frame rate and too close to previous I-frame */
+    {
+        incr_i = 2;
+        numLoop = 2;
+        start_i = 1;
+        type_pred = 0; /* for initial candidate selection */
+    }
+    else
+    {
+        incr_i = 1;
+        numLoop = 1;
+        start_i = 0;
+        type_pred = 2;
+    }
+
+    /* First pass, loop thru half the macroblock */
+    /* determine scene change */
+    /* Second pass, for the rest of macroblocks */
+    numIntra = 0;
+    while (numLoop--)
+    {
+        for (j = 0; j < mbheight; j++)
+        {
+            if (incr_i > 1)
+                start_i = (start_i == 0 ? 1 : 0) ; /* toggle 0 and 1 */
+
+            offset = width * (j << 4) + (start_i << 4);
+
+            mbnum = j * mbwidth + start_i;
+
+            for (i = start_i; i < mbwidth; i += incr_i)
+            {
+                video->mbnum = mbnum;
+                mot_mb = mot[mbnum];
+                mode_mb = Mode + mbnum;
+
+                cur = currFrame->yChan + offset;
+
+
+                if (*mode_mb != MODE_INTRA)
+                {
+#if defined(HTFM)
+                    HTFMPrepareCurMB(video, &htfm_stat, cur);
+#else
+                    PrepareCurMB(video, cur);
+#endif
+                    /************************************************************/
+                    /******** full-pel 1MV and 4MVs search **********************/
+
+#ifdef _SAD_STAT
+                    num_MB++;
+#endif
+                    MBMotionSearch(video, cur, best_cand, i << 4, j << 4, type_pred,
+                                   FS_en, &hp_guess);
+
+#ifdef PRINT_MV
+                    fp_debug = fopen("c:\\bitstream\\mv1_debug.txt", "a");
+                    fprintf(fp_debug, "#%d (%d,%d,%d) : ", mbnum, mot_mb[0].x, mot_mb[0].y, mot_mb[0].sad);
+                    fprintf(fp_debug, "(%d,%d,%d) : (%d,%d,%d) : (%d,%d,%d) : (%d,%d,%d) : ==>\n",
+                            mot_mb[1].x, mot_mb[1].y, mot_mb[1].sad,
+                            mot_mb[2].x, mot_mb[2].y, mot_mb[2].sad,
+                            mot_mb[3].x, mot_mb[3].y, mot_mb[3].sad,
+                            mot_mb[4].x, mot_mb[4].y, mot_mb[4].sad);
+                    fclose(fp_debug);
+#endif
+                    sad16 = mot_mb[0].sad;
+#ifdef NO_INTER4V
+                    sad8 = sad16;
+#else
+                    sad8 = mot_mb[1].sad + mot_mb[2].sad + mot_mb[3].sad + mot_mb[4].sad;
+#endif
+
+                    /* choose between INTRA or INTER */
+                    (*ChooseMode)(mode_mb, cur, width, ((sad8 < sad16) ? sad8 : sad16));
+                }
+                else    /* INTRA update, use for prediction 3/23/01 */
+                {
+                    mot_mb[0].x = mot_mb[0].y = 0;
+                }
+
+                if (*mode_mb == MODE_INTRA)
+                {
+                    numIntra++ ;
+
+                    /* compute SAV for rate control and fast DCT, 11/28/00 */
+                    (*ComputeMBSum)(cur, width, mot_mb);
+
+                    /* leave mot_mb[0] as it is for fast motion search */
+                    /* set the 4 MVs to zeros */
+                    for (comp = 1; comp <= 4; comp++)
+                    {
+                        mot_mb[comp].x = 0;
+                        mot_mb[comp].y = 0;
+                    }
+#ifdef PRINT_MV
+                    fp_debug = fopen("c:\\bitstream\\mv1_debug.txt", "a");
+                    fprintf(fp_debug, "\n");
+                    fclose(fp_debug);
+#endif
+                }
+                else /* *mode_mb = MODE_INTER;*/
+                {
+                    if (video->encParams->HalfPel_Enabled)
+                    {
+#ifdef _SAD_STAT
+                        num_HP_MB++;
+#endif
+                        /* find half-pel resolution motion vector */
+                        FindHalfPelMB(video, cur, mot_mb, best_cand[0],
+                                      i << 4, j << 4, xh, yh, hp_guess);
+#ifdef PRINT_MV
+                        fp_debug = fopen("c:\\bitstream\\mv1_debug.txt", "a");
+                        fprintf(fp_debug, "(%d,%d), %d\n", mot_mb[0].x, mot_mb[0].y, mot_mb[0].sad);
+                        fclose(fp_debug);
+#endif
+                        skip_halfpel_4mv = ((sad16 - mot_mb[0].sad) <= (MB_Nb >> 1) + 1);
+                        sad16 = mot_mb[0].sad;
+
+#ifndef NO_INTER4V
+                        if (use_4mv && !skip_halfpel_4mv)
+                        {
+                            /* Also decide 1MV or 4MV !!!!!!!!*/
+                            sad8 = FindHalfPelBlk(video, cur, mot_mb, sad16,
+                                                  best_cand, mode_mb, i << 4, j << 4, xh, yh, hp_mem4MV);
+
+#ifdef PRINT_MV
+                            fp_debug = fopen("c:\\bitstream\\mv1_debug.txt", "a");
+                            fprintf(fp_debug, " (%d,%d,%d) : (%d,%d,%d) : (%d,%d,%d) : (%d,%d,%d) \n",
+                                    mot_mb[1].x, mot_mb[1].y, mot_mb[1].sad,
+                                    mot_mb[2].x, mot_mb[2].y, mot_mb[2].sad,
+                                    mot_mb[3].x, mot_mb[3].y, mot_mb[3].sad,
+                                    mot_mb[4].x, mot_mb[4].y, mot_mb[4].sad);
+                            fclose(fp_debug);
+#endif
+                        }
+#endif /* NO_INTER4V */
+                    }
+                    else    /* HalfPel_Enabled ==0  */
+                    {
+#ifndef NO_INTER4V
+                        //if(sad16 < sad8-PREF_16_VEC)
+                        if (sad16 - PREF_16_VEC > sad8)
+                        {
+                            *mode_mb = MODE_INTER4V;
+                        }
+#endif
+                    }
+#if (ZERO_MV_PREF==2)   /* use mot_mb[7].sad as d0 computed in MBMotionSearch*/
+                    /******************************************************/
+                    if (mot_mb[7].sad - PREF_NULL_VEC < sad16 && mot_mb[7].sad - PREF_NULL_VEC < sad8)
+                    {
+                        mot_mb[0].sad = mot_mb[7].sad - PREF_NULL_VEC;
+                        mot_mb[0].x = mot_mb[0].y = 0;
+                        *mode_mb = MODE_INTER;
+                    }
+                    /******************************************************/
+#endif
+                    if (*mode_mb == MODE_INTER)
+                    {
+                        if (mot_mb[0].x == 0 && mot_mb[0].y == 0)   /* use zero vector */
+                            mot_mb[0].sad += PREF_NULL_VEC; /* add back the bias */
+
+                        mot_mb[1].sad = mot_mb[2].sad = mot_mb[3].sad = mot_mb[4].sad = (mot_mb[0].sad + 2) >> 2;
+                        mot_mb[1].x = mot_mb[2].x = mot_mb[3].x = mot_mb[4].x = mot_mb[0].x;
+                        mot_mb[1].y = mot_mb[2].y = mot_mb[3].y = mot_mb[4].y = mot_mb[0].y;
+
+                    }
+                }
+
+                /* find maximum magnitude */
+                /* compute average SAD for rate control, 11/28/00 */
+                if (*mode_mb == MODE_INTER)
+                {
+#ifdef PRINT_MV
+                    fp_debug = fopen("c:\\bitstream\\mv1_debug.txt", "a");
+                    fprintf(fp_debug, "%d MODE_INTER\n", mbnum);
+                    fclose(fp_debug);
+#endif
+                    totalSAD += mot_mb[0].sad;
+                    if (mot_mb[0].x > max_mag)
+                        max_mag = mot_mb[0].x;
+                    if (mot_mb[0].y > max_mag)
+                        max_mag = mot_mb[0].y;
+                    if (mot_mb[0].x < min_mag)
+                        min_mag = mot_mb[0].x;
+                    if (mot_mb[0].y < min_mag)
+                        min_mag = mot_mb[0].y;
+                }
+                else if (*mode_mb == MODE_INTER4V)
+                {
+#ifdef PRINT_MV
+                    fp_debug = fopen("c:\\bitstream\\mv1_debug.txt", "a");
+                    fprintf(fp_debug, "%d MODE_INTER4V\n", mbnum);
+                    fclose(fp_debug);
+#endif
+                    totalSAD += sad8;
+                    for (comp = 1; comp <= 4; comp++)
+                    {
+                        if (mot_mb[comp].x > max_mag)
+                            max_mag = mot_mb[comp].x;
+                        if (mot_mb[comp].y > max_mag)
+                            max_mag = mot_mb[comp].y;
+                        if (mot_mb[comp].x < min_mag)
+                            min_mag = mot_mb[comp].x;
+                        if (mot_mb[comp].y < min_mag)
+                            min_mag = mot_mb[comp].y;
+                    }
+                }
+                else    /* MODE_INTRA */
+                {
+#ifdef PRINT_MV
+                    fp_debug = fopen("c:\\bitstream\\mv1_debug.txt", "a");
+                    fprintf(fp_debug, "%d MODE_INTRA\n", mbnum);
+                    fclose(fp_debug);
+#endif
+                    totalSAD += mot_mb[0].sad;
+                }
+                mbnum += incr_i;
+                offset += (incr_i << 4);
+
+            }
+        }
+
+        if (incr_i > 1 && numLoop) /* scene change on and first loop */
+        {
+            //if(numIntra > ((totalMB>>3)<<1) + (totalMB>>3)) /* 75% of 50%MBs */
+            if (numIntra > (0.30*(totalMB / 2.0))) /* 15% of 50%MBs */
+            {
+                /******** scene change detected *******************/
+                currVop->predictionType = I_VOP;
+                M4VENC_MEMSET(Mode, MODE_INTRA, sizeof(UChar)*totalMB); /* set this for MB level coding*/
+                currVop->quantizer = video->encParams->InitQuantIvop[video->currLayer];
+
+                /* compute the SAV for rate control & fast DCT */
+                totalSAD = 0;
+                offset = 0;
+                mbnum = 0;
+                cur = currFrame->yChan;
+
+                for (j = 0; j < mbheight; j++)
+                {
+                    for (i = 0; i < mbwidth; i++)
+                    {
+                        video->mbnum = mbnum;
+                        mot_mb = mot[mbnum];
+
+
+                        (*ComputeMBSum)(cur + (i << 4), width, mot_mb);
+                        totalSAD += mot_mb[0].sad;
+
+                        mbnum++;
+                    }
+                    cur += (width << 4);
+                }
+
+                video->sumMAD = (float)totalSAD / (float)NumPixelMB;
+                ResetIntraUpdate(intraArray, totalMB);
+                /* video->numVopsInGOP=0; 3/13/01 move it to vop.c*/
+
+                return ;
+            }
+        }
+        /******** no scene change, continue motion search **********************/
+        start_i = 0;
+        type_pred++; /* second pass */
+    }
+
+    video->sumMAD = (float)totalSAD / (float)NumPixelMB;    /* avg SAD */
+
+    /* find f_code , 10/27/2000 */
+    f_code_p = 1;
+    while ((max_mag >> (4 + f_code_p)) > 0)
+        f_code_p++;
+
+    f_code_n = 1;
+    min_mag *= -1;
+    while ((min_mag - 1) >> (4 + f_code_n) > 0)
+        f_code_n++;
+
+    currVop->fcodeForward = (f_code_p > f_code_n ? f_code_p : f_code_n);
+
+#ifdef HTFM
+    /***** HYPOTHESIS TESTING ********/  /* 2/28/01 */
+    if (collect)
+    {
+        collect = 0;
+        UpdateHTFM(video, newvar, exp_lamda, &htfm_stat);
+    }
+    /*********************************/
+#endif
+
+    return ;
+}
+
+
+#ifdef HTFM
+void InitHTFM(VideoEncData *video, HTFM_Stat *htfm_stat, double *newvar, Int *collect)
+{
+    Int i;
+    Int lx = video->currVop->width; //  padding
+    Int lx2 = lx << 1;
+    Int lx3 = lx2 + lx;
+    Int rx = video->currVop->pitch;
+    Int rx2 = rx << 1;
+    Int rx3 = rx2 + rx;
+
+    Int *offset, *offset2;
+
+    /* 4/11/01, collect data every 30 frames, doesn't have to be base layer */
+    if (((Int)video->numVopsInGOP) % 30 == 1)
+    {
+
+        *collect = 1;
+
+        htfm_stat->countbreak = 0;
+        htfm_stat->abs_dif_mad_avg = 0;
+
+        for (i = 0; i < 16; i++)
+        {
+            newvar[i] = 0.0;
+        }
+//      video->functionPointer->SAD_MB_PADDING = &SAD_MB_PADDING_HTFM_Collect;
+        video->functionPointer->SAD_Macroblock = &SAD_MB_HTFM_Collect;
+        video->functionPointer->SAD_MB_HalfPel[0] = NULL;
+        video->functionPointer->SAD_MB_HalfPel[1] = &SAD_MB_HP_HTFM_Collectxh;
+        video->functionPointer->SAD_MB_HalfPel[2] = &SAD_MB_HP_HTFM_Collectyh;
+        video->functionPointer->SAD_MB_HalfPel[3] = &SAD_MB_HP_HTFM_Collectxhyh;
+        video->sad_extra_info = (void*)(htfm_stat);
+        offset = htfm_stat->offsetArray;
+        offset2 = htfm_stat->offsetRef;
+    }
+    else
+    {
+//      video->functionPointer->SAD_MB_PADDING = &SAD_MB_PADDING_HTFM;
+        video->functionPointer->SAD_Macroblock = &SAD_MB_HTFM;
+        video->functionPointer->SAD_MB_HalfPel[0] = NULL;
+        video->functionPointer->SAD_MB_HalfPel[1] = &SAD_MB_HP_HTFMxh;
+        video->functionPointer->SAD_MB_HalfPel[2] = &SAD_MB_HP_HTFMyh;
+        video->functionPointer->SAD_MB_HalfPel[3] = &SAD_MB_HP_HTFMxhyh;
+        video->sad_extra_info = (void*)(video->nrmlz_th);
+        offset = video->nrmlz_th + 16;
+        offset2 = video->nrmlz_th + 32;
+    }
+
+    offset[0] = 0;
+    offset[1] = lx2 + 2;
+    offset[2] = 2;
+    offset[3] = lx2;
+    offset[4] = lx + 1;
+    offset[5] = lx3 + 3;
+    offset[6] = lx + 3;
+    offset[7] = lx3 + 1;
+    offset[8] = lx;
+    offset[9] = lx3 + 2;
+    offset[10] = lx3 ;
+    offset[11] = lx + 2 ;
+    offset[12] = 1;
+    offset[13] = lx2 + 3;
+    offset[14] = lx2 + 1;
+    offset[15] = 3;
+
+    offset2[0] = 0;
+    offset2[1] = rx2 + 2;
+    offset2[2] = 2;
+    offset2[3] = rx2;
+    offset2[4] = rx + 1;
+    offset2[5] = rx3 + 3;
+    offset2[6] = rx + 3;
+    offset2[7] = rx3 + 1;
+    offset2[8] = rx;
+    offset2[9] = rx3 + 2;
+    offset2[10] = rx3 ;
+    offset2[11] = rx + 2 ;
+    offset2[12] = 1;
+    offset2[13] = rx2 + 3;
+    offset2[14] = rx2 + 1;
+    offset2[15] = 3;
+
+    return ;
+}
+
+void UpdateHTFM(VideoEncData *video, double *newvar, double *exp_lamda, HTFM_Stat *htfm_stat)
+{
+    if (htfm_stat->countbreak == 0)
+        htfm_stat->countbreak = 1;
+
+    newvar[0] = (double)(htfm_stat->abs_dif_mad_avg) / (htfm_stat->countbreak * 16.);
+
+    if (newvar[0] < 0.001)
+    {
+        newvar[0] = 0.001; /* to prevent floating overflow */
+    }
+    exp_lamda[0] =  1 / (newvar[0] * 1.4142136);
+    exp_lamda[1] = exp_lamda[0] * 1.5825;
+    exp_lamda[2] = exp_lamda[0] * 2.1750;
+    exp_lamda[3] = exp_lamda[0] * 3.5065;
+    exp_lamda[4] = exp_lamda[0] * 3.1436;
+    exp_lamda[5] = exp_lamda[0] * 3.5315;
+    exp_lamda[6] = exp_lamda[0] * 3.7449;
+    exp_lamda[7] = exp_lamda[0] * 4.5854;
+    exp_lamda[8] = exp_lamda[0] * 4.6191;
+    exp_lamda[9] = exp_lamda[0] * 5.4041;
+    exp_lamda[10] = exp_lamda[0] * 6.5974;
+    exp_lamda[11] = exp_lamda[0] * 10.5341;
+    exp_lamda[12] = exp_lamda[0] * 10.0719;
+    exp_lamda[13] = exp_lamda[0] * 12.0516;
+    exp_lamda[14] = exp_lamda[0] * 15.4552;
+
+    CalcThreshold(HTFM_Pf, exp_lamda, video->nrmlz_th);
+    return ;
+}
+
+
+void CalcThreshold(double pf, double exp_lamda[], Int nrmlz_th[])
+{
+    Int i;
+    double temp[15];
+    //  printf("\nLamda: ");
+
+    /* parametric PREMODELling */
+    for (i = 0; i < 15; i++)
+    {
+        //    printf("%g ",exp_lamda[i]);
+        if (pf < 0.5)
+            temp[i] = 1 / exp_lamda[i] * M4VENC_LOG(2 * pf);
+        else
+            temp[i] = -1 / exp_lamda[i] * M4VENC_LOG(2 * (1 - pf));
+    }
+
+    nrmlz_th[15] = 0;
+    for (i = 0; i < 15; i++)        /* scale upto no.pixels */
+        nrmlz_th[i] = (Int)(temp[i] * ((i + 1) << 4) + 0.5);
+
+    return ;
+}
+
+void    HTFMPrepareCurMB(VideoEncData *video, HTFM_Stat *htfm_stat, UChar *cur)
+{
+    void* tmp = (void*)(video->currYMB);
+    ULong *htfmMB = (ULong*)tmp;
+    UChar *ptr, byte;
+    Int *offset;
+    Int i;
+    ULong word;
+    Int width = video->currVop->width;
+
+    if (((Int)video->numVopsInGOP) % 30 == 1)
+    {
+        offset = htfm_stat->offsetArray;
+    }
+    else
+    {
+        offset = video->nrmlz_th + 16;
+    }
+
+    for (i = 0; i < 16; i++)
+    {
+        ptr = cur + offset[i];
+        word = ptr[0];
+        byte = ptr[4];
+        word |= (byte << 8);
+        byte = ptr[8];
+        word |= (byte << 16);
+        byte = ptr[12];
+        word |= (byte << 24);
+        *htfmMB++ = word;
+
+        word = *(ptr += (width << 2));
+        byte = ptr[4];
+        word |= (byte << 8);
+        byte = ptr[8];
+        word |= (byte << 16);
+        byte = ptr[12];
+        word |= (byte << 24);
+        *htfmMB++ = word;
+
+        word = *(ptr += (width << 2));
+        byte = ptr[4];
+        word |= (byte << 8);
+        byte = ptr[8];
+        word |= (byte << 16);
+        byte = ptr[12];
+        word |= (byte << 24);
+        *htfmMB++ = word;
+
+        word = *(ptr += (width << 2));
+        byte = ptr[4];
+        word |= (byte << 8);
+        byte = ptr[8];
+        word |= (byte << 16);
+        byte = ptr[12];
+        word |= (byte << 24);
+        *htfmMB++ = word;
+    }
+
+    return ;
+}
+
+
+#endif
+
+void    PrepareCurMB(VideoEncData *video, UChar *cur)
+{
+    void* tmp = (void*)(video->currYMB);
+    ULong *currYMB = (ULong*)tmp;
+    Int i;
+    Int width = video->currVop->width;
+
+    cur -= width;
+
+    for (i = 0; i < 16; i++)
+    {
+        *currYMB++ = *((ULong*)(cur += width));
+        *currYMB++ = *((ULong*)(cur + 4));
+        *currYMB++ = *((ULong*)(cur + 8));
+        *currYMB++ = *((ULong*)(cur + 12));
+    }
+
+    return ;
+}
+
+
+/*==================================================================
+    Function:   MBMotionSearch
+    Date:       09/06/2000
+    Purpose:    Perform motion estimation for a macroblock.
+                Find 1MV and 4MVs in half-pels resolutions.
+                Using ST1 algorithm provided by Chalidabhongse and Kuo
+                CSVT March'98.
+
+==================================================================*/
+
+void MBMotionSearch(VideoEncData *video, UChar *cur, UChar *best_cand[],
+                    Int i0, Int j0, Int type_pred, Int FS_en, Int *hp_guess)
+{
+    Vol *currVol = video->vol[video->currLayer];
+    UChar *ref, *cand, *ncand = NULL, *cur8;
+    void *extra_info = video->sad_extra_info;
+    Int mbnum = video->mbnum;
+    Int width = video->currVop->width; /* 6/12/01, must be multiple of 16 */
+    Int height = video->currVop->height;
+    MOT **mot = video->mot;
+    UChar use_4mv = video->encParams->MV8x8_Enabled;
+    UChar h263_mode = video->encParams->H263_Enabled;
+    Int(*SAD_Macroblock)(UChar*, UChar*, Int, void*) = video->functionPointer->SAD_Macroblock;
+    Int(*SAD_Block)(UChar*, UChar*, Int, Int, void*) = video->functionPointer->SAD_Block;
+    VideoEncParams *encParams = video->encParams;
+    Int range = encParams->SearchRange;
+
+    Int lx = video->currVop->pitch; /* padding */
+    Int comp;
+    Int i, j, imin, jmin, ilow, ihigh, jlow, jhigh, iorg, jorg;
+    Int d, dmin, dn[9];
+#if (ZERO_MV_PREF==1)   /* compute (0,0) MV at the end */
+    Int d0;
+#endif
+    Int k;
+    Int mvx[5], mvy[5], imin0, jmin0;
+    Int num_can, center_again;
+    Int last_loc, new_loc = 0;
+    Int step, max_step = range >> 1;
+    Int next;
+
+    ref = video->forwardRefVop->yChan; /* origin of actual frame */
+
+    cur = video->currYMB; /* use smaller memory space for current MB */
+
+    /*  find limit of the search (adjusting search range)*/
+
+    if (!h263_mode)
+    {
+        ilow = i0 - range;
+        if (ilow < -15)
+            ilow = -15;
+        ihigh = i0 + range - 1;
+        if (ihigh > width - 1)
+            ihigh = width - 1;
+        jlow = j0 - range;
+        if (jlow < -15)
+            jlow = -15;
+        jhigh = j0 + range - 1;
+        if (jhigh > height - 1)
+            jhigh = height - 1;
+    }
+    else
+    {
+        ilow = i0 - range;
+        if (ilow < 0)
+            ilow = 0;
+        ihigh = i0 + range - 1;
+        if (ihigh > width - 16)
+            ihigh = width - 16;
+        jlow = j0 - range;
+        if (jlow < 0)
+            jlow = 0;
+        jhigh = j0 + range - 1;
+        if (jhigh > height - 16)
+            jhigh = height - 16;
+    }
+
+    imin = i0;
+    jmin = j0; /* needed for fullsearch */
+    ncand = ref + imin + jmin * lx;
+
+    /* for first row of MB, fullsearch can be used */
+    if (FS_en)
+    {
+        *hp_guess = 0; /* no guess for fast half-pel */
+
+        dmin =  fullsearch(video, currVol, ref, cur, &imin, &jmin, ilow, ihigh, jlow, jhigh);
+
+        ncand = ref + imin + jmin * lx;
+
+        mot[mbnum][0].sad = dmin;
+        mot[mbnum][0].x = (imin - i0) << 1;
+        mot[mbnum][0].y = (jmin - j0) << 1;
+        imin0 = imin << 1;  /* 16x16 MV in half-pel resolution */
+        jmin0 = jmin << 1;
+        best_cand[0] = ncand;
+    }
+    else
+    {   /* 4/7/01, modified this testing for fullsearch the top row to only upto (0,3) MB */
+        /*            upto 30% complexity saving with the same complexity */
+        if (video->forwardRefVop->predictionType == I_VOP && j0 == 0 && i0 <= 64 && type_pred != 1)
+        {
+            *hp_guess = 0; /* no guess for fast half-pel */
+            dmin =  fullsearch(video, currVol, ref, cur, &imin, &jmin, ilow, ihigh, jlow, jhigh);
+            ncand = ref + imin + jmin * lx;
+        }
+        else
+        {
+            /************** initialize candidate **************************/
+            /* find initial motion vector */
+            CandidateSelection(mvx, mvy, &num_can, i0 >> 4, j0 >> 4, video, type_pred);
+
+            dmin = 65535;
+
+            /* check if all are equal */
+            if (num_can == ALL_CAND_EQUAL)
+            {
+                i = i0 + mvx[0];
+                j = j0 + mvy[0];
+
+                if (i >= ilow && i <= ihigh && j >= jlow && j <= jhigh)
+                {
+                    cand = ref + i + j * lx;
+
+                    d = (*SAD_Macroblock)(cand, cur, (dmin << 16) | lx, extra_info);
+
+                    if (d < dmin)
+                    {
+                        dmin = d;
+                        imin = i;
+                        jmin = j;
+                        ncand = cand;
+                    }
+                }
+            }
+            else
+            {
+                /************** evaluate unique candidates **********************/
+                for (k = 0; k < num_can; k++)
+                {
+                    i = i0 + mvx[k];
+                    j = j0 + mvy[k];
+
+                    if (i >= ilow && i <= ihigh && j >= jlow && j <= jhigh)
+                    {
+                        cand = ref + i + j * lx;
+                        d = (*SAD_Macroblock)(cand, cur, (dmin << 16) | lx, extra_info);
+
+                        if (d < dmin)
+                        {
+                            dmin = d;
+                            imin = i;
+                            jmin = j;
+                            ncand = cand;
+                        }
+                        else if ((d == dmin) && PV_ABS(mvx[k]) + PV_ABS(mvy[k]) < PV_ABS(i0 - imin) + PV_ABS(j0 - jmin))
+                        {
+                            dmin = d;
+                            imin = i;
+                            jmin = j;
+                            ncand = cand;
+                        }
+                    }
+                }
+            }
+            if (num_can == 0 || dmin == 65535) /* no candidate selected */
+            {
+                ncand = ref + i0 + j0 * lx; /* use (0,0) MV as initial value */
+                mot[mbnum][7].sad = dmin = (*SAD_Macroblock)(ncand, cur, (65535 << 16) | lx, extra_info);
+#if (ZERO_MV_PREF==1)   /* compute (0,0) MV at the end */
+                d0 = dmin;
+#endif
+                imin = i0;
+                jmin = j0;
+            }
+
+#if (ZERO_MV_PREF==0)  /*  COMPUTE ZERO VECTOR FIRST !!!!!*/
+            dmin -= PREF_NULL_VEC;
+#endif
+
+            /******************* local refinement ***************************/
+            center_again = 0;
+            last_loc = new_loc = 0;
+            //          ncand = ref + jmin*lx + imin;  /* center of the search */
+            step = 0;
+            dn[0] = dmin;
+            while (!center_again && step <= max_step)
+            {
+
+                MoveNeighborSAD(dn, last_loc);
+
+                center_again = 1;
+                i = imin;
+                j = jmin - 1;
+                cand = ref + i + j * lx;
+
+                /*  starting from [0,-1] */
+                /* spiral check one step at a time*/
+                for (k = 2; k <= 8; k += 2)
+                {
+                    if (!tab_exclude[last_loc][k]) /* exclude last step computation */
+                    {       /* not already computed */
+                        if (i >= ilow && i <= ihigh && j >= jlow && j <= jhigh)
+                        {
+                            d = (*SAD_Macroblock)(cand, cur, (dmin << 16) | lx, extra_info);
+                            dn[k] = d; /* keep it for half pel use */
+
+                            if (d < dmin)
+                            {
+                                ncand = cand;
+                                dmin = d;
+                                imin = i;
+                                jmin = j;
+                                center_again = 0;
+                                new_loc = k;
+                            }
+                            else if ((d == dmin) && PV_ABS(i0 - i) + PV_ABS(j0 - j) < PV_ABS(i0 - imin) + PV_ABS(j0 - jmin))
+                            {
+                                ncand = cand;
+                                imin = i;
+                                jmin = j;
+                                center_again = 0;
+                                new_loc = k;
+                            }
+                        }
+                    }
+                    if (k == 8)  /* end side search*/
+                    {
+                        if (!center_again)
+                        {
+                            k = -1; /* start diagonal search */
+                            cand -= lx;
+                            j--;
+                        }
+                    }
+                    else
+                    {
+                        next = refine_next[k][0];
+                        i += next;
+                        cand += next;
+                        next = refine_next[k][1];
+                        j += next;
+                        cand += lx * next;
+                    }
+                }
+                last_loc = new_loc;
+                step ++;
+            }
+            if (!center_again)
+                MoveNeighborSAD(dn, last_loc);
+
+            *hp_guess = FindMin(dn);
+
+        }
+
+#if (ZERO_MV_PREF==1)   /* compute (0,0) MV at the end */
+        if (d0 - PREF_NULL_VEC < dmin)
+        {
+            ncand = ref + i0 + j0 * lx;
+            dmin = d0;
+            imin = i0;
+            jmin = j0;
+        }
+#endif
+        mot[mbnum][0].sad = dmin;
+        mot[mbnum][0].x = (imin - i0) << 1;
+        mot[mbnum][0].y = (jmin - j0) << 1;
+        imin0 = imin << 1;  /* 16x16 MV in half-pel resolution */
+        jmin0 = jmin << 1;
+        best_cand[0] = ncand;
+    }
+    /* imin and jmin is the best 1 MV */
+#ifndef NO_INTER4V
+    /*******************  Find 4 motion vectors ****************************/
+    if (use_4mv && !h263_mode)
+    {
+#ifdef _SAD_STAT
+        num_Blk += 4;
+#endif
+        /* starting from the best 1MV */
+        //offset = imin + jmin*lx;
+        iorg = i0;
+        jorg = j0;
+
+        for (comp = 0; comp < 4; comp++)
+        {
+            i0 = iorg + ((comp & 1) << 3);
+            j0 = jorg + ((comp & 2) << 2);
+
+            imin = (imin0 >> 1) + ((comp & 1) << 3);    /* starting point from 16x16 MV */
+            jmin = (jmin0 >> 1) + ((comp & 2) << 2);
+            ncand = ref + imin + jmin * lx;
+
+            cur8 = cur + ((comp & 1) << 3) + (((comp & 2) << 2) << 4) ; /* 11/30/05, smaller cache */
+
+            /*  find limit of the search (adjusting search range)*/
+            ilow = i0 - range;
+            ihigh = i0 + range - 1 ;/* 4/9/01 */
+            if (ilow < -15)
+                ilow = -15;
+            if (ihigh > width - 1)
+                ihigh = width - 1;
+            jlow = j0 - range;
+            jhigh = j0 + range - 1 ;/* 4/9/01 */
+            if (jlow < -15)
+                jlow = -15;
+            if (jhigh > height - 1)
+                jhigh = height - 1;
+
+            SAD_Block = video->functionPointer->SAD_Block;
+
+            if (FS_en)  /* fullsearch enable, center around 16x16 MV */
+            {
+                dmin =  fullsearchBlk(video, currVol, ncand, cur8, &imin, &jmin, ilow, ihigh, jlow, jhigh, range);
+                ncand = ref + imin + jmin * lx;
+
+                mot[mbnum][comp+1].sad = dmin;
+                mot[mbnum][comp+1].x = (imin - i0) << 1;
+                mot[mbnum][comp+1].y = (jmin - j0) << 1;
+                best_cand[comp+1] = ncand;
+            }
+            else    /* no fullsearch, do local search */
+            {
+                /* starting point from 16x16 */
+                dmin = (*SAD_Block)(ncand, cur8, 65536, lx, extra_info);
+
+                /******************* local refinement ***************************/
+                center_again = 0;
+                last_loc = 0;
+
+                while (!center_again)
+                {
+                    center_again = 1;
+                    i = imin;
+                    j = jmin - 1;
+                    cand = ref + i + j * lx;
+
+                    /*  starting from [0,-1] */
+                    /* spiral check one step at a time*/
+                    for (k = 2; k <= 8; k += 2)
+                    {
+                        if (!tab_exclude[last_loc][k]) /* exclude last step computation */
+                        {       /* not already computed */
+                            if (i >= ilow && i <= ihigh && j >= jlow && j <= jhigh)
+                            {
+                                d = (*SAD_Block)(cand, cur8, dmin, lx, extra_info);
+
+                                if (d < dmin)
+                                {
+                                    ncand = cand;
+                                    dmin = d;
+                                    imin = i;
+                                    jmin = j;
+                                    center_again = 0;
+                                    new_loc = k;
+                                }
+                                else if ((d == dmin) &&
+                                         PV_ABS(i0 - i) + PV_ABS(j0 - j) < PV_ABS(i0 - imin) + PV_ABS(j0 - jmin))
+                                {
+                                    ncand = cand;
+                                    imin = i;
+                                    jmin = j;
+                                    center_again = 0;
+                                    new_loc = k;
+                                }
+                            }
+                        }
+                        if (k == 8)  /* end side search*/
+                        {
+                            if (!center_again)
+                            {
+                                k = -1; /* start diagonal search */
+                                if (j <= height - 1 && j > 0)   cand -= lx;
+                                j--;
+                            }
+                        }
+                        else
+                        {
+                            next = refine_next[k][0];
+                            cand += next;
+                            i += next;
+                            next = refine_next[k][1];
+                            cand += lx * next;
+                            j += next;
+                        }
+                    }
+                    last_loc = new_loc;
+                }
+                mot[mbnum][comp+1].sad = dmin;
+                mot[mbnum][comp+1].x = (imin - i0) << 1;
+                mot[mbnum][comp+1].y = (jmin - j0) << 1;
+                best_cand[comp+1] = ncand;
+            }
+            /********************************************/
+        }
+    }
+    else
+#endif  /* NO_INTER4V */
+    {
+        mot[mbnum][1].sad = mot[mbnum][2].sad = mot[mbnum][3].sad = mot[mbnum][4].sad = (dmin + 2) >> 2;
+        mot[mbnum][1].x = mot[mbnum][2].x = mot[mbnum][3].x = mot[mbnum][4].x = mot[mbnum][0].x;
+        mot[mbnum][1].y = mot[mbnum][2].y = mot[mbnum][3].y = mot[mbnum][4].y = mot[mbnum][0].y;
+        best_cand[1] = best_cand[2] = best_cand[3] = best_cand[4] = ncand;
+
+    }
+    return ;
+}
+
+
+/*===============================================================================
+    Function:   fullsearch
+    Date:       09/16/2000
+    Purpose:    Perform full-search motion estimation over the range of search
+                region in a spiral-outward manner.
+    Input/Output:   VideoEncData, current Vol, previou Vop, pointer to the left corner of
+                current VOP, current coord (also output), boundaries.
+===============================================================================*/
+
+Int fullsearch(VideoEncData *video, Vol *currVol, UChar *prev, UChar *cur,
+               Int *imin, Int *jmin, Int ilow, Int ihigh, Int jlow, Int jhigh)
+{
+    Int range = video->encParams->SearchRange;
+    UChar *cand;
+    Int i, j, k, l;
+    Int d, dmin;
+    Int i0 = *imin; /* current position */
+    Int j0 = *jmin;
+    Int(*SAD_Macroblock)(UChar*, UChar*, Int, void*) = video->functionPointer->SAD_Macroblock;
+    void *extra_info = video->sad_extra_info;
+//  UChar h263_mode = video->encParams->H263_Enabled;
+    Int lx = video->currVop->pitch; /* with padding */
+
+    Int offset = i0 + j0 * lx;
+
+    OSCL_UNUSED_ARG(currVol);
+
+    cand = prev + offset;
+
+    dmin  = (*SAD_Macroblock)(cand, cur, (65535 << 16) | lx, (void*)extra_info) - PREF_NULL_VEC;
+
+    /* perform spiral search */
+    for (k = 1; k <= range; k++)
+    {
+
+        i = i0 - k;
+        j = j0 - k;
+
+        cand = prev + i + j * lx;
+
+        for (l = 0; l < 8*k; l++)
+        {
+            /* no need for boundary checking again */
+            if (i >= ilow && i <= ihigh && j >= jlow && j <= jhigh)
+            {
+                d = (*SAD_Macroblock)(cand, cur, (dmin << 16) | lx, (void*)extra_info);
+
+                if (d < dmin)
+                {
+                    dmin = d;
+                    *imin = i;
+                    *jmin = j;
+                }
+                else if ((d == dmin) && PV_ABS(i0 - i) + PV_ABS(j0 - j) < PV_ABS(i0 - *imin) + PV_ABS(j0 - *jmin))
+                {
+                    dmin = d;
+                    *imin = i;
+                    *jmin = j;
+                }
+            }
+
+            if (l < (k << 1))
+            {
+                i++;
+                cand++;
+            }
+            else if (l < (k << 2))
+            {
+                j++;
+                cand += lx;
+            }
+            else if (l < ((k << 2) + (k << 1)))
+            {
+                i--;
+                cand--;
+            }
+            else
+            {
+                j--;
+                cand -= lx;
+            }
+        }
+    }
+
+    return dmin;
+}
+
+#ifndef NO_INTER4V
+/*===============================================================================
+    Function:   fullsearchBlk
+    Date:       01/9/2001
+    Purpose:    Perform full-search motion estimation of an 8x8 block over the range
+                of search region in a spiral-outward manner centered at the 16x16 MV.
+    Input/Output:   VideoEncData, MB coordinate, pointer to the initial MV on the
+                reference, pointer to coor of current block, search range.
+===============================================================================*/
+Int fullsearchBlk(VideoEncData *video, Vol *currVol, UChar *cent, UChar *cur,
+                  Int *imin, Int *jmin, Int ilow, Int ihigh, Int jlow, Int jhigh, Int range)
+{
+    UChar *cand, *ref;
+    Int i, j, k, l, istart, jstart;
+    Int d, dmin;
+    Int lx = video->currVop->pitch; /* with padding */
+    Int(*SAD_Block)(UChar*, UChar*, Int, Int, void*) = video->functionPointer->SAD_Block;
+    void *extra_info = video->sad_extra_info;
+
+    OSCL_UNUSED_ARG(currVol);
+
+    /* starting point centered at 16x16 MV */
+    ref = cent;
+    istart = *imin;
+    jstart = *jmin;
+
+    dmin = (*SAD_Block)(ref, cur, 65536, lx, (void*)extra_info);
+
+    cand = ref;
+    /* perform spiral search */
+    for (k = 1; k <= range; k++)
+    {
+
+        i = istart - k;
+        j = jstart - k;
+        cand -= (lx + 1);  /* candidate region */
+
+        for (l = 0; l < 8*k; l++)
+        {
+            /* no need for boundary checking again */
+            if (i >= ilow && i <= ihigh && j >= jlow && j <= jhigh)
+            {
+                d = (*SAD_Block)(cand, cur, dmin, lx, (void*)extra_info);
+
+                if (d < dmin)
+                {
+                    dmin = d;
+                    *imin = i;
+                    *jmin = j;
+                }
+                else if ((d == dmin) &&
+                         PV_ABS(istart - i) + PV_ABS(jstart - j) < PV_ABS(istart - *imin) + PV_ABS(jstart - *jmin))
+                {
+                    dmin = d;
+                    *imin = i;
+                    *jmin = j;
+                }
+            }
+
+            if (l < (k << 1))
+            {
+                i++;
+                cand++;
+            }
+            else if (l < (k << 2))
+            {
+                j++;
+                cand += lx;
+            }
+            else if (l < ((k << 2) + (k << 1)))
+            {
+                i--;
+                cand--;
+            }
+            else
+            {
+                j--;
+                cand -= lx;
+            }
+        }
+    }
+
+    return dmin;
+}
+#endif /* NO_INTER4V */
+
+/*===============================================================================
+    Function:   CandidateSelection
+    Date:       09/16/2000
+    Purpose:    Fill up the list of candidate using spatio-temporal correlation
+                among neighboring blocks.
+    Input/Output:   type_pred = 0: first pass, 1: second pass, or no SCD
+    Modified:    09/23/01, get rid of redundant candidates before passing back.
+===============================================================================*/
+
+void CandidateSelection(Int *mvx, Int *mvy, Int *num_can, Int imb, Int jmb,
+                        VideoEncData *video, Int type_pred)
+{
+    MOT **mot = video->mot;
+    MOT *pmot;
+    Int mbnum = video->mbnum;
+    Vol *currVol = video->vol[video->currLayer];
+    Int mbwidth = currVol->nMBPerRow;
+    Int mbheight = currVol->nMBPerCol;
+    Int i, j, same, num1;
+
+    *num_can = 0;
+
+    if (video->forwardRefVop->predictionType == P_VOP)
+    {
+        /* Spatio-Temporal Candidate (five candidates) */
+        if (type_pred == 0) /* first pass */
+        {
+            pmot = &mot[mbnum][0]; /* same coordinate previous frame */
+            mvx[(*num_can)] = (pmot->x) >> 1;
+            mvy[(*num_can)++] = (pmot->y) >> 1;
+            if (imb >= (mbwidth >> 1) && imb > 0)  /*left neighbor previous frame */
+            {
+                pmot = &mot[mbnum-1][0];
+                mvx[(*num_can)] = (pmot->x) >> 1;
+                mvy[(*num_can)++] = (pmot->y) >> 1;
+            }
+            else if (imb + 1 < mbwidth)   /*right neighbor previous frame */
+            {
+                pmot = &mot[mbnum+1][0];
+                mvx[(*num_can)] = (pmot->x) >> 1;
+                mvy[(*num_can)++] = (pmot->y) >> 1;
+            }
+
+            if (jmb < mbheight - 1)  /*bottom neighbor previous frame */
+            {
+                pmot = &mot[mbnum+mbwidth][0];
+                mvx[(*num_can)] = (pmot->x) >> 1;
+                mvy[(*num_can)++] = (pmot->y) >> 1;
+            }
+            else if (jmb > 0)   /*upper neighbor previous frame */
+            {
+                pmot = &mot[mbnum-mbwidth][0];
+                mvx[(*num_can)] = (pmot->x) >> 1;
+                mvy[(*num_can)++] = (pmot->y) >> 1;
+            }
+
+            if (imb > 0 && jmb > 0)  /* upper-left neighbor current frame*/
+            {
+                pmot = &mot[mbnum-mbwidth-1][0];
+                mvx[(*num_can)] = (pmot->x) >> 1;
+                mvy[(*num_can)++] = (pmot->y) >> 1;
+            }
+            if (jmb > 0 && imb < mbheight - 1)  /* upper right neighbor current frame*/
+            {
+                pmot = &mot[mbnum-mbwidth+1][0];
+                mvx[(*num_can)] = (pmot->x) >> 1;
+                mvy[(*num_can)++] = (pmot->y) >> 1;
+            }
+        }
+        else    /* second pass */
+            /* original ST1 algorithm */
+        {
+            pmot = &mot[mbnum][0]; /* same coordinate previous frame */
+            mvx[(*num_can)] = (pmot->x) >> 1;
+            mvy[(*num_can)++] = (pmot->y) >> 1;
+
+            if (imb > 0)  /*left neighbor current frame */
+            {
+                pmot = &mot[mbnum-1][0];
+                mvx[(*num_can)] = (pmot->x) >> 1;
+                mvy[(*num_can)++] = (pmot->y) >> 1;
+            }
+            if (jmb > 0)  /*upper neighbor current frame */
+            {
+                pmot = &mot[mbnum-mbwidth][0];
+                mvx[(*num_can)] = (pmot->x) >> 1;
+                mvy[(*num_can)++] = (pmot->y) >> 1;
+            }
+            if (imb < mbwidth - 1)  /*right neighbor previous frame */
+            {
+                pmot = &mot[mbnum+1][0];
+                mvx[(*num_can)] = (pmot->x) >> 1;
+                mvy[(*num_can)++] = (pmot->y) >> 1;
+            }
+            if (jmb < mbheight - 1)  /*bottom neighbor previous frame */
+            {
+                pmot = &mot[mbnum+mbwidth][0];
+                mvx[(*num_can)] = (pmot->x) >> 1;
+                mvy[(*num_can)++] = (pmot->y) >> 1;
+            }
+        }
+    }
+    else  /* only Spatial Candidate (four candidates)*/
+    {
+        if (type_pred == 0) /*first pass*/
+        {
+            if (imb > 1)  /* neighbor two blocks away to the left */
+            {
+                pmot = &mot[mbnum-2][0];
+                mvx[(*num_can)] = (pmot->x) >> 1;
+                mvy[(*num_can)++] = (pmot->y) >> 1;
+            }
+            if (imb > 0 && jmb > 0)  /* upper-left neighbor */
+            {
+                pmot = &mot[mbnum-mbwidth-1][0];
+                mvx[(*num_can)] = (pmot->x) >> 1;
+                mvy[(*num_can)++] = (pmot->y) >> 1;
+            }
+            if (jmb > 0 && imb < mbheight - 1)  /* upper right neighbor */
+            {
+                pmot = &mot[mbnum-mbwidth+1][0];
+                mvx[(*num_can)] = (pmot->x) >> 1;
+                mvy[(*num_can)++] = (pmot->y) >> 1;
+            }
+        }
+//#ifdef SCENE_CHANGE_DETECTION
+        /* second pass (ST2 algorithm)*/
+        else if (type_pred == 1) /* 4/7/01 */
+        {
+            if (imb > 0)  /*left neighbor current frame */
+            {
+                pmot = &mot[mbnum-1][0];
+                mvx[(*num_can)] = (pmot->x) >> 1;
+                mvy[(*num_can)++] = (pmot->y) >> 1;
+            }
+            if (jmb > 0)  /*upper neighbor current frame */
+            {
+                pmot = &mot[mbnum-mbwidth][0];
+                mvx[(*num_can)] = (pmot->x) >> 1;
+                mvy[(*num_can)++] = (pmot->y) >> 1;
+            }
+            if (imb < mbwidth - 1)  /*right neighbor current frame */
+            {
+                pmot = &mot[mbnum+1][0];
+                mvx[(*num_can)] = (pmot->x) >> 1;
+                mvy[(*num_can)++] = (pmot->y) >> 1;
+            }
+            if (jmb < mbheight - 1)  /*bottom neighbor current frame */
+            {
+                pmot = &mot[mbnum+mbwidth][0];
+                mvx[(*num_can)] = (pmot->x) >> 1;
+                mvy[(*num_can)++] = (pmot->y) >> 1;
+            }
+        }
+//#else
+        else /* original ST1 algorithm */
+        {
+            if (imb > 0)  /*left neighbor current frame */
+            {
+                pmot = &mot[mbnum-1][0];
+                mvx[(*num_can)] = (pmot->x) >> 1;
+                mvy[(*num_can)++] = (pmot->y) >> 1;
+
+                if (jmb > 0)  /*upper-left neighbor current frame */
+                {
+                    pmot = &mot[mbnum-mbwidth-1][0];
+                    mvx[(*num_can)] = (pmot->x) >> 1;
+                    mvy[(*num_can)++] = (pmot->y) >> 1;
+                }
+
+            }
+            if (jmb > 0)  /*upper neighbor current frame */
+            {
+                pmot = &mot[mbnum-mbwidth][0];
+                mvx[(*num_can)] = (pmot->x) >> 1;
+                mvy[(*num_can)++] = (pmot->y) >> 1;
+
+                if (imb < mbheight - 1)  /*upper-right neighbor current frame */
+                {
+                    pmot = &mot[mbnum-mbwidth+1][0];
+                    mvx[(*num_can)] = (pmot->x) >> 1;
+                    mvy[(*num_can)++] = (pmot->y) >> 1;
+                }
+            }
+        }
+//#endif
+    }
+
+    /* 3/23/01, remove redundant candidate (possible k-mean) */
+    num1 = *num_can;
+    *num_can = 1;
+    for (i = 1; i < num1; i++)
+    {
+        same = 0;
+        j = 0;
+        while (!same && j < *num_can)
+        {
+#if (CANDIDATE_DISTANCE==0)
+            if (mvx[i] == mvx[j] && mvy[i] == mvy[j])
+#else
+            // modified k-mean, 3/24/01, shouldn't be greater than 3
+            if (PV_ABS(mvx[i] - mvx[j]) + PV_ABS(mvy[i] - mvy[j]) < CANDIDATE_DISTANCE)
+#endif
+                same = 1;
+            j++;
+        }
+        if (!same)
+        {
+            mvx[*num_can] = mvx[i];
+            mvy[*num_can] = mvy[i];
+            (*num_can)++;
+        }
+    }
+
+#ifdef _SAD_STAT
+    num_cand += (*num_can);
+#endif
+
+    if (num1 == 5 && *num_can == 1)
+        *num_can = ALL_CAND_EQUAL; /* all are equal */
+
+    return ;
+}
+
+/*===========================================================================
+    Function:   RasterIntraUpdate
+    Date:       2/26/01
+    Purpose:    To raster-scan assign INTRA-update .
+                N macroblocks are updated (also was programmable).
+===========================================================================*/
+void RasterIntraUpdate(UChar *intraArray, UChar *Mode, Int totalMB, Int numRefresh)
+{
+    Int indx, i;
+
+    /* find the last refresh MB */
+    indx = 0;
+    while (intraArray[indx] == 1 && indx < totalMB)
+        indx++;
+
+    /* add more  */
+    for (i = 0; i < numRefresh && indx < totalMB; i++)
+    {
+        Mode[indx] = MODE_INTRA;
+        intraArray[indx++] = 1;
+    }
+
+    /* if read the end of frame, reset and loop around */
+    if (indx >= totalMB - 1)
+    {
+        ResetIntraUpdate(intraArray, totalMB);
+        indx = 0;
+        while (i < numRefresh && indx < totalMB)
+        {
+            intraArray[indx] = 1;
+            Mode[indx++] = MODE_INTRA;
+            i++;
+        }
+    }
+
+    return ;
+}
+
+/*===========================================================================
+    Function:   ResetIntraUpdate
+    Date:       11/28/00
+    Purpose:    Reset already intra updated flags to all zero
+===========================================================================*/
+
+void ResetIntraUpdate(UChar *intraArray, Int totalMB)
+{
+    M4VENC_MEMSET(intraArray, 0, sizeof(UChar)*totalMB);
+    return ;
+}
+
+/*===========================================================================
+    Function:   ResetIntraUpdateRegion
+    Date:       12/1/00
+    Purpose:    Reset already intra updated flags in one region to all zero
+===========================================================================*/
+void ResetIntraUpdateRegion(UChar *intraArray, Int start_i, Int rwidth,
+                            Int start_j, Int rheight, Int mbwidth, Int mbheight)
+{
+    Int indx, j;
+
+    if (start_i + rwidth >= mbwidth)
+        rwidth = mbwidth - start_i;
+    if (start_j + rheight >= mbheight)
+        rheight = mbheight - start_j;
+
+    for (j = start_j; j < start_j + rheight; j++)
+    {
+        indx = j * mbwidth;
+        M4VENC_MEMSET(intraArray + indx + start_i, 0, sizeof(UChar)*rwidth);
+    }
+
+    return ;
+}
+
+/*************************************************************
+    Function:   MoveNeighborSAD
+    Date:       3/27/01
+    Purpose:    Move neighboring SAD around when center has shifted
+*************************************************************/
+
+void MoveNeighborSAD(Int dn[], Int new_loc)
+{
+    Int tmp[9];
+    tmp[0] = dn[0];
+    tmp[1] = dn[1];
+    tmp[2] = dn[2];
+    tmp[3] = dn[3];
+    tmp[4] = dn[4];
+    tmp[5] = dn[5];
+    tmp[6] = dn[6];
+    tmp[7] = dn[7];
+    tmp[8] = dn[8];
+    dn[0] = dn[1] = dn[2] = dn[3] = dn[4] = dn[5] = dn[6] = dn[7] = dn[8] = 65536;
+
+    switch (new_loc)
+    {
+        case 0:
+            break;
+        case 1:
+            dn[4] = tmp[2];
+            dn[5] = tmp[0];
+            dn[6] = tmp[8];
+            break;
+        case 2:
+            dn[4] = tmp[3];
+            dn[5] = tmp[4];
+            dn[6] = tmp[0];
+            dn[7] = tmp[8];
+            dn[8] = tmp[1];
+            break;
+        case 3:
+            dn[6] = tmp[4];
+            dn[7] = tmp[0];
+            dn[8] = tmp[2];
+            break;
+        case 4:
+            dn[1] = tmp[2];
+            dn[2] = tmp[3];
+            dn[6] = tmp[5];
+            dn[7] = tmp[6];
+            dn[8] = tmp[0];
+            break;
+        case 5:
+            dn[1] = tmp[0];
+            dn[2] = tmp[4];
+            dn[8] = tmp[6];
+            break;
+        case 6:
+            dn[1] = tmp[8];
+            dn[2] = tmp[0];
+            dn[3] = tmp[4];
+            dn[4] = tmp[5];
+            dn[8] = tmp[7];
+            break;
+        case 7:
+            dn[2] = tmp[8];
+            dn[3] = tmp[0];
+            dn[4] = tmp[6];
+            break;
+        case 8:
+            dn[2] = tmp[1];
+            dn[3] = tmp[2];
+            dn[4] = tmp[0];
+            dn[5] = tmp[6];
+            dn[6] = tmp[7];
+            break;
+    }
+    dn[0] = tmp[new_loc];
+
+    return ;
+}
+
+/* 3/28/01, find minimal of dn[9] */
+
+Int FindMin(Int dn[])
+{
+    Int min, i;
+    Int dmin;
+
+    dmin = dn[1];
+    min = 1;
+    for (i = 2; i < 9; i++)
+    {
+        if (dn[i] < dmin)
+        {
+            dmin = dn[i];
+            min = i;
+        }
+    }
+
+    return min;
+}
+
+
+
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/mp4def.h b/media/libstagefright/codecs/m4v_h263/enc/src/mp4def.h
new file mode 100644
index 0000000..df1aa8b
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/mp4def.h
@@ -0,0 +1,228 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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 _PVDECDEF_H_
+#define _PVDECDEF_H_
+
+#include <stdlib.h>
+#include <string.h>
+
+// Redefine the int types
+typedef uint8_t uint8;
+typedef uint16_t uint16;
+typedef int16_t int16;
+typedef uint32_t uint32;
+typedef int32_t int32;
+typedef unsigned int uint;
+
+/********** platform dependent in-line assembly *****************************/
+
+/*************** Intel *****************/
+
+/*************** ARM *****************/
+/* for general ARM instruction. #define __ARM has to be defined in compiler set up.*/
+/* for DSP MUL */
+#ifdef __TARGET_FEATURE_DSPMUL
+#define _ARM_DSP_MUL
+#endif
+
+/* for Count Leading Zero instruction */
+#ifdef __TARGET_ARCH_5T
+#define _ARM_CLZ
+#endif
+#ifdef __TARGET_ARCH_5TE
+#define _ARM_CLZ
+#endif
+/****************************************************************************/
+
+#ifndef _PV_TYPES_
+#define _PV_TYPES_
+typedef unsigned char UChar;
+typedef char Char;
+typedef unsigned int UInt;
+typedef int Int;
+typedef unsigned short UShort;
+typedef short Short;
+typedef short int SInt;
+typedef unsigned int Bool;
+typedef unsigned long   ULong;
+typedef void Void;
+
+#define PV_CODEC_INIT       0
+#define PV_CODEC_STOP       1
+#define PV_CODEC_RUNNING    2
+#define PV_CODEC_RESET      3
+#endif
+
+typedef enum
+{
+    PV_SUCCESS,
+    PV_FAIL,
+    PV_EOS,             /* hit End_Of_Sequence     */
+    PV_MB_STUFFING,     /* hit Macroblock_Stuffing */
+    PV_END_OF_VOP,      /* hit End_of_Video_Object_Plane */
+    PV_END_OF_MB,       /* hit End_of_Macroblock */
+    PV_END_OF_BUF       /* hit End_of_Bitstream_Buffer */
+} PV_STATUS;
+
+typedef UChar PIXEL;
+//typedef Int MOT;   /* : "int" type runs faster on RISC machine */
+
+#define HTFM            /*  3/2/01, Hypothesis Test Fast Matching for early drop-out*/
+//#define _MOVE_INTERFACE
+
+//#define RANDOM_REFSELCODE
+
+/* handle the case of devision by zero in RC */
+#define MAD_MIN 1
+
+/* 4/11/01, if SSE or MMX, no HTFM, no SAD_HP_FLY */
+
+/* Code size reduction related Macros */
+#ifdef H263_ONLY
+#ifndef NO_RVLC
+#define NO_RVLC
+#endif
+#ifndef NO_MPEG_QUANT
+#define NO_MPEG_QUANT
+#endif
+#ifndef NO_INTER4V
+#define NO_INTER4V
+#endif
+#endif
+/**************************************/
+
+#define TRUE    1
+#define FALSE   0
+
+#define PV_ABS(x)       (((x)<0)? -(x) : (x))
+#define PV_SIGN(x)      (((x)<0)? -1 : 1)
+#define PV_SIGN0(a)     (((a)<0)? -1 : (((a)>0) ? 1 : 0))
+#define PV_MAX(a,b)     ((a)>(b)? (a):(b))
+#define PV_MIN(a,b)     ((a)<(b)? (a):(b))
+
+#define MODE_INTRA      0
+#define MODE_INTER      1
+#define MODE_INTRA_Q    2
+#define MODE_INTER_Q    3
+#define MODE_INTER4V    4
+#define MODE_SKIPPED    6
+
+#define I_VOP       0
+#define P_VOP       1
+#define B_VOP       2
+
+/*09/04/00 Add MB height and width */
+#define MB_WIDTH 16
+#define MB_HEIGHT 16
+
+#define VOP_BRIGHT_WHITEENC 255
+
+
+#define LUMINANCE_DC_TYPE   1
+#define CHROMINANCE_DC_TYPE 2
+
+#define EOB_CODE                        1
+#define EOB_CODE_LENGTH                32
+
+/* 11/30/98 */
+#define FoundRM     1   /* Resync Marker */
+#define FoundVSC    2   /* VOP_START_CODE. */
+#define FoundGSC    3   /* GROUP_START_CODE */
+#define FoundEOB    4   /* EOB_CODE */
+
+
+/* 05/08/2000, the error code returned from BitstreamShowBits() */
+#define BITSTREAM_ERROR_CODE 0xFFFFFFFF
+
+/* PacketVideo "absolution timestamp" object.  06/13/2000 */
+#define PVTS_START_CODE         0x01C4
+#define PVTS_START_CODE_LENGTH  32
+
+/* session layer and vop layer start codes */
+
+#define SESSION_START_CODE  0x01B0
+#define SESSION_END_CODE    0x01B1
+#define VISUAL_OBJECT_START_CODE 0x01B5
+
+#define VO_START_CODE           0x8
+#define VO_HEADER_LENGTH        32      /* lengtho of VO header: VO_START_CODE +  VO_ID */
+
+#define SOL_START_CODE          0x01BE
+#define SOL_START_CODE_LENGTH   32
+
+#define VOL_START_CODE 0x12
+#define VOL_START_CODE_LENGTH 28
+
+#define VOP_START_CODE 0x1B6
+#define VOP_START_CODE_LENGTH   32
+
+#define GROUP_START_CODE    0x01B3
+#define GROUP_START_CODE_LENGTH  32
+
+#define VOP_ID_CODE_LENGTH      5
+#define VOP_TEMP_REF_CODE_LENGTH    16
+
+#define USER_DATA_START_CODE        0x01B2
+#define USER_DATA_START_CODE_LENGTH 32
+
+#define START_CODE_PREFIX       0x01
+#define START_CODE_PREFIX_LENGTH    24
+
+#define SHORT_VIDEO_START_MARKER         0x20
+#define SHORT_VIDEO_START_MARKER_LENGTH  22
+#define SHORT_VIDEO_END_MARKER            0x3F
+#define GOB_RESYNC_MARKER         0x01
+#define GOB_RESYNC_MARKER_LENGTH  17
+
+/* motion and resync markers used in error resilient mode  */
+
+#define DC_MARKER                      438273
+#define DC_MARKER_LENGTH                19
+
+#define MOTION_MARKER_COMB             126977
+#define MOTION_MARKER_COMB_LENGTH       17
+
+#define MOTION_MARKER_SEP              81921
+#define MOTION_MARKER_SEP_LENGTH        17
+
+#define RESYNC_MARKER           1
+#define RESYNC_MARKER_LENGTH    17
+
+#define SPRITE_NOT_USED     0
+#define STATIC_SPRITE       1
+#define ONLINE_SPRITE       2
+#define GMC_SPRITE      3
+
+/* macroblock and block size */
+#define MB_SIZE 16
+#define NCOEFF_MB (MB_SIZE*MB_SIZE)
+#define B_SIZE 8
+#define NCOEFF_BLOCK (B_SIZE*B_SIZE)
+#define NCOEFF_Y NCOEFF_MB
+#define NCOEFF_U NCOEFF_BLOCK
+#define NCOEFF_V NCOEFF_BLOCK
+
+/* overrun buffer size  */
+#define DEFAULT_OVERRUN_BUFFER_SIZE 1000
+
+
+/* VLC decoding related definitions */
+#define VLC_ERROR   (-1)
+#define VLC_ESCAPE  7167
+
+#endif /* _PVDECDEF_H_ */
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/mp4enc_api.cpp b/media/libstagefright/codecs/m4v_h263/enc/src/mp4enc_api.cpp
new file mode 100644
index 0000000..946e3d0
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/mp4enc_api.cpp
@@ -0,0 +1,3278 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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 "mp4enc_lib.h"
+#include "bitstream_io.h"
+#include "rate_control.h"
+#include "m4venc_oscl.h"
+
+
+/* Inverse normal zigzag */
+const static Int zigzag_i[NCOEFF_BLOCK] =
+{
+    0, 1, 8, 16, 9, 2, 3, 10,
+    17, 24, 32, 25, 18, 11, 4, 5,
+    12, 19, 26, 33, 40, 48, 41, 34,
+    27, 20, 13, 6, 7, 14, 21, 28,
+    35, 42, 49, 56, 57, 50, 43, 36,
+    29, 22, 15, 23, 30, 37, 44, 51,
+    58, 59, 52, 45, 38, 31, 39, 46,
+    53, 60, 61, 54, 47, 55, 62, 63
+};
+
+/* INTRA */
+const static Int mpeg_iqmat_def[NCOEFF_BLOCK] =
+    {  8, 17, 18, 19, 21, 23, 25, 27,
+       17, 18, 19, 21, 23, 25, 27, 28,
+       20, 21, 22, 23, 24, 26, 28, 30,
+       21, 22, 23, 24, 26, 28, 30, 32,
+       22, 23, 24, 26, 28, 30, 32, 35,
+       23, 24, 26, 28, 30, 32, 35, 38,
+       25, 26, 28, 30, 32, 35, 38, 41,
+       27, 28, 30, 32, 35, 38, 41, 45
+    };
+
+/* INTER */
+const static Int mpeg_nqmat_def[64]  =
+    { 16, 17, 18, 19, 20, 21, 22, 23,
+      17, 18, 19, 20, 21, 22, 23, 24,
+      18, 19, 20, 21, 22, 23, 24, 25,
+      19, 20, 21, 22, 23, 24, 26, 27,
+      20, 21, 22, 23, 25, 26, 27, 28,
+      21, 22, 23, 24, 26, 27, 28, 30,
+      22, 23, 24, 26, 27, 28, 30, 31,
+      23, 24, 25, 27, 28, 30, 31, 33
+    };
+
+/* Profiles and levels */
+/* Simple profile(level 0-3) and Core profile (level 1-2) */
+/* {SPL0, SPL1, SPL2, SPL3, CPL1, CPL2, CPL2, CPL2} , SPL0: Simple Profile@Level0, CPL1: Core Profile@Level1, the last two are redundant for easy table manipulation */
+const static Int profile_level_code[8] =
+{
+    0x08, 0x01, 0x02, 0x03, 0x21, 0x22, 0x22, 0x22
+};
+
+const static Int profile_level_max_bitrate[8] =
+{
+    64000, 64000, 128000, 384000, 384000, 2000000, 2000000, 2000000
+};
+
+const static Int profile_level_max_packet_size[8] =
+{
+    2048, 2048, 4096, 8192, 4096, 8192, 8192, 8192
+};
+
+const static Int profile_level_max_mbsPerSec[8] =
+{
+    1485, 1485, 5940, 11880, 5940, 23760, 23760, 23760
+};
+
+const static Int profile_level_max_VBV_size[8] =
+{
+    163840, 163840, 655360, 655360, 262144, 1310720, 1310720, 1310720
+};
+
+
+/* Simple scalable profile (level 0-2) and Core scalable profile (level 1-3) */
+/* {SSPL0, SSPL1, SSPL2, SSPL2, CSPL1, CSPL2, CSPL3, CSPL3} , SSPL0: Simple Scalable Profile@Level0, CSPL1: Core Scalable Profile@Level1, the fourth is redundant for easy table manipulation */
+
+const static Int scalable_profile_level_code[8] =
+{
+    0x10, 0x11, 0x12, 0x12, 0xA1, 0xA2, 0xA3, 0xA3
+};
+
+const static Int scalable_profile_level_max_bitrate[8] =
+{
+    128000, 128000, 256000, 256000, 768000, 1500000, 4000000, 4000000
+};
+
+/* in bits */
+const static Int scalable_profile_level_max_packet_size[8] =
+{
+    2048, 2048, 4096, 4096, 4096, 4096, 16384, 16384
+};
+
+const static Int scalable_profile_level_max_mbsPerSec[8] =
+{
+    1485, 7425, 23760, 23760, 14850, 29700, 120960, 120960
+};
+
+const static Int scalable_profile_level_max_VBV_size[8] =
+{
+    163840, 655360, 655360, 655360, 1048576, 1310720, 1310720, 1310720
+};
+
+
+/* H263 profile 0 @ level 10-70 */
+const static Int   h263Level[8] = {0, 10, 20, 30, 40, 50, 60, 70};
+const static float rBR_bound[8] = {0, 1, 2, 6, 32, 64, 128, 256};
+const static float max_h263_framerate[2] = {(float)30000 / (float)2002,
+        (float)30000 / (float)1001
+                                           };
+const static Int   max_h263_width[2]  = {176, 352};
+const static Int   max_h263_height[2] = {144, 288};
+
+/* 6/2/2001, newly added functions to make PVEncodeVop more readable. */
+Int DetermineCodingLayer(VideoEncData *video, Int *nLayer, ULong modTime);
+void DetermineVopType(VideoEncData *video, Int currLayer);
+Int UpdateSkipNextFrame(VideoEncData *video, ULong *modTime, Int *size, PV_STATUS status);
+Bool SetProfile_BufferSize(VideoEncData *video, float delay, Int bInitialized);
+
+#ifdef PRINT_RC_INFO
+extern FILE *facct;
+extern int tiTotalNumBitsGenerated;
+extern int iStuffBits;
+#endif
+
+#ifdef PRINT_EC
+extern FILE *fec;
+#endif
+
+
+/* ======================================================================== */
+/*  Function : PVGetDefaultEncOption()                                      */
+/*  Date     : 12/12/2005                                                   */
+/*  Purpose  :                                                              */
+/*  In/out   :                                                              */
+/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
+/*  Modified :                                                              */
+/*                                                                          */
+/* ======================================================================== */
+
+OSCL_EXPORT_REF Bool PVGetDefaultEncOption(VideoEncOptions *encOption, Int encUseCase)
+{
+    VideoEncOptions defaultUseCase = {H263_MODE, profile_level_max_packet_size[SIMPLE_PROFILE_LEVEL0] >> 3,
+                                      SIMPLE_PROFILE_LEVEL0, PV_OFF, 0, 1, 1000, 33, {144, 144}, {176, 176}, {15, 30}, {64000, 128000},
+                                      {10, 10}, {12, 12}, {0, 0}, CBR_1, 0.0, PV_OFF, -1, 0, PV_OFF, 16, PV_OFF, 0, PV_ON
+                                     };
+
+    OSCL_UNUSED_ARG(encUseCase); // unused for now. Later we can add more defaults setting and use this
+    // argument to select the right one.
+    /* in the future we can create more meaningful use-cases */
+    if (encOption == NULL)
+    {
+        return PV_FALSE;
+    }
+
+    M4VENC_MEMCPY(encOption, &defaultUseCase, sizeof(VideoEncOptions));
+
+    return PV_TRUE;
+}
+
+/* ======================================================================== */
+/*  Function : PVInitVideoEncoder()                                         */
+/*  Date     : 08/22/2000                                                   */
+/*  Purpose  : Initialization of MP4 Encoder and VO bitstream               */
+/*  In/out   :                                                              */
+/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
+/*  Modified :  5/21/01, allocate only yChan and assign uChan & vChan   */
+/*              12/12/05, add encoding option as input argument         */
+/* ======================================================================== */
+OSCL_EXPORT_REF Bool    PVInitVideoEncoder(VideoEncControls *encoderControl, VideoEncOptions *encOption)
+{
+
+    Bool        status = PV_TRUE;
+    Int         nLayers, idx, i, j;
+    Int         max = 0, max_width = 0, max_height = 0, pitch, offset;
+    Int         size = 0, nTotalMB = 0;
+    VideoEncData *video;
+    Vol         *pVol;
+    VideoEncParams  *pEncParams;
+    Int         temp_w, temp_h, mbsPerSec;
+
+    /******************************************/
+    /*      this part use to be PVSetEncode() */
+    Int profile_table_index, *profile_level_table;
+    Int profile_level = encOption->profile_level;
+    Int PacketSize = encOption->packetSize << 3;
+    Int timeInc, timeIncRes;
+    float profile_max_framerate;
+    VideoEncParams *encParams;
+
+    if (encoderControl->videoEncoderData) /* this has been called */
+    {
+        if (encoderControl->videoEncoderInit) /* check if PVInitVideoEncoder() has been called  */
+        {
+            PVCleanUpVideoEncoder(encoderControl);
+            encoderControl->videoEncoderInit = 0;
+        }
+
+        M4VENC_FREE(encoderControl->videoEncoderData);
+        encoderControl->videoEncoderData = NULL;
+    }
+    encoderControl->videoEncoderInit = 0;   /* reset this value */
+
+    video = (VideoEncData *)M4VENC_MALLOC(sizeof(VideoEncData)); /* allocate memory for encData */
+
+    if (video == NULL)
+        return PV_FALSE;
+
+    M4VENC_MEMSET(video, 0, sizeof(VideoEncData));
+
+    encoderControl->videoEncoderData = (void *) video;         /* set up pointer in VideoEncData structure */
+
+    video->encParams = (VideoEncParams *)M4VENC_MALLOC(sizeof(VideoEncParams));
+    if (video->encParams == NULL)
+        goto CLEAN_UP;
+
+    M4VENC_MEMSET(video->encParams, 0, sizeof(VideoEncParams));
+
+    encParams = video->encParams;
+    encParams->nLayers = encOption->numLayers;
+
+    /* Check whether the input packetsize is valid (Note: put code here (before any memory allocation) in order to avoid memory leak */
+    if ((Int)profile_level < (Int)(SIMPLE_SCALABLE_PROFILE_LEVEL0))  /* non-scalable profile */
+    {
+        profile_level_table = (Int *)profile_level_max_packet_size;
+        profile_table_index = (Int)profile_level;
+        if (encParams->nLayers != 1)
+        {
+            goto CLEAN_UP;
+        }
+
+        encParams->LayerMaxMbsPerSec[0] = profile_level_max_mbsPerSec[profile_table_index];
+
+    }
+    else   /* scalable profile */
+    {
+        profile_level_table = (Int *)scalable_profile_level_max_packet_size;
+        profile_table_index = (Int)profile_level - (Int)(SIMPLE_SCALABLE_PROFILE_LEVEL0);
+        if (encParams->nLayers < 2)
+        {
+            goto CLEAN_UP;
+        }
+        for (i = 0; i < encParams->nLayers; i++)
+        {
+            encParams->LayerMaxMbsPerSec[i] = scalable_profile_level_max_mbsPerSec[profile_table_index];
+        }
+
+    }
+
+    /* cannot have zero size packet with these modes */
+    if (PacketSize == 0)
+    {
+        if (encOption->encMode == DATA_PARTITIONING_MODE)
+        {
+            goto CLEAN_UP;
+        }
+        if (encOption->encMode == COMBINE_MODE_WITH_ERR_RES)
+        {
+            encOption->encMode = COMBINE_MODE_NO_ERR_RES;
+        }
+    }
+
+    if (encOption->gobHeaderInterval == 0)
+    {
+        if (encOption->encMode == H263_MODE_WITH_ERR_RES)
+        {
+            encOption->encMode = H263_MODE;
+        }
+
+        if (encOption->encMode == SHORT_HEADER_WITH_ERR_RES)
+        {
+            encOption->encMode = SHORT_HEADER;
+        }
+    }
+
+    if (PacketSize > profile_level_table[profile_table_index])
+        goto CLEAN_UP;
+
+    /* Initial Defaults for all Modes */
+
+    encParams->SequenceStartCode = 1;
+    encParams->GOV_Enabled = 0;
+    encParams->RoundingType = 0;
+    encParams->IntraDCVlcThr = PV_MAX(PV_MIN(encOption->intraDCVlcTh, 7), 0);
+    encParams->ACDCPrediction = ((encOption->useACPred == PV_ON) ? TRUE : FALSE);
+    encParams->RC_Type = encOption->rcType;
+    encParams->Refresh = encOption->numIntraMB;
+    encParams->ResyncMarkerDisable = 0; /* Enable Resync Marker */
+
+    for (i = 0; i < encOption->numLayers; i++)
+    {
+#ifdef NO_MPEG_QUANT
+        encParams->QuantType[i] = 0;
+#else
+        encParams->QuantType[i] = encOption->quantType[i];      /* H263 */
+#endif
+        if (encOption->pQuant[i] >= 1 && encOption->pQuant[i] <= 31)
+        {
+            encParams->InitQuantPvop[i] = encOption->pQuant[i];
+        }
+        else
+        {
+            goto CLEAN_UP;
+        }
+        if (encOption->iQuant[i] >= 1 && encOption->iQuant[i] <= 31)
+        {
+            encParams->InitQuantIvop[i] = encOption->iQuant[i];
+        }
+        else
+        {
+            goto CLEAN_UP;
+        }
+    }
+
+    encParams->HalfPel_Enabled = 1;
+    encParams->SearchRange = encOption->searchRange; /* 4/16/2001 */
+    encParams->FullSearch_Enabled = 0;
+#ifdef NO_INTER4V
+    encParams->MV8x8_Enabled = 0;
+#else
+    encParams->MV8x8_Enabled = 0;// comment out for now!! encOption->mv8x8Enable;
+#endif
+    encParams->H263_Enabled = 0;
+    encParams->GOB_Header_Interval = 0; // need to be reset to 0
+    encParams->IntraPeriod = encOption->intraPeriod;    /* Intra update period update default*/
+    encParams->SceneChange_Det = encOption->sceneDetect;
+    encParams->FineFrameSkip_Enabled = 0;
+    encParams->NoFrameSkip_Enabled = encOption->noFrameSkipped;
+    encParams->NoPreSkip_Enabled = encOption->noFrameSkipped;
+    encParams->GetVolHeader[0] = 0;
+    encParams->GetVolHeader[1] = 0;
+    encParams->ResyncPacketsize = encOption->packetSize << 3;
+    encParams->LayerMaxBitRate[0] = 0;
+    encParams->LayerMaxBitRate[1] = 0;
+    encParams->LayerMaxFrameRate[0] = (float)0.0;
+    encParams->LayerMaxFrameRate[1] = (float)0.0;
+    encParams->VBV_delay = encOption->vbvDelay;  /* 2sec VBV buffer size */
+
+    switch (encOption->encMode)
+    {
+
+        case SHORT_HEADER:
+        case SHORT_HEADER_WITH_ERR_RES:
+
+            /* From Table 6-26 */
+            encParams->nLayers = 1;
+            encParams->QuantType[0] = 0;    /*H263 */
+            encParams->ResyncMarkerDisable = 1; /* Disable Resync Marker */
+            encParams->DataPartitioning = 0; /* Combined Mode */
+            encParams->ReversibleVLC = 0;   /* Disable RVLC */
+            encParams->RoundingType = 0;
+            encParams->IntraDCVlcThr = 7;   /* use_intra_dc_vlc = 0 */
+            encParams->MV8x8_Enabled = 0;
+
+            encParams->GOB_Header_Interval = encOption->gobHeaderInterval;
+            encParams->H263_Enabled = 2;
+            encParams->GOV_Enabled = 0;
+            encParams->TimeIncrementRes = 30000;        /* timeIncrementRes for H263 */
+            break;
+
+        case H263_MODE:
+        case H263_MODE_WITH_ERR_RES:
+
+            /* From Table 6-26 */
+            encParams->nLayers = 1;
+            encParams->QuantType[0] = 0;    /*H263 */
+            encParams->ResyncMarkerDisable = 1; /* Disable Resync Marker */
+            encParams->DataPartitioning = 0; /* Combined Mode */
+            encParams->ReversibleVLC = 0;   /* Disable RVLC */
+            encParams->RoundingType = 0;
+            encParams->IntraDCVlcThr = 7;   /* use_intra_dc_vlc = 0 */
+            encParams->MV8x8_Enabled = 0;
+
+            encParams->H263_Enabled = 1;
+            encParams->GOV_Enabled = 0;
+            encParams->TimeIncrementRes = 30000;        /* timeIncrementRes for H263 */
+
+            break;
+#ifndef H263_ONLY
+        case DATA_PARTITIONING_MODE:
+
+            encParams->DataPartitioning = 1;        /* Base Layer Data Partitioning */
+            encParams->ResyncMarkerDisable = 0; /* Resync Marker */
+#ifdef NO_RVLC
+            encParams->ReversibleVLC = 0;
+#else
+            encParams->ReversibleVLC = (encOption->rvlcEnable == PV_ON); /* RVLC when Data Partitioning */
+#endif
+            encParams->ResyncPacketsize = PacketSize;
+            break;
+
+        case COMBINE_MODE_WITH_ERR_RES:
+
+            encParams->DataPartitioning = 0;        /* Combined Mode */
+            encParams->ResyncMarkerDisable = 0; /* Resync Marker */
+            encParams->ReversibleVLC = 0;           /* No RVLC */
+            encParams->ResyncPacketsize = PacketSize;
+            break;
+
+        case COMBINE_MODE_NO_ERR_RES:
+
+            encParams->DataPartitioning = 0;        /* Combined Mode */
+            encParams->ResyncMarkerDisable = 1; /* Disable Resync Marker */
+            encParams->ReversibleVLC = 0;           /* No RVLC */
+            break;
+#endif
+        default:
+            goto CLEAN_UP;
+    }
+    /* Set the constraints (maximum values) according to the input profile and level */
+    /* Note that profile_table_index is already figured out above */
+
+    /* base layer */
+    encParams->profile_table_index    = profile_table_index; /* Used to limit the profile and level in SetProfile_BufferSize() */
+
+    /* check timeIncRes */
+    timeIncRes = encOption->timeIncRes;
+    timeInc = encOption->tickPerSrc;
+
+    if ((timeIncRes >= 1) && (timeIncRes <= 65536) && (timeInc < timeIncRes) && (timeInc != 0))
+    {
+        if (!encParams->H263_Enabled)
+        {
+            encParams->TimeIncrementRes = timeIncRes;
+        }
+        else
+        {
+            encParams->TimeIncrementRes = 30000;
+//          video->FrameRate = 30000/(float)1001; /* fix it to 29.97 fps */
+        }
+        video->FrameRate = timeIncRes / ((float)timeInc);
+    }
+    else
+    {
+        goto CLEAN_UP;
+    }
+
+    /* check frame dimension */
+    if (encParams->H263_Enabled)
+    {
+        switch (encOption->encWidth[0])
+        {
+            case 128:
+                if (encOption->encHeight[0] != 96) /* source_format = 1 */
+                    goto CLEAN_UP;
+                break;
+            case 176:
+                if (encOption->encHeight[0] != 144) /* source_format = 2 */
+                    goto CLEAN_UP;
+                break;
+            case 352:
+                if (encOption->encHeight[0] != 288) /* source_format = 2 */
+                    goto CLEAN_UP;
+                break;
+
+            case 704:
+                if (encOption->encHeight[0] != 576) /* source_format = 2 */
+                    goto CLEAN_UP;
+                break;
+            case 1408:
+                if (encOption->encHeight[0] != 1152) /* source_format = 2 */
+                    goto CLEAN_UP;
+                break;
+
+            default:
+                goto CLEAN_UP;
+        }
+    }
+    for (i = 0; i < encParams->nLayers; i++)
+    {
+        encParams->LayerHeight[i] = encOption->encHeight[i];
+        encParams->LayerWidth[i] = encOption->encWidth[i];
+    }
+
+    /* check frame rate */
+    for (i = 0; i < encParams->nLayers; i++)
+    {
+        encParams->LayerFrameRate[i] = encOption->encFrameRate[i];
+    }
+
+    if (encParams->nLayers > 1)
+    {
+        if (encOption->encFrameRate[0] == encOption->encFrameRate[1] ||
+                encOption->encFrameRate[0] == 0. || encOption->encFrameRate[1] == 0.) /* 7/31/03 */
+            goto CLEAN_UP;
+    }
+    /* set max frame rate */
+    for (i = 0; i < encParams->nLayers; i++)
+    {
+
+        /* Make sure the maximum framerate is consistent with the given profile and level */
+        nTotalMB = ((encParams->LayerWidth[i] + 15) / 16) * ((encParams->LayerHeight[i] + 15) / 16);
+
+        if (nTotalMB > 0)
+            profile_max_framerate = (float)encParams->LayerMaxMbsPerSec[i] / (float)nTotalMB;
+
+        else
+            profile_max_framerate = (float)30.0;
+
+        encParams->LayerMaxFrameRate[i] = PV_MIN(profile_max_framerate, encParams->LayerFrameRate[i]);
+    }
+
+    /* check bit rate */
+    /* set max bit rate */
+    for (i = 0; i < encParams->nLayers; i++)
+    {
+        encParams->LayerBitRate[i] = encOption->bitRate[i];
+        encParams->LayerMaxBitRate[i] = encOption->bitRate[i];
+    }
+    if (encParams->nLayers > 1)
+    {
+        if (encOption->bitRate[0] == encOption->bitRate[1] ||
+                encOption->bitRate[0] == 0 || encOption->bitRate[1] == 0) /* 7/31/03 */
+            goto CLEAN_UP;
+    }
+    /* check rate control and vbv delay*/
+    encParams->RC_Type = encOption->rcType;
+
+    if (encOption->vbvDelay == 0.0) /* set to default */
+    {
+        switch (encOption->rcType)
+        {
+            case CBR_1:
+            case CBR_2:
+                encParams->VBV_delay = (float)2.0; /* default 2sec VBV buffer size */
+                break;
+
+            case CBR_LOWDELAY:
+                encParams->VBV_delay = (float)0.5; /* default 0.5sec VBV buffer size */
+                break;
+
+            case VBR_1:
+            case VBR_2:
+                encParams->VBV_delay = (float)10.0; /* default 10sec VBV buffer size */
+                break;
+            default:
+                break;
+        }
+    }
+    else /* force this value */
+    {
+        encParams->VBV_delay = encOption->vbvDelay;
+    }
+
+    /* check search range */
+    if (encParams->H263_Enabled && encOption->searchRange > 16)
+    {
+        encParams->SearchRange = 16; /* 4/16/2001 */
+    }
+
+    /*****************************************/
+    /* checking for conflict between options */
+    /*****************************************/
+
+    if (video->encParams->RC_Type == CBR_1 || video->encParams->RC_Type == CBR_2 || video->encParams->RC_Type == CBR_LOWDELAY)  /* if CBR */
+    {
+#ifdef _PRINT_STAT
+        if (video->encParams->NoFrameSkip_Enabled == PV_ON ||
+                video->encParams->NoPreSkip_Enabled == PV_ON) /* don't allow frame skip*/
+            printf("WARNING!!!! CBR with NoFrameSkip\n");
+#endif
+    }
+    else if (video->encParams->RC_Type == CONSTANT_Q)   /* constant_Q */
+    {
+        video->encParams->NoFrameSkip_Enabled = PV_ON;  /* no frame skip */
+        video->encParams->NoPreSkip_Enabled = PV_ON;    /* no frame skip */
+#ifdef _PRINT_STAT
+        printf("Turn on NoFrameSkip\n");
+#endif
+    }
+
+    if (video->encParams->NoFrameSkip_Enabled == PV_ON) /* if no frame skip */
+    {
+        video->encParams->FineFrameSkip_Enabled = PV_OFF;
+#ifdef _PRINT_STAT
+        printf("NoFrameSkip !!! may violate VBV_BUFFER constraint.\n");
+        printf("Turn off FineFrameSkip\n");
+#endif
+    }
+
+    /******************************************/
+    /******************************************/
+
+    nLayers = video->encParams->nLayers; /* Number of Layers to be encoded */
+
+    /* Find the maximum width*height for memory allocation of the VOPs */
+    for (idx = 0; idx < nLayers; idx++)
+    {
+        temp_w = video->encParams->LayerWidth[idx];
+        temp_h = video->encParams->LayerHeight[idx];
+
+        if ((temp_w*temp_h) > max)
+        {
+            max = temp_w * temp_h;
+            max_width = ((temp_w + 15) >> 4) << 4;
+            max_height = ((temp_h + 15) >> 4) << 4;
+            nTotalMB = ((max_width * max_height) >> 8);
+        }
+
+        /* Check if the video size and framerate(MBsPerSec) are vald */
+        mbsPerSec = (Int)(nTotalMB * video->encParams->LayerFrameRate[idx]);
+        if (mbsPerSec > video->encParams->LayerMaxMbsPerSec[idx]) status = PV_FALSE;
+    }
+
+    /****************************************************/
+    /* Set Profile and Video Buffer Size for each layer */
+    /****************************************************/
+    if (video->encParams->RC_Type == CBR_LOWDELAY) video->encParams->VBV_delay = 0.5; /* For CBR_LOWDELAY, we set 0.5sec buffer */
+    status = SetProfile_BufferSize(video, video->encParams->VBV_delay, 1);
+    if (status != PV_TRUE)
+        goto CLEAN_UP;
+
+    /****************************************/
+    /* memory allocation and initialization */
+    /****************************************/
+
+    if (video == NULL) goto CLEAN_UP;
+
+    /* cyclic reference for passing through both structures */
+    video->videoEncControls = encoderControl;
+
+    //video->currLayer = 0; /* Set current Layer to 0 */
+    //video->currFrameNo = 0; /* Set current frame Number to 0 */
+    video->nextModTime = 0;
+    video->nextEncIVop = 0; /* Sets up very first frame to be I-VOP! */
+    video->numVopsInGOP = 0; /* counter for Vops in Gop, 2/8/01 */
+
+    //video->frameRate = video->encParams->LayerFrameRate[0]; /* Set current layer frame rate */
+
+    video->QPMB = (UChar *) M4VENC_MALLOC(nTotalMB * sizeof(UChar)); /* Memory for MB quantizers */
+    if (video->QPMB == NULL) goto CLEAN_UP;
+
+
+    video->headerInfo.Mode = (UChar *) M4VENC_MALLOC(sizeof(UChar) * nTotalMB); /* Memory for MB Modes */
+    if (video->headerInfo.Mode == NULL) goto CLEAN_UP;
+    video->headerInfo.CBP = (UChar *) M4VENC_MALLOC(sizeof(UChar) * nTotalMB);   /* Memory for CBP (Y and C) of each MB */
+    if (video->headerInfo.CBP == NULL) goto CLEAN_UP;
+
+    /* Allocating motion vector space and interpolation memory*/
+
+    video->mot = (MOT **)M4VENC_MALLOC(sizeof(MOT *) * nTotalMB);
+    if (video->mot == NULL) goto CLEAN_UP;
+
+    for (idx = 0; idx < nTotalMB; idx++)
+    {
+        video->mot[idx] = (MOT *)M4VENC_MALLOC(sizeof(MOT) * 8);
+        if (video->mot[idx] == NULL)
+        {
+            goto CLEAN_UP;
+        }
+    }
+
+    video->intraArray = (UChar *)M4VENC_MALLOC(sizeof(UChar) * nTotalMB);
+    if (video->intraArray == NULL) goto CLEAN_UP;
+
+    video->sliceNo = (UChar *) M4VENC_MALLOC(nTotalMB); /* Memory for Slice Numbers */
+    if (video->sliceNo == NULL) goto CLEAN_UP;
+    /* Allocating space for predDCAC[][8][16], Not that I intentionally  */
+    /*    increase the dimension of predDCAC from [][6][15] to [][8][16] */
+    /*    so that compilers can generate faster code to indexing the     */
+    /*    data inside (by using << instead of *).         04/14/2000. */
+    /* 5/29/01, use  decoder lib ACDC prediction memory scheme.  */
+    video->predDC = (typeDCStore *) M4VENC_MALLOC(nTotalMB * sizeof(typeDCStore));
+    if (video->predDC == NULL) goto CLEAN_UP;
+
+    if (!video->encParams->H263_Enabled)
+    {
+        video->predDCAC_col = (typeDCACStore *) M4VENC_MALLOC(((max_width >> 4) + 1) * sizeof(typeDCACStore));
+        if (video->predDCAC_col == NULL) goto CLEAN_UP;
+
+        /* element zero will be used for storing vertical (col) AC coefficients */
+        /*  the rest will be used for storing horizontal (row) AC coefficients  */
+        video->predDCAC_row = video->predDCAC_col + 1;        /*  ACDC */
+
+        video->acPredFlag = (Int *) M4VENC_MALLOC(nTotalMB * sizeof(Int)); /* Memory for acPredFlag */
+        if (video->acPredFlag == NULL) goto CLEAN_UP;
+    }
+
+    video->outputMB = (MacroBlock *) M4VENC_MALLOC(sizeof(MacroBlock)); /* Allocating macroblock space */
+    if (video->outputMB == NULL) goto CLEAN_UP;
+    M4VENC_MEMSET(video->outputMB->block[0], 0, (sizeof(Short) << 6)*6);
+
+    M4VENC_MEMSET(video->dataBlock, 0, sizeof(Short) << 7);
+    /* Allocate (2*packetsize) working bitstreams */
+
+    video->bitstream1 = BitStreamCreateEnc(2 * 4096); /*allocate working stream 1*/
+    if (video->bitstream1 == NULL) goto CLEAN_UP;
+    video->bitstream2 = BitStreamCreateEnc(2 * 4096); /*allocate working stream 2*/
+    if (video->bitstream2 == NULL) goto CLEAN_UP;
+    video->bitstream3 = BitStreamCreateEnc(2 * 4096); /*allocate working stream 3*/
+    if (video->bitstream3 == NULL) goto CLEAN_UP;
+
+    /* allocate overrun buffer */
+    // this buffer is used when user's buffer is too small to hold one frame.
+    // It is not needed for slice-based encoding.
+    if (nLayers == 1)
+    {
+        video->oBSize = encParams->BufferSize[0] >> 3;
+    }
+    else
+    {
+        video->oBSize = PV_MAX((encParams->BufferSize[0] >> 3), (encParams->BufferSize[1] >> 3));
+    }
+
+    if (video->oBSize > DEFAULT_OVERRUN_BUFFER_SIZE || encParams->RC_Type == CONSTANT_Q) // set limit
+    {
+        video->oBSize = DEFAULT_OVERRUN_BUFFER_SIZE;
+    }
+    video->overrunBuffer = (UChar*) M4VENC_MALLOC(sizeof(UChar) * video->oBSize);
+    if (video->overrunBuffer == NULL) goto CLEAN_UP;
+
+
+    video->currVop = (Vop *) M4VENC_MALLOC(sizeof(Vop)); /* Memory for Current VOP */
+    if (video->currVop == NULL) goto CLEAN_UP;
+
+    /* add padding, 09/19/05 */
+    if (video->encParams->H263_Enabled) /* make it conditional  11/28/05 */
+    {
+        pitch = max_width;
+        offset = 0;
+    }
+    else
+    {
+        pitch = max_width + 32;
+        offset = (pitch << 4) + 16;
+        max_height += 32;
+    }
+    size = pitch * max_height;
+
+    video->currVop->yChan = (PIXEL *)M4VENC_MALLOC(sizeof(PIXEL) * (size + (size >> 1))); /* Memory for currVop Y */
+    if (video->currVop->yChan == NULL) goto CLEAN_UP;
+    video->currVop->uChan = video->currVop->yChan + size;/* Memory for currVop U */
+    video->currVop->vChan = video->currVop->uChan + (size >> 2);/* Memory for currVop V */
+
+    /* shift for the offset */
+    if (offset)
+    {
+        video->currVop->yChan += offset; /* offset to the origin.*/
+        video->currVop->uChan += (offset >> 2) + 4;
+        video->currVop->vChan += (offset >> 2) + 4;
+    }
+
+    video->forwardRefVop = video->currVop;      /*  Initialize forwardRefVop */
+    video->backwardRefVop = video->currVop;     /*  Initialize backwardRefVop */
+
+    video->prevBaseVop = (Vop *) M4VENC_MALLOC(sizeof(Vop));         /* Memory for Previous Base Vop */
+    if (video->prevBaseVop == NULL) goto CLEAN_UP;
+    video->prevBaseVop->yChan = (PIXEL *) M4VENC_MALLOC(sizeof(PIXEL) * (size + (size >> 1))); /* Memory for prevBaseVop Y */
+    if (video->prevBaseVop->yChan == NULL) goto CLEAN_UP;
+    video->prevBaseVop->uChan = video->prevBaseVop->yChan + size; /* Memory for prevBaseVop U */
+    video->prevBaseVop->vChan = video->prevBaseVop->uChan + (size >> 2); /* Memory for prevBaseVop V */
+
+    if (offset)
+    {
+        video->prevBaseVop->yChan += offset; /* offset to the origin.*/
+        video->prevBaseVop->uChan += (offset >> 2) + 4;
+        video->prevBaseVop->vChan += (offset >> 2) + 4;
+    }
+
+
+    if (0) /* If B Frames */
+    {
+        video->nextBaseVop = (Vop *) M4VENC_MALLOC(sizeof(Vop));         /* Memory for Next Base Vop */
+        if (video->nextBaseVop == NULL) goto CLEAN_UP;
+        video->nextBaseVop->yChan = (PIXEL *) M4VENC_MALLOC(sizeof(PIXEL) * (size + (size >> 1))); /* Memory for nextBaseVop Y */
+        if (video->nextBaseVop->yChan == NULL) goto CLEAN_UP;
+        video->nextBaseVop->uChan = video->nextBaseVop->yChan + size; /* Memory for nextBaseVop U */
+        video->nextBaseVop->vChan = video->nextBaseVop->uChan + (size >> 2); /* Memory for nextBaseVop V */
+
+        if (offset)
+        {
+            video->nextBaseVop->yChan += offset; /* offset to the origin.*/
+            video->nextBaseVop->uChan += (offset >> 2) + 4;
+            video->nextBaseVop->vChan += (offset >> 2) + 4;
+        }
+    }
+
+    if (nLayers > 1)   /* If enhancement layers */
+    {
+        video->prevEnhanceVop = (Vop *) M4VENC_MALLOC(sizeof(Vop));      /* Memory for Previous Enhancement Vop */
+        if (video->prevEnhanceVop == NULL) goto CLEAN_UP;
+        video->prevEnhanceVop->yChan = (PIXEL *) M4VENC_MALLOC(sizeof(PIXEL) * (size + (size >> 1))); /* Memory for Previous Ehancement Y */
+        if (video->prevEnhanceVop->yChan == NULL) goto CLEAN_UP;
+        video->prevEnhanceVop->uChan = video->prevEnhanceVop->yChan + size; /* Memory for Previous Enhancement U */
+        video->prevEnhanceVop->vChan = video->prevEnhanceVop->uChan + (size >> 2); /* Memory for Previous Enhancement V */
+
+        if (offset)
+        {
+            video->prevEnhanceVop->yChan += offset; /* offset to the origin.*/
+            video->prevEnhanceVop->uChan += (offset >> 2) + 4;
+            video->prevEnhanceVop->vChan += (offset >> 2) + 4;
+        }
+    }
+
+    video->numberOfLayers = nLayers; /* Number of Layers */
+    video->sumMAD = 0;
+
+
+    /* 04/09/01, for Vops in the use multipass processing */
+    for (idx = 0; idx < nLayers; idx++)
+    {
+        video->pMP[idx] = (MultiPass *)M4VENC_MALLOC(sizeof(MultiPass));
+        if (video->pMP[idx] == NULL)    goto CLEAN_UP;
+        M4VENC_MEMSET(video->pMP[idx], 0, sizeof(MultiPass));
+
+        video->pMP[idx]->encoded_frames = -1; /* forget about the very first I frame */
+
+
+        /* RDInfo **pRDSamples */
+        video->pMP[idx]->pRDSamples = (RDInfo **)M4VENC_MALLOC(30 * sizeof(RDInfo *));
+        if (video->pMP[idx]->pRDSamples == NULL)    goto CLEAN_UP;
+        for (i = 0; i < 30; i++)
+        {
+            video->pMP[idx]->pRDSamples[i] = (RDInfo *)M4VENC_MALLOC(32 * sizeof(RDInfo));
+            if (video->pMP[idx]->pRDSamples[i] == NULL) goto CLEAN_UP;
+            for (j = 0; j < 32; j++)    M4VENC_MEMSET(&(video->pMP[idx]->pRDSamples[i][j]), 0, sizeof(RDInfo));
+        }
+        video->pMP[idx]->frameRange = (Int)(video->encParams->LayerFrameRate[idx] * 1.0); /* 1.0s time frame*/
+        video->pMP[idx]->frameRange = PV_MAX(video->pMP[idx]->frameRange, 5);
+        video->pMP[idx]->frameRange = PV_MIN(video->pMP[idx]->frameRange, 30);
+
+        video->pMP[idx]->framePos = -1;
+
+    }
+    /* /// End /////////////////////////////////////// */
+
+
+    video->vol = (Vol **)M4VENC_MALLOC(nLayers * sizeof(Vol *)); /* Memory for VOL pointers */
+
+    /* Memory allocation and Initialization of Vols and writing of headers */
+    if (video->vol == NULL) goto CLEAN_UP;
+
+    for (idx = 0; idx < nLayers; idx++)
+    {
+        video->volInitialize[idx] = 1;
+        video->refTick[idx] = 0;
+        video->relLayerCodeTime[idx] = 1000;
+        video->vol[idx] = (Vol *)M4VENC_MALLOC(sizeof(Vol));
+        if (video->vol[idx] == NULL)  goto CLEAN_UP;
+
+        pVol = video->vol[idx];
+        pEncParams = video->encParams;
+
+        M4VENC_MEMSET(video->vol[idx], 0, sizeof(Vol));
+        /* Initialize some VOL parameters */
+        pVol->volID = idx;  /* Set VOL ID */
+        pVol->shortVideoHeader = pEncParams->H263_Enabled; /*Short Header */
+        pVol->GOVStart = pEncParams->GOV_Enabled; /* GOV Header */
+        pVol->timeIncrementResolution = video->encParams->TimeIncrementRes;
+        pVol->nbitsTimeIncRes = 1;
+        while (pVol->timeIncrementResolution > (1 << pVol->nbitsTimeIncRes))
+        {
+            pVol->nbitsTimeIncRes++;
+        }
+
+        /* timing stuff */
+        pVol->timeIncrement = 0;
+        pVol->moduloTimeBase = 0;
+        pVol->fixedVopRate = 0; /* No fixed VOP rate */
+        pVol->stream = (BitstreamEncVideo *)M4VENC_MALLOC(sizeof(BitstreamEncVideo)); /* allocate BitstreamEncVideo Instance */
+        if (pVol->stream == NULL)  goto CLEAN_UP;
+
+        pVol->width = pEncParams->LayerWidth[idx];      /* Layer Width */
+        pVol->height = pEncParams->LayerHeight[idx];    /* Layer Height */
+        //  pVol->intra_acdcPredDisable = pEncParams->ACDCPrediction; /* ACDC Prediction */
+        pVol->ResyncMarkerDisable = pEncParams->ResyncMarkerDisable; /* Resync Marker Mode */
+        pVol->dataPartitioning = pEncParams->DataPartitioning; /* Data Partitioning */
+        pVol->useReverseVLC = pEncParams->ReversibleVLC; /* RVLC */
+        if (idx > 0) /* Scalability layers */
+        {
+            pVol->ResyncMarkerDisable = 1;
+            pVol->dataPartitioning = 0;
+            pVol->useReverseVLC = 0; /*  No RVLC */
+        }
+        pVol->quantType = pEncParams->QuantType[idx];           /* Quantizer Type */
+
+        /* no need to init Quant Matrices */
+
+        pVol->scalability = 0;  /* Vol Scalability */
+        if (idx > 0)
+            pVol->scalability = 1; /* Multiple layers => Scalability */
+
+        /* Initialize Vol to Temporal scalability.  It can change during encoding */
+        pVol->scalType = 1;
+        /* Initialize reference Vol ID to the base layer = 0 */
+        pVol->refVolID = 0;
+        /* Initialize layer resolution to same as the reference */
+        pVol->refSampDir = 0;
+        pVol->horSamp_m = 1;
+        pVol->horSamp_n = 1;
+        pVol->verSamp_m = 1;
+        pVol->verSamp_n = 1;
+        pVol->enhancementType = 0; /* We always enhance the entire region */
+
+        pVol->nMBPerRow = (pVol->width + 15) / 16;
+        pVol->nMBPerCol = (pVol->height + 15) / 16;
+        pVol->nTotalMB = pVol->nMBPerRow * pVol->nMBPerCol;
+
+        if (pVol->nTotalMB >= 1)
+            pVol->nBitsForMBID = 1;
+        if (pVol->nTotalMB >= 3)
+            pVol->nBitsForMBID = 2;
+        if (pVol->nTotalMB >= 5)
+            pVol->nBitsForMBID = 3;
+        if (pVol->nTotalMB >= 9)
+            pVol->nBitsForMBID = 4;
+        if (pVol->nTotalMB >= 17)
+            pVol->nBitsForMBID = 5;
+        if (pVol->nTotalMB >= 33)
+            pVol->nBitsForMBID = 6;
+        if (pVol->nTotalMB >= 65)
+            pVol->nBitsForMBID = 7;
+        if (pVol->nTotalMB >= 129)
+            pVol->nBitsForMBID = 8;
+        if (pVol->nTotalMB >= 257)
+            pVol->nBitsForMBID = 9;
+        if (pVol->nTotalMB >= 513)
+            pVol->nBitsForMBID = 10;
+        if (pVol->nTotalMB >= 1025)
+            pVol->nBitsForMBID = 11;
+        if (pVol->nTotalMB >= 2049)
+            pVol->nBitsForMBID = 12;
+        if (pVol->nTotalMB >= 4097)
+            pVol->nBitsForMBID = 13;
+        if (pVol->nTotalMB >= 8193)
+            pVol->nBitsForMBID = 14;
+        if (pVol->nTotalMB >= 16385)
+            pVol->nBitsForMBID = 15;
+        if (pVol->nTotalMB >= 32769)
+            pVol->nBitsForMBID = 16;
+        if (pVol->nTotalMB >= 65537)
+            pVol->nBitsForMBID = 17;
+        if (pVol->nTotalMB >= 131073)
+            pVol->nBitsForMBID = 18;
+
+        if (pVol->shortVideoHeader)
+        {
+            switch (pVol->width)
+            {
+                case 128:
+                    if (pVol->height == 96)  /* source_format = 1 */
+                    {
+                        pVol->nGOBinVop = 6;
+                        pVol->nMBinGOB = 8;
+                    }
+                    else
+                        status = PV_FALSE;
+                    break;
+
+                case 176:
+                    if (pVol->height == 144)  /* source_format = 2 */
+                    {
+                        pVol->nGOBinVop = 9;
+                        pVol->nMBinGOB = 11;
+                    }
+                    else
+                        status = PV_FALSE;
+                    break;
+                case 352:
+                    if (pVol->height == 288)  /* source_format = 2 */
+                    {
+                        pVol->nGOBinVop = 18;
+                        pVol->nMBinGOB = 22;
+                    }
+                    else
+                        status = PV_FALSE;
+                    break;
+
+                case 704:
+                    if (pVol->height == 576)  /* source_format = 2 */
+                    {
+                        pVol->nGOBinVop = 18;
+                        pVol->nMBinGOB = 88;
+                    }
+                    else
+                        status = PV_FALSE;
+                    break;
+                case 1408:
+                    if (pVol->height == 1152)  /* source_format = 2 */
+                    {
+                        pVol->nGOBinVop = 18;
+                        pVol->nMBinGOB = 352;
+                    }
+                    else
+                        status = PV_FALSE;
+                    break;
+
+                default:
+                    status = PV_FALSE;
+                    break;
+            }
+        }
+    }
+
+    /***************************************************/
+    /* allocate and initialize rate control parameters */
+    /***************************************************/
+
+    /* BEGIN INITIALIZATION OF ANNEX L RATE CONTROL */
+    if (video->encParams->RC_Type != CONSTANT_Q)
+    {
+        for (idx = 0; idx < nLayers; idx++) /* 12/25/00 */
+        {
+            video->rc[idx] =
+                (rateControl *)M4VENC_MALLOC(sizeof(rateControl));
+
+            if (video->rc[idx] == NULL) goto CLEAN_UP;
+
+            M4VENC_MEMSET(video->rc[idx], 0, sizeof(rateControl));
+        }
+        if (PV_SUCCESS != RC_Initialize(video))
+        {
+            goto CLEAN_UP;
+        }
+        /* initialization for 2-pass rate control */
+    }
+    /* END INITIALIZATION OF ANNEX L RATE CONTROL */
+
+    /********** assign platform dependent functions ***********************/
+    /* 1/23/01 */
+    /* This must be done at run-time not a compile time */
+    video->functionPointer = (FuncPtr*) M4VENC_MALLOC(sizeof(FuncPtr));
+    if (video->functionPointer == NULL) goto CLEAN_UP;
+
+    video->functionPointer->ComputeMBSum = &ComputeMBSum_C;
+    video->functionPointer->SAD_MB_HalfPel[0] = NULL;
+    video->functionPointer->SAD_MB_HalfPel[1] = &SAD_MB_HalfPel_Cxh;
+    video->functionPointer->SAD_MB_HalfPel[2] = &SAD_MB_HalfPel_Cyh;
+    video->functionPointer->SAD_MB_HalfPel[3] = &SAD_MB_HalfPel_Cxhyh;
+
+#ifndef NO_INTER4V
+    video->functionPointer->SAD_Blk_HalfPel = &SAD_Blk_HalfPel_C;
+    video->functionPointer->SAD_Block = &SAD_Block_C;
+#endif
+    video->functionPointer->SAD_Macroblock = &SAD_Macroblock_C;
+    video->functionPointer->ChooseMode = &ChooseMode_C;
+    video->functionPointer->GetHalfPelMBRegion = &GetHalfPelMBRegion_C;
+//  video->functionPointer->SAD_MB_PADDING = &SAD_MB_PADDING; /* 4/21/01 */
+
+
+    encoderControl->videoEncoderInit = 1;  /* init done! */
+
+    return PV_TRUE;
+
+CLEAN_UP:
+    PVCleanUpVideoEncoder(encoderControl);
+
+    return PV_FALSE;
+}
+
+
+/* ======================================================================== */
+/*  Function : PVCleanUpVideoEncoder()                                      */
+/*  Date     : 08/22/2000                                                   */
+/*  Purpose  : Deallocates allocated memory from InitVideoEncoder()         */
+/*  In/out   :                                                              */
+/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
+/*  Modified : 5/21/01, free only yChan in Vop                          */
+/*                                                                          */
+/* ======================================================================== */
+
+OSCL_EXPORT_REF Bool    PVCleanUpVideoEncoder(VideoEncControls *encoderControl)
+{
+    Int idx, i;
+    VideoEncData *video = (VideoEncData *)encoderControl->videoEncoderData;
+    int nTotalMB;
+    int max_width, offset;
+
+#ifdef PRINT_RC_INFO
+    if (facct != NULL)
+    {
+        fprintf(facct, "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n");
+        fprintf(facct, "TOTAL NUM BITS GENERATED %d\n", tiTotalNumBitsGenerated);
+        fprintf(facct, "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n");
+        fprintf(facct, "TOTAL NUMBER OF FRAMES CODED %d\n",
+                video->encParams->rc[0]->totalFrameNumber);
+        fprintf(facct, "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n");
+        fprintf(facct, "Average BitRate %d\n",
+                (tiTotalNumBitsGenerated / (90 / 30)));
+        fprintf(facct, "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n");
+        fprintf(facct, "TOTAL NUMBER OF STUFF BITS %d\n", (iStuffBits + 10740));
+        fprintf(facct, "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n");
+        fprintf(facct, "TOTAL NUMBER OF BITS TO NETWORK %d\n", (35800*90 / 30));;
+        fprintf(facct, "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n");
+        fprintf(facct, "SUM OF STUFF BITS AND GENERATED BITS %d\n",
+                (tiTotalNumBitsGenerated + iStuffBits + 10740));
+        fprintf(facct, "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n");
+        fprintf(facct, "UNACCOUNTED DIFFERENCE %d\n",
+                ((35800*90 / 30) - (tiTotalNumBitsGenerated + iStuffBits + 10740)));
+        fprintf(facct, "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n");
+        fclose(facct);
+    }
+#endif
+
+#ifdef PRINT_EC
+    fclose(fec);
+#endif
+
+    if (video != NULL)
+    {
+
+        if (video->QPMB) M4VENC_FREE(video->QPMB);
+        if (video->headerInfo.Mode)M4VENC_FREE(video->headerInfo.Mode);
+        if (video->headerInfo.CBP)M4VENC_FREE(video->headerInfo.CBP);
+
+
+        if (video->mot)
+        {
+            nTotalMB = video->vol[0]->nTotalMB;
+            for (idx = 1; idx < video->currLayer; idx++)
+                if (video->vol[idx]->nTotalMB > nTotalMB)
+                    nTotalMB = video->vol[idx]->nTotalMB;
+            for (idx = 0; idx < nTotalMB; idx++)
+            {
+                if (video->mot[idx])
+                    M4VENC_FREE(video->mot[idx]);
+            }
+            M4VENC_FREE(video->mot);
+        }
+
+        if (video->intraArray) M4VENC_FREE(video->intraArray);
+
+        if (video->sliceNo)M4VENC_FREE(video->sliceNo);
+        if (video->acPredFlag)M4VENC_FREE(video->acPredFlag);
+//      if(video->predDCAC)M4VENC_FREE(video->predDCAC);
+        if (video->predDC) M4VENC_FREE(video->predDC);
+        video->predDCAC_row = NULL;
+        if (video->predDCAC_col) M4VENC_FREE(video->predDCAC_col);
+        if (video->outputMB)M4VENC_FREE(video->outputMB);
+
+        if (video->bitstream1)BitstreamCloseEnc(video->bitstream1);
+        if (video->bitstream2)BitstreamCloseEnc(video->bitstream2);
+        if (video->bitstream3)BitstreamCloseEnc(video->bitstream3);
+
+        if (video->overrunBuffer) M4VENC_FREE(video->overrunBuffer);
+
+        max_width = video->encParams->LayerWidth[0];
+        max_width = (((max_width + 15) >> 4) << 4); /* 09/19/05 */
+        if (video->encParams->H263_Enabled)
+        {
+            offset = 0;
+        }
+        else
+        {
+            offset = ((max_width + 32) << 4) + 16;
+        }
+
+        if (video->currVop)
+        {
+            if (video->currVop->yChan)
+            {
+                video->currVop->yChan -= offset;
+                M4VENC_FREE(video->currVop->yChan);
+            }
+            M4VENC_FREE(video->currVop);
+        }
+
+        if (video->nextBaseVop)
+        {
+            if (video->nextBaseVop->yChan)
+            {
+                video->nextBaseVop->yChan -= offset;
+                M4VENC_FREE(video->nextBaseVop->yChan);
+            }
+            M4VENC_FREE(video->nextBaseVop);
+        }
+
+        if (video->prevBaseVop)
+        {
+            if (video->prevBaseVop->yChan)
+            {
+                video->prevBaseVop->yChan -= offset;
+                M4VENC_FREE(video->prevBaseVop->yChan);
+            }
+            M4VENC_FREE(video->prevBaseVop);
+        }
+        if (video->prevEnhanceVop)
+        {
+            if (video->prevEnhanceVop->yChan)
+            {
+                video->prevEnhanceVop->yChan -= offset;
+                M4VENC_FREE(video->prevEnhanceVop->yChan);
+            }
+            M4VENC_FREE(video->prevEnhanceVop);
+        }
+
+        /* 04/09/01, for Vops in the use multipass processing */
+        for (idx = 0; idx < video->encParams->nLayers; idx++)
+        {
+            if (video->pMP[idx])
+            {
+                if (video->pMP[idx]->pRDSamples)
+                {
+                    for (i = 0; i < 30; i++)
+                    {
+                        if (video->pMP[idx]->pRDSamples[i])
+                            M4VENC_FREE(video->pMP[idx]->pRDSamples[i]);
+                    }
+                    M4VENC_FREE(video->pMP[idx]->pRDSamples);
+                }
+
+                M4VENC_MEMSET(video->pMP[idx], 0, sizeof(MultiPass));
+                M4VENC_FREE(video->pMP[idx]);
+            }
+        }
+        /* //  End /////////////////////////////////////// */
+
+        if (video->vol)
+        {
+            for (idx = 0; idx < video->encParams->nLayers; idx++)
+            {
+                if (video->vol[idx])
+                {
+                    if (video->vol[idx]->stream)
+                        M4VENC_FREE(video->vol[idx]->stream);
+                    M4VENC_FREE(video->vol[idx]);
+                }
+            }
+            M4VENC_FREE(video->vol);
+        }
+
+        /***************************************************/
+        /* stop rate control parameters */
+        /***************************************************/
+
+        /* ANNEX L RATE CONTROL */
+        if (video->encParams->RC_Type != CONSTANT_Q)
+        {
+            RC_Cleanup(video->rc, video->encParams->nLayers);
+
+            for (idx = 0; idx < video->encParams->nLayers; idx++)
+            {
+                if (video->rc[idx])
+                    M4VENC_FREE(video->rc[idx]);
+            }
+        }
+
+        if (video->functionPointer) M4VENC_FREE(video->functionPointer);
+
+        /* If application has called PVCleanUpVideoEncoder then we deallocate */
+        /* If PVInitVideoEncoder class it, then we DO NOT deallocate */
+        if (video->encParams)
+        {
+            M4VENC_FREE(video->encParams);
+        }
+
+        M4VENC_FREE(video);
+        encoderControl->videoEncoderData = NULL; /* video */
+    }
+
+    encoderControl->videoEncoderInit = 0;
+
+    return PV_TRUE;
+}
+
+/* ======================================================================== */
+/*  Function : PVGetVolHeader()                                             */
+/*  Date     : 7/17/2001,                                                   */
+/*  Purpose  :                                                              */
+/*  In/out   :                                                              */
+/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
+/*  Modified :                                                              */
+/*                                                                          */
+/* ======================================================================== */
+
+OSCL_EXPORT_REF Bool PVGetVolHeader(VideoEncControls *encCtrl, UChar *volHeader, Int *size, Int layer)
+{
+    VideoEncData    *encData;
+    PV_STATUS   EncodeVOS_Start(VideoEncControls *encCtrl);
+    encData = (VideoEncData *)encCtrl->videoEncoderData;
+
+
+    if (encData == NULL)
+        return PV_FALSE;
+    if (encData->encParams == NULL)
+        return PV_FALSE;
+
+
+    encData->currLayer = layer; /* Set Layer */
+    /*pv_status = */
+    EncodeVOS_Start(encCtrl); /* Encode VOL Header */
+
+    encData->encParams->GetVolHeader[layer] = 1; /* Set usage flag: Needed to support old method*/
+
+    /* Copy bitstream to buffer and set the size */
+
+    if (*size > encData->bitstream1->byteCount)
+    {
+        *size = encData->bitstream1->byteCount;
+        M4VENC_MEMCPY(volHeader, encData->bitstream1->bitstreamBuffer, *size);
+    }
+    else
+        return PV_FALSE;
+
+    /* Reset bitstream1 buffer parameters */
+    BitstreamEncReset(encData->bitstream1);
+
+    return PV_TRUE;
+}
+
+/* ======================================================================== */
+/*  Function : PVGetOverrunBuffer()                                         */
+/*  Purpose  : Get the overrun buffer `                                     */
+/*  In/out   :                                                              */
+/*  Return   : Pointer to overrun buffer.                                   */
+/*  Modified :                                                              */
+/* ======================================================================== */
+
+OSCL_EXPORT_REF UChar* PVGetOverrunBuffer(VideoEncControls *encCtrl)
+{
+    VideoEncData *video = (VideoEncData *)encCtrl->videoEncoderData;
+    Int currLayer = video->currLayer;
+    Vol *currVol = video->vol[currLayer];
+
+    if (currVol->stream->bitstreamBuffer != video->overrunBuffer) // not used
+    {
+        return NULL;
+    }
+
+    return video->overrunBuffer;
+}
+
+
+
+
+/* ======================================================================== */
+/*  Function : EncodeVideoFrame()                                           */
+/*  Date     : 08/22/2000                                                   */
+/*  Purpose  : Encode video frame and return bitstream                      */
+/*  In/out   :                                                              */
+/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
+/*  Modified :                                                              */
+/*  02.14.2001                                      */
+/*              Finishing new timestamp 32-bit input                        */
+/*              Applications need to take care of wrap-around               */
+/* ======================================================================== */
+OSCL_EXPORT_REF Bool PVEncodeVideoFrame(VideoEncControls *encCtrl, VideoEncFrameIO *vid_in, VideoEncFrameIO *vid_out,
+                                        ULong *nextModTime, UChar *bstream, Int *size, Int *nLayer)
+{
+    Bool status = PV_TRUE;
+    PV_STATUS pv_status;
+    VideoEncData *video = (VideoEncData *)encCtrl->videoEncoderData;
+    VideoEncParams *encParams = video->encParams;
+    Vol *currVol;
+    Vop *tempForwRefVop = NULL;
+    Int tempRefSelCode = 0;
+    PV_STATUS   EncodeVOS_Start(VideoEncControls *encCtrl);
+    Int width_16, height_16;
+    Int width, height;
+    Vop *temp;
+    Int encodeVop = 0;
+    void  PaddingEdge(Vop *padVop);
+    Int currLayer = -1;
+    //Int nLayers = encParams->nLayers;
+
+    ULong modTime = vid_in->timestamp;
+
+#ifdef RANDOM_REFSELCODE   /* add random selection of reference Vop */
+    Int random_val[30] = {0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0};
+    static Int rand_idx = 0;
+#endif
+
+    /*******************************************************/
+    /* Determine Next Vop to encode, if any, and nLayer    */
+    /*******************************************************/
+    //i = nLayers-1;
+
+    if (video->volInitialize[0]) /* first vol to code */
+    {
+        video->nextModTime = video->modTimeRef = ((modTime) - ((modTime) % 1000));
+    }
+
+    encodeVop = DetermineCodingLayer(video, nLayer, modTime);
+    currLayer = *nLayer;
+    if ((currLayer < 0) || (currLayer > encParams->nLayers - 1))
+        return PV_FALSE;
+
+    /******************************************/
+    /* If post-skipping still effective --- return */
+    /******************************************/
+
+    if (!encodeVop) /* skip enh layer, no base layer coded --- return */
+    {
+#ifdef _PRINT_STAT
+        printf("No frame coded. Continue to next frame.");
+#endif
+        /* expected next code time, convert back to millisec */
+        *nextModTime = video->nextModTime;
+
+#ifdef ALLOW_VOP_NOT_CODED
+        if (video->vol[0]->shortVideoHeader) /* Short Video Header = 1 */
+        {
+            *size = 0;
+            *nLayer = -1;
+        }
+        else
+        {
+            *nLayer = 0;
+            EncodeVopNotCoded(video, bstream, size, modTime);
+            *size = video->vol[0]->stream->byteCount;
+        }
+#else
+        *size = 0;
+        *nLayer = -1;
+#endif
+        return status;
+    }
+
+
+//ENCODE_VOP_AGAIN:  /* 12/30/00 */
+
+    /**************************************************************/
+    /* Initialize Vol stream structure with application bitstream */
+    /**************************************************************/
+
+    currVol = video->vol[currLayer];
+    currVol->stream->bitstreamBuffer = bstream;
+    currVol->stream->bufferSize = *size;
+    BitstreamEncReset(currVol->stream);
+    BitstreamSetOverrunBuffer(currVol->stream, video->overrunBuffer, video->oBSize, video);
+
+    /***********************************************************/
+    /* Encode VOS and VOL Headers on first call for each layer */
+    /***********************************************************/
+
+    if (video->volInitialize[currLayer])
+    {
+        video->currVop->timeInc = 0;
+        video->prevBaseVop->timeInc = 0;
+        if (!video->encParams->GetVolHeader[currLayer])
+            pv_status = EncodeVOS_Start(encCtrl);
+    }
+
+    /***************************************************/
+    /* Copy Input Video Frame to Internal Video Buffer */
+    /***************************************************/
+    /* Determine Width and Height of Vop Layer */
+
+    width = encParams->LayerWidth[currLayer];   /* Get input width */
+    height = encParams->LayerHeight[currLayer]; /* Get input height */
+    /* Round Up to nearest multiple of 16 : MPEG-4 Standard */
+
+    width_16 = ((width + 15) / 16) * 16;            /* Round up to nearest multiple of 16 */
+    height_16 = ((height + 15) / 16) * 16;          /* Round up to nearest multiple of 16 */
+
+    video->input = vid_in;  /* point to the frame input */
+
+    /*//  End ////////////////////////////// */
+
+
+    /**************************************/
+    /* Determine VOP Type                 */
+    /* 6/2/2001, separate function      */
+    /**************************************/
+    DetermineVopType(video, currLayer);
+
+    /****************************/
+    /*    Initialize VOP        */
+    /****************************/
+    video->currVop->volID = currVol->volID;
+    video->currVop->width = width_16;
+    video->currVop->height = height_16;
+    if (video->encParams->H263_Enabled) /*  11/28/05 */
+    {
+        video->currVop->pitch = width_16;
+    }
+    else
+    {
+        video->currVop->pitch = width_16 + 32;
+    }
+    video->currVop->timeInc = currVol->timeIncrement;
+    video->currVop->vopCoded = 1;
+    video->currVop->roundingType = 0;
+    video->currVop->intraDCVlcThr = encParams->IntraDCVlcThr;
+
+    if (currLayer == 0
+#ifdef RANDOM_REFSELCODE   /* add random selection of reference Vop */
+            || random_val[rand_idx] || video->volInitialize[currLayer]
+#endif
+       )
+    {
+        tempForwRefVop = video->forwardRefVop; /* keep initial state */
+        if (tempForwRefVop != NULL) tempRefSelCode = tempForwRefVop->refSelectCode;
+
+        video->forwardRefVop = video->prevBaseVop;
+        video->forwardRefVop->refSelectCode = 1;
+    }
+#ifdef RANDOM_REFSELCODE
+    else
+    {
+        tempForwRefVop = video->forwardRefVop; /* keep initial state */
+        if (tempForwRefVop != NULL) tempRefSelCode = tempForwRefVop->refSelectCode;
+
+        video->forwardRefVop = video->prevEnhanceVop;
+        video->forwardRefVop->refSelectCode = 0;
+    }
+    rand_idx++;
+    rand_idx %= 30;
+#endif
+
+    video->currVop->refSelectCode = video->forwardRefVop->refSelectCode;
+    video->currVop->gobNumber = 0;
+    video->currVop->gobFrameID = video->currVop->predictionType;
+    video->currVop->temporalRef = (modTime * 30 / 1001) % 256;
+
+    video->currVop->temporalInterval = 0;
+
+    if (video->currVop->predictionType == I_VOP)
+        video->currVop->quantizer = encParams->InitQuantIvop[currLayer];
+    else
+        video->currVop->quantizer = encParams->InitQuantPvop[currLayer];
+
+
+    /****************/
+    /* Encode Vop */
+    /****************/
+    video->slice_coding = 0;
+
+    pv_status = EncodeVop(video);
+#ifdef _PRINT_STAT
+    if (video->currVop->predictionType == I_VOP)
+        printf(" I-VOP ");
+    else
+        printf(" P-VOP (ref.%d)", video->forwardRefVop->refSelectCode);
+#endif
+
+    /************************************/
+    /* Update Skip Next Frame           */
+    /************************************/
+    *nLayer = UpdateSkipNextFrame(video, nextModTime, size, pv_status);
+    if (*nLayer == -1) /* skip current frame */
+    {
+        /* make sure that pointers are restored to the previous state */
+        if (currLayer == 0)
+        {
+            video->forwardRefVop = tempForwRefVop; /* For P-Vop base only */
+            video->forwardRefVop->refSelectCode = tempRefSelCode;
+        }
+
+        return status;
+    }
+
+    /* If I-VOP was encoded, reset IntraPeriod */
+    if ((currLayer == 0) && (encParams->IntraPeriod > 0) && (video->currVop->predictionType == I_VOP))
+        video->nextEncIVop = encParams->IntraPeriod;
+
+    /* Set HintTrack Information */
+    if (currLayer != -1)
+    {
+        if (currVol->prevModuloTimeBase)
+            video->hintTrackInfo.MTB = 1;
+        else
+            video->hintTrackInfo.MTB = 0;
+        video->hintTrackInfo.LayerID = (UChar)currVol->volID;
+        video->hintTrackInfo.CodeType = (UChar)video->currVop->predictionType;
+        video->hintTrackInfo.RefSelCode = (UChar)video->currVop->refSelectCode;
+    }
+
+    /************************************************/
+    /* Determine nLayer and timeInc for next encode */
+    /* 12/27/00 always go by the highest layer*/
+    /************************************************/
+
+    /**********************************************************/
+    /* Copy Reconstructed Buffer to Output Video Frame Buffer */
+    /**********************************************************/
+    vid_out->yChan = video->currVop->yChan;
+    vid_out->uChan = video->currVop->uChan;
+    vid_out->vChan = video->currVop->vChan;
+    if (video->encParams->H263_Enabled)
+    {
+        vid_out->height = video->currVop->height; /* padded height */
+        vid_out->pitch = video->currVop->width; /* padded width */
+    }
+    else
+    {
+        vid_out->height = video->currVop->height + 32; /* padded height */
+        vid_out->pitch = video->currVop->width + 32; /* padded width */
+    }
+    //video_out->timestamp = video->modTime;
+    vid_out->timestamp = (ULong)(((video->prevFrameNum[currLayer] * 1000) / encParams->LayerFrameRate[currLayer]) + video->modTimeRef + 0.5);
+
+    /*// End /////////////////////// */
+
+    /***********************************/
+    /* Update Ouput bstream byte count */
+    /***********************************/
+
+    *size = currVol->stream->byteCount;
+
+    /****************************************/
+    /* Swap Vop Pointers for Base Layer     */
+    /****************************************/
+    if (currLayer == 0)
+    {
+        temp = video->prevBaseVop;
+        video->prevBaseVop = video->currVop;
+        video->prevBaseVop->padded = 0; /* not padded */
+        video->currVop  = temp;
+        video->forwardRefVop = video->prevBaseVop; /* For P-Vop base only */
+        video->forwardRefVop->refSelectCode = 1;
+    }
+    else
+    {
+        temp = video->prevEnhanceVop;
+        video->prevEnhanceVop = video->currVop;
+        video->prevEnhanceVop->padded = 0; /* not padded */
+        video->currVop = temp;
+        video->forwardRefVop = video->prevEnhanceVop;
+        video->forwardRefVop->refSelectCode = 0;
+    }
+
+    /****************************************/
+    /* Modify the intialize flag at the end.*/
+    /****************************************/
+    if (video->volInitialize[currLayer])
+        video->volInitialize[currLayer] = 0;
+
+    return status;
+}
+
+#ifndef NO_SLICE_ENCODE
+/* ======================================================================== */
+/*  Function : PVEncodeFrameSet()                                           */
+/*  Date     : 04/18/2000                                                   */
+/*  Purpose  : Enter a video frame and perform front-end time check plus ME */
+/*  In/out   :                                                              */
+/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
+/*  Modified :                                                              */
+/*                                                                          */
+/* ======================================================================== */
+OSCL_EXPORT_REF Bool PVEncodeFrameSet(VideoEncControls *encCtrl, VideoEncFrameIO *vid_in, ULong *nextModTime, Int *nLayer)
+{
+    Bool status = PV_TRUE;
+    VideoEncData *video = (VideoEncData *)encCtrl->videoEncoderData;
+    VideoEncParams *encParams = video->encParams;
+    Vol *currVol;
+    PV_STATUS   EncodeVOS_Start(VideoEncControls *encCtrl);
+    Int width_16, height_16;
+    Int width, height;
+    Int encodeVop = 0;
+    void  PaddingEdge(Vop *padVop);
+    Int currLayer = -1;
+    //Int nLayers = encParams->nLayers;
+
+    ULong   modTime = vid_in->timestamp;
+
+#ifdef RANDOM_REFSELCODE   /* add random selection of reference Vop */
+    Int random_val[30] = {0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0};
+    static Int rand_idx = 0;
+#endif
+    /*******************************************************/
+    /* Determine Next Vop to encode, if any, and nLayer    */
+    /*******************************************************/
+
+    video->modTime = modTime;
+
+    //i = nLayers-1;
+
+    if (video->volInitialize[0]) /* first vol to code */
+    {
+        video->nextModTime = video->modTimeRef = ((modTime) - ((modTime) % 1000));
+    }
+
+
+    encodeVop = DetermineCodingLayer(video, nLayer, modTime);
+
+    currLayer = *nLayer;
+
+    /******************************************/
+    /* If post-skipping still effective --- return */
+    /******************************************/
+
+    if (!encodeVop) /* skip enh layer, no base layer coded --- return */
+    {
+#ifdef _PRINT_STAT
+        printf("No frame coded. Continue to next frame.");
+#endif
+        *nLayer = -1;
+
+        /* expected next code time, convert back to millisec */
+        *nextModTime = video->nextModTime;;
+        return status;
+    }
+
+    /**************************************************************/
+    /* Initialize Vol stream structure with application bitstream */
+    /**************************************************************/
+
+    currVol = video->vol[currLayer];
+    currVol->stream->bufferSize = 0;
+    BitstreamEncReset(currVol->stream);
+
+    /***********************************************************/
+    /* Encode VOS and VOL Headers on first call for each layer */
+    /***********************************************************/
+
+    if (video->volInitialize[currLayer])
+    {
+        video->currVop->timeInc = 0;
+        video->prevBaseVop->timeInc = 0;
+    }
+
+    /***************************************************/
+    /* Copy Input Video Frame to Internal Video Buffer */
+    /***************************************************/
+    /* Determine Width and Height of Vop Layer */
+
+    width = encParams->LayerWidth[currLayer];   /* Get input width */
+    height = encParams->LayerHeight[currLayer]; /* Get input height */
+    /* Round Up to nearest multiple of 16 : MPEG-4 Standard */
+
+    width_16 = ((width + 15) / 16) * 16;            /* Round up to nearest multiple of 16 */
+    height_16 = ((height + 15) / 16) * 16;          /* Round up to nearest multiple of 16 */
+
+    video->input = vid_in;  /* point to the frame input */
+
+    /*//  End ////////////////////////////// */
+
+
+    /**************************************/
+    /* Determine VOP Type                 */
+    /* 6/2/2001, separate function      */
+    /**************************************/
+    DetermineVopType(video, currLayer);
+
+    /****************************/
+    /*    Initialize VOP        */
+    /****************************/
+    video->currVop->volID = currVol->volID;
+    video->currVop->width = width_16;
+    video->currVop->height = height_16;
+    if (video->encParams->H263_Enabled) /*  11/28/05 */
+    {
+        video->currVop->pitch = width_16;
+    }
+    else
+    {
+        video->currVop->pitch = width_16 + 32;
+    }
+    video->currVop->timeInc = currVol->timeIncrement;
+    video->currVop->vopCoded = 1;
+    video->currVop->roundingType = 0;
+    video->currVop->intraDCVlcThr = encParams->IntraDCVlcThr;
+
+    if (currLayer == 0
+#ifdef RANDOM_REFSELCODE   /* add random selection of reference Vop */
+            || random_val[rand_idx] || video->volInitialize[currLayer]
+#endif
+       )
+    {
+        video->tempForwRefVop = video->forwardRefVop; /* keep initial state */
+        if (video->tempForwRefVop != NULL) video->tempRefSelCode = video->tempForwRefVop->refSelectCode;
+
+        video->forwardRefVop = video->prevBaseVop;
+        video->forwardRefVop->refSelectCode = 1;
+    }
+#ifdef RANDOM_REFSELCODE
+    else
+    {
+        video->tempForwRefVop = video->forwardRefVop; /* keep initial state */
+        if (video->tempForwRefVop != NULL) video->tempRefSelCode = video->tempForwRefVop->refSelectCode;
+
+        video->forwardRefVop = video->prevEnhanceVop;
+        video->forwardRefVop->refSelectCode = 0;
+    }
+    rand_idx++;
+    rand_idx %= 30;
+#endif
+
+    video->currVop->refSelectCode = video->forwardRefVop->refSelectCode;
+    video->currVop->gobNumber = 0;
+    video->currVop->gobFrameID = video->currVop->predictionType;
+    video->currVop->temporalRef = ((modTime) * 30 / 1001) % 256;
+
+    video->currVop->temporalInterval = 0;
+
+    if (video->currVop->predictionType == I_VOP)
+        video->currVop->quantizer = encParams->InitQuantIvop[currLayer];
+    else
+        video->currVop->quantizer = encParams->InitQuantPvop[currLayer];
+
+    /****************/
+    /* Encode Vop   */
+    /****************/
+    video->slice_coding = 1;
+
+    /*pv_status =*/
+    EncodeVop(video);
+
+#ifdef _PRINT_STAT
+    if (video->currVop->predictionType == I_VOP)
+        printf(" I-VOP ");
+    else
+        printf(" P-VOP (ref.%d)", video->forwardRefVop->refSelectCode);
+#endif
+
+    /* Set HintTrack Information */
+    if (currVol->prevModuloTimeBase)
+        video->hintTrackInfo.MTB = 1;
+    else
+        video->hintTrackInfo.MTB = 0;
+
+    video->hintTrackInfo.LayerID = (UChar)currVol->volID;
+    video->hintTrackInfo.CodeType = (UChar)video->currVop->predictionType;
+    video->hintTrackInfo.RefSelCode = (UChar)video->currVop->refSelectCode;
+
+    return status;
+}
+#endif /* NO_SLICE_ENCODE */
+
+#ifndef NO_SLICE_ENCODE
+/* ======================================================================== */
+/*  Function : PVEncodePacket()                                             */
+/*  Date     : 04/18/2002                                                   */
+/*  Purpose  : Encode one packet and return bitstream                       */
+/*  In/out   :                                                              */
+/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
+/*  Modified :                                                              */
+/*                                                                          */
+/* ======================================================================== */
+OSCL_EXPORT_REF Bool PVEncodeSlice(VideoEncControls *encCtrl, UChar *bstream, Int *size,
+                                   Int *endofFrame, VideoEncFrameIO *vid_out, ULong *nextModTime)
+{
+    PV_STATUS pv_status;
+    VideoEncData *video = (VideoEncData *)encCtrl->videoEncoderData;
+    VideoEncParams *encParams = video->encParams;
+    Vol *currVol;
+    PV_STATUS   EncodeVOS_Start(VideoEncControls *encCtrl);
+    Vop *temp;
+    void  PaddingEdge(Vop *padVop);
+    Int currLayer = video->currLayer;
+    Int pre_skip;
+    Int pre_size;
+    /**************************************************************/
+    /* Initialize Vol stream structure with application bitstream */
+    /**************************************************************/
+
+    currVol = video->vol[currLayer];
+    currVol->stream->bitstreamBuffer = bstream;
+    pre_size = currVol->stream->byteCount;
+    currVol->stream->bufferSize = pre_size + (*size);
+
+    /***********************************************************/
+    /* Encode VOS and VOL Headers on first call for each layer */
+    /***********************************************************/
+
+    if (video->volInitialize[currLayer])
+    {
+        if (!video->encParams->GetVolHeader[currLayer])
+            pv_status = EncodeVOS_Start(encCtrl);
+    }
+
+    /****************/
+    /* Encode Slice */
+    /****************/
+    pv_status = EncodeSlice(video);
+
+    *endofFrame = 0;
+
+    if (video->mbnum >= currVol->nTotalMB && !video->end_of_buf)
+    {
+        *endofFrame = 1;
+
+        /************************************/
+        /* Update Skip Next Frame           */
+        /************************************/
+        pre_skip = UpdateSkipNextFrame(video, nextModTime, size, pv_status); /* modified such that no pre-skipped */
+
+        if (pre_skip == -1) /* error */
+        {
+            *endofFrame = -1;
+            /* make sure that pointers are restored to the previous state */
+            if (currLayer == 0)
+            {
+                video->forwardRefVop = video->tempForwRefVop; /* For P-Vop base only */
+                video->forwardRefVop->refSelectCode = video->tempRefSelCode;
+            }
+
+            return pv_status;
+        }
+
+        /* If I-VOP was encoded, reset IntraPeriod */
+        if ((currLayer == 0) && (encParams->IntraPeriod > 0) && (video->currVop->predictionType == I_VOP))
+            video->nextEncIVop = encParams->IntraPeriod;
+
+        /**********************************************************/
+        /* Copy Reconstructed Buffer to Output Video Frame Buffer */
+        /**********************************************************/
+        vid_out->yChan = video->currVop->yChan;
+        vid_out->uChan = video->currVop->uChan;
+        vid_out->vChan = video->currVop->vChan;
+        if (video->encParams->H263_Enabled)
+        {
+            vid_out->height = video->currVop->height; /* padded height */
+            vid_out->pitch = video->currVop->width; /* padded width */
+        }
+        else
+        {
+            vid_out->height = video->currVop->height + 32; /* padded height */
+            vid_out->pitch = video->currVop->width + 32; /* padded width */
+        }
+        //vid_out->timestamp = video->modTime;
+        vid_out->timestamp = (ULong)(((video->prevFrameNum[currLayer] * 1000) / encParams->LayerFrameRate[currLayer]) + video->modTimeRef + 0.5);
+
+        /*// End /////////////////////// */
+
+        /****************************************/
+        /* Swap Vop Pointers for Base Layer     */
+        /****************************************/
+
+        if (currLayer == 0)
+        {
+            temp = video->prevBaseVop;
+            video->prevBaseVop = video->currVop;
+            video->prevBaseVop->padded = 0; /* not padded */
+            video->currVop = temp;
+            video->forwardRefVop = video->prevBaseVop; /* For P-Vop base only */
+            video->forwardRefVop->refSelectCode = 1;
+        }
+        else
+        {
+            temp = video->prevEnhanceVop;
+            video->prevEnhanceVop = video->currVop;
+            video->prevEnhanceVop->padded = 0; /* not padded */
+            video->currVop = temp;
+            video->forwardRefVop = video->prevEnhanceVop;
+            video->forwardRefVop->refSelectCode = 0;
+        }
+    }
+
+    /***********************************/
+    /* Update Ouput bstream byte count */
+    /***********************************/
+
+    *size = currVol->stream->byteCount - pre_size;
+
+    /****************************************/
+    /* Modify the intialize flag at the end.*/
+    /****************************************/
+    if (video->volInitialize[currLayer])
+        video->volInitialize[currLayer] = 0;
+
+    return pv_status;
+}
+#endif /* NO_SLICE_ENCODE */
+
+
+/* ======================================================================== */
+/*  Function : PVGetH263ProfileLevelID()                                    */
+/*  Date     : 02/05/2003                                                   */
+/*  Purpose  : Get H.263 Profile ID and level ID for profile 0              */
+/*  In/out   : Profile ID=0, levelID is what we want                        */
+/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
+/*  Modified :                                                              */
+/*  Note     : h263Level[8], rBR_bound[8], max_h263_framerate[2]            */
+/*             max_h263_width[2], max_h263_height[2] are global             */
+/*                                                                          */
+/* ======================================================================== */
+OSCL_EXPORT_REF Bool PVGetH263ProfileLevelID(VideoEncControls *encCtrl, Int *profileID, Int *levelID)
+{
+    VideoEncData *encData;
+    Int width, height;
+    float bitrate_r, framerate;
+
+
+    /* For this version, we only support H.263 profile 0 */
+    *profileID = 0;
+
+    *levelID = 0;
+    encData = (VideoEncData *)encCtrl->videoEncoderData;
+
+    if (encData == NULL)
+        return PV_FALSE;
+    if (encData->encParams == NULL)
+        return PV_FALSE;
+
+    if (!encData->encParams->H263_Enabled) return PV_FALSE;
+
+
+    /* get image width, height, bitrate and framerate */
+    width     = encData->encParams->LayerWidth[0];
+    height    = encData->encParams->LayerHeight[0];
+    bitrate_r = (float)(encData->encParams->LayerBitRate[0]) / (float)64000.0;
+    framerate = encData->encParams->LayerFrameRate[0];
+    if (!width || !height || !(bitrate_r > 0 && framerate > 0)) return PV_FALSE;
+
+    /* This is the most frequent case : level 10 */
+    if (bitrate_r <= rBR_bound[1] && framerate <= max_h263_framerate[0] &&
+            (width <= max_h263_width[0] && height <= max_h263_height[0]))
+    {
+        *levelID = h263Level[1];
+        return PV_TRUE;
+    }
+    else if (bitrate_r > rBR_bound[4] ||
+             (width > max_h263_width[1] || height > max_h263_height[1]) ||
+             framerate > max_h263_framerate[1])    /* check the highest level 70 */
+    {
+        *levelID = h263Level[7];
+        return PV_TRUE;
+    }
+    else   /* search level 20, 30, 40 */
+    {
+
+        /* pick out level 20 */
+        if (bitrate_r <= rBR_bound[2] &&
+                ((width <= max_h263_width[0] && height <= max_h263_height[0] && framerate <= max_h263_framerate[1]) ||
+                 (width <= max_h263_width[1] && height <= max_h263_height[1] && framerate <= max_h263_framerate[0])))
+        {
+            *levelID = h263Level[2];
+            return PV_TRUE;
+        }
+        else   /* width, height and framerate are ok, now choose level 30 or 40 */
+        {
+            *levelID = (bitrate_r <= rBR_bound[3] ? h263Level[3] : h263Level[4]);
+            return PV_TRUE;
+        }
+    }
+}
+
+/* ======================================================================== */
+/*  Function : PVGetMPEG4ProfileLevelID()                                   */
+/*  Date     : 26/06/2008                                                   */
+/*  Purpose  : Get MPEG4 Level after initialized                            */
+/*  In/out   : profile_level according to interface                         */
+/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
+/*  Modified :                                                              */
+/*                                                                          */
+/* ======================================================================== */
+OSCL_EXPORT_REF Bool PVGetMPEG4ProfileLevelID(VideoEncControls *encCtrl, Int *profile_level, Int nLayer)
+{
+    VideoEncData* video;
+    Int i;
+
+    video = (VideoEncData *)encCtrl->videoEncoderData;
+
+    if (nLayer == 0)
+    {
+        for (i = 0; i < 8; i++)
+        {
+            if (video->encParams->ProfileLevel[0] == profile_level_code[i])
+            {
+                break;
+            }
+        }
+        *profile_level = i;
+    }
+    else
+    {
+        for (i = 0; i < 8; i++)
+        {
+            if (video->encParams->ProfileLevel[0] == scalable_profile_level_code[i])
+            {
+                break;
+            }
+        }
+        *profile_level = i + SIMPLE_SCALABLE_PROFILE_LEVEL0;
+    }
+
+    return true;
+}
+
+#ifndef LIMITED_API
+/* ======================================================================== */
+/*  Function : PVUpdateEncFrameRate                                         */
+/*  Date     : 04/08/2002                                                   */
+/*  Purpose  : Update target frame rates of the encoded base and enhance    */
+/*             layer(if any) while encoding operation is ongoing            */
+/*  In/out   :                                                              */
+/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
+/*  Modified :                                                              */
+/*                                                                          */
+/* ======================================================================== */
+
+OSCL_EXPORT_REF Bool PVUpdateEncFrameRate(VideoEncControls *encCtrl, float *frameRate)
+{
+    VideoEncData    *encData;
+    Int i;// nTotalMB, mbPerSec;
+
+    encData = (VideoEncData *)encCtrl->videoEncoderData;
+
+    if (encData == NULL)
+        return PV_FALSE;
+    if (encData->encParams == NULL)
+        return PV_FALSE;
+
+    /* Update the framerates for all the layers */
+    for (i = 0; i < encData->encParams->nLayers; i++)
+    {
+
+        /* New check: encoding framerate should be consistent with the given profile and level */
+        //nTotalMB = (((encData->encParams->LayerWidth[i]+15)/16)*16)*(((encData->encParams->LayerHeight[i]+15)/16)*16)/(16*16);
+        //mbPerSec = (Int)(nTotalMB * frameRate[i]);
+        //if(mbPerSec > encData->encParams->LayerMaxMbsPerSec[i]) return PV_FALSE;
+        if (frameRate[i] > encData->encParams->LayerMaxFrameRate[i]) return PV_FALSE; /* set by users or profile */
+
+        encData->encParams->LayerFrameRate[i] = frameRate[i];
+    }
+
+    return RC_UpdateBXRCParams((void*) encData);
+
+}
+#endif
+#ifndef LIMITED_API
+/* ======================================================================== */
+/*  Function : PVUpdateBitRate                                              */
+/*  Date     : 04/08/2002                                                   */
+/*  Purpose  : Update target bit rates of the encoded base and enhance      */
+/*             layer(if any) while encoding operation is ongoing            */
+/*  In/out   :                                                              */
+/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
+/*  Modified :                                                              */
+/*                                                                          */
+/* ======================================================================== */
+
+OSCL_EXPORT_REF Bool PVUpdateBitRate(VideoEncControls *encCtrl, Int *bitRate)
+{
+    VideoEncData    *encData;
+    Int i;
+
+    encData = (VideoEncData *)encCtrl->videoEncoderData;
+
+    if (encData == NULL)
+        return PV_FALSE;
+    if (encData->encParams == NULL)
+        return PV_FALSE;
+
+    /* Update the bitrates for all the layers */
+    for (i = 0; i < encData->encParams->nLayers; i++)
+    {
+        if (bitRate[i] > encData->encParams->LayerMaxBitRate[i]) /* set by users or profile */
+        {
+            return PV_FALSE;
+        }
+        encData->encParams->LayerBitRate[i] = bitRate[i];
+    }
+
+    return RC_UpdateBXRCParams((void*) encData);
+
+}
+#endif
+#ifndef LIMITED_API
+/* ============================================================================ */
+/*  Function : PVUpdateVBVDelay()                                                   */
+/*  Date     : 4/23/2004                                                        */
+/*  Purpose  : Update VBV buffer size(in delay)                                 */
+/*  In/out   :                                                                  */
+/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                        */
+/*  Modified :                                                                  */
+/*                                                                              */
+/* ============================================================================ */
+
+Bool PVUpdateVBVDelay(VideoEncControls *encCtrl, float delay)
+{
+
+    VideoEncData    *encData;
+    Int total_bitrate, max_buffer_size;
+    int index;
+
+    encData = (VideoEncData *)encCtrl->videoEncoderData;
+
+    if (encData == NULL)
+        return PV_FALSE;
+    if (encData->encParams == NULL)
+        return PV_FALSE;
+
+    /* Check whether the input delay is valid based on the given profile */
+    total_bitrate   = (encData->encParams->nLayers == 1 ? encData->encParams->LayerBitRate[0] :
+                       encData->encParams->LayerBitRate[1]);
+    index = encData->encParams->profile_table_index;
+    max_buffer_size = (encData->encParams->nLayers == 1 ? profile_level_max_VBV_size[index] :
+                       scalable_profile_level_max_VBV_size[index]);
+
+    if (total_bitrate*delay > (float)max_buffer_size)
+        return PV_FALSE;
+
+    encData->encParams->VBV_delay = delay;
+    return PV_TRUE;
+
+}
+#endif
+#ifndef LIMITED_API
+/* ======================================================================== */
+/*  Function : PVUpdateIFrameInterval()                                         */
+/*  Date     : 04/10/2002                                                   */
+/*  Purpose  : updates the INTRA frame refresh interval while encoding      */
+/*             is ongoing                                                   */
+/*  In/out   :                                                              */
+/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
+/*  Modified :                                                              */
+/*                                                                          */
+/* ======================================================================== */
+
+OSCL_EXPORT_REF Bool PVUpdateIFrameInterval(VideoEncControls *encCtrl, Int aIFramePeriod)
+{
+    VideoEncData    *encData;
+
+    encData = (VideoEncData *)encCtrl->videoEncoderData;
+
+    if (encData == NULL)
+        return PV_FALSE;
+    if (encData->encParams == NULL)
+        return PV_FALSE;
+
+    encData->encParams->IntraPeriod = aIFramePeriod;
+    return PV_TRUE;
+}
+#endif
+#ifndef LIMITED_API
+/* ======================================================================== */
+/*  Function : PVSetNumIntraMBRefresh()                                     */
+/*  Date     : 08/05/2003                                                   */
+/*  Purpose  :                                                              */
+/*  In/out   :                                                              */
+/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
+/*  Modified :                                                              */
+/*                                                                          */
+/* ======================================================================== */
+OSCL_EXPORT_REF Bool    PVUpdateNumIntraMBRefresh(VideoEncControls *encCtrl, Int numMB)
+{
+    VideoEncData    *encData;
+
+    encData = (VideoEncData *)encCtrl->videoEncoderData;
+
+    if (encData == NULL)
+        return PV_FALSE;
+
+    encData->encParams->Refresh = numMB;
+
+    return PV_TRUE;
+}
+#endif
+#ifndef LIMITED_API
+/* ======================================================================== */
+/*  Function : PVIFrameRequest()                                            */
+/*  Date     : 04/10/2002                                                   */
+/*  Purpose  : encodes the next base frame as an I-Vop                      */
+/*  In/out   :                                                              */
+/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
+/*  Modified :                                                              */
+/*                                                                          */
+/* ======================================================================== */
+
+OSCL_EXPORT_REF Bool PVIFrameRequest(VideoEncControls *encCtrl)
+{
+    VideoEncData    *encData;
+
+    encData = (VideoEncData *)encCtrl->videoEncoderData;
+
+    if (encData == NULL)
+        return PV_FALSE;
+    if (encData->encParams == NULL)
+        return PV_FALSE;
+
+    encData->nextEncIVop = 1;
+    return PV_TRUE;
+}
+#endif
+#ifndef LIMITED_API
+/* ======================================================================== */
+/*  Function : PVGetEncMemoryUsage()                                        */
+/*  Date     : 10/17/2000                                                   */
+/*  Purpose  :                                                              */
+/*  In/out   :                                                              */
+/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
+/*  Modified :                                                              */
+/*                                                                          */
+/* ======================================================================== */
+
+OSCL_EXPORT_REF Int PVGetEncMemoryUsage(VideoEncControls *encCtrl)
+{
+    VideoEncData    *encData;
+
+    encData = (VideoEncData *)encCtrl->videoEncoderData;
+
+    if (encData == NULL)
+        return PV_FALSE;
+    if (encData->encParams == NULL)
+        return PV_FALSE;
+    return encData->encParams->MemoryUsage;
+}
+#endif
+
+/* ======================================================================== */
+/*  Function : PVGetHintTrack()                                             */
+/*  Date     : 1/17/2001,                                                   */
+/*  Purpose  :                                                              */
+/*  In/out   :                                                              */
+/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
+/*  Modified :                                                              */
+/*                                                                          */
+/* ======================================================================== */
+
+OSCL_EXPORT_REF Bool PVGetHintTrack(VideoEncControls *encCtrl, MP4HintTrack *info)
+{
+    VideoEncData    *encData;
+
+    encData = (VideoEncData *)encCtrl->videoEncoderData;
+
+    if (encData == NULL)
+        return PV_FALSE;
+    if (encData->encParams == NULL)
+        return PV_FALSE;
+    info->MTB = encData->hintTrackInfo.MTB;
+    info->LayerID = encData->hintTrackInfo.LayerID;
+    info->CodeType = encData->hintTrackInfo.CodeType;
+    info->RefSelCode = encData->hintTrackInfo.RefSelCode;
+
+    return PV_TRUE;
+}
+
+/* ======================================================================== */
+/*  Function : PVGetMaxVideoFrameSize()                                     */
+/*  Date     : 7/17/2001,                                                   */
+/*  Purpose  : Function merely returns the maximum buffer size              */
+/*  In/out   :                                                              */
+/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
+/*  Modified :                                                              */
+/*                                                                          */
+/* ======================================================================== */
+
+OSCL_EXPORT_REF Bool PVGetMaxVideoFrameSize(VideoEncControls *encCtrl, Int *maxVideoFrameSize)
+{
+    VideoEncData    *encData;
+
+    encData = (VideoEncData *)encCtrl->videoEncoderData;
+
+    if (encData == NULL)
+        return PV_FALSE;
+    if (encData->encParams == NULL)
+        return PV_FALSE;
+
+
+
+    *maxVideoFrameSize = encData->encParams->BufferSize[0];
+
+    if (encData->encParams->nLayers == 2)
+        if (*maxVideoFrameSize < encData->encParams->BufferSize[1])
+            *maxVideoFrameSize = encData->encParams->BufferSize[1];
+    *maxVideoFrameSize >>= 3;   /* Convert to Bytes */
+
+    if (*maxVideoFrameSize <= 4000)
+        *maxVideoFrameSize = 4000;
+
+    return PV_TRUE;
+}
+#ifndef LIMITED_API
+/* ======================================================================== */
+/*  Function : PVGetVBVSize()                                               */
+/*  Date     : 4/15/2002                                                    */
+/*  Purpose  : Function merely returns the maximum buffer size              */
+/*  In/out   :                                                              */
+/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
+/*  Modified :                                                              */
+/*                                                                          */
+/* ======================================================================== */
+
+OSCL_EXPORT_REF Bool PVGetVBVSize(VideoEncControls *encCtrl, Int *VBVSize)
+{
+    VideoEncData    *encData;
+
+    encData = (VideoEncData *)encCtrl->videoEncoderData;
+
+    if (encData == NULL)
+        return PV_FALSE;
+    if (encData->encParams == NULL)
+        return PV_FALSE;
+
+    *VBVSize = encData->encParams->BufferSize[0];
+    if (encData->encParams->nLayers == 2)
+        *VBVSize += encData->encParams->BufferSize[1];
+
+    return PV_TRUE;
+
+}
+#endif
+/* ======================================================================== */
+/*  Function : EncodeVOS_Start()                                            */
+/*  Date     : 08/22/2000                                                   */
+/*  Purpose  : Encodes the VOS,VO, and VOL or Short Headers                 */
+/*  In/out   :                                                              */
+/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
+/*  Modified :                                                              */
+/*                                                                          */
+/* ======================================================================== */
+PV_STATUS EncodeVOS_Start(VideoEncControls *encoderControl)
+{
+
+    VideoEncData *video = (VideoEncData *)encoderControl->videoEncoderData;
+    Vol         *currVol = video->vol[video->currLayer];
+    PV_STATUS status = PV_SUCCESS;
+    //int profile_level=0x01;
+    BitstreamEncVideo *stream = video->bitstream1;
+    int i, j;
+
+    /********************************/
+    /* Check for short_video_header */
+    /********************************/
+    if (currVol->shortVideoHeader == 1)
+        return status;
+    else
+    {
+        /* Short Video Header or M4V */
+
+        /**************************/
+        /* VisualObjectSequence ()*/
+        /**************************/
+        status = BitstreamPutGT16Bits(stream, 32, SESSION_START_CODE);
+        /*  Determine profile_level */
+        status = BitstreamPutBits(stream, 8, video->encParams->ProfileLevel[video->currLayer]);
+
+        /******************/
+        /* VisualObject() */
+        /******************/
+
+        status = BitstreamPutGT16Bits(stream, 32, VISUAL_OBJECT_START_CODE);
+        status = BitstreamPut1Bits(stream, 0x00); /* visual object identifier */
+        status = BitstreamPutBits(stream, 4, 0x01); /* visual object Type == "video ID" */
+        status = BitstreamPut1Bits(stream, 0x00); /* no video signal type */
+
+        /*temp   = */
+        BitstreamMpeg4ByteAlignStuffing(stream);
+
+
+        status = BitstreamPutGT16Bits(stream, 27, VO_START_CODE);/* byte align: should be 2 bits */
+        status = BitstreamPutBits(stream, 5, 0x00);/*  Video ID = 0  */
+
+
+
+        /**********************/
+        /* VideoObjectLayer() */
+        /**********************/
+        if (currVol->shortVideoHeader == 0)
+        { /* M4V  else Short Video Header */
+            status = BitstreamPutGT16Bits(stream, VOL_START_CODE_LENGTH, VOL_START_CODE);
+            status = BitstreamPutBits(stream, 4, currVol->volID);/*  video_object_layer_id */
+            status = BitstreamPut1Bits(stream, 0x00);/*  Random Access = 0  */
+
+            if (video->currLayer == 0)
+                status = BitstreamPutBits(stream, 8, 0x01);/* Video Object Type Indication = 1  ... Simple Object Type */
+            else
+                status = BitstreamPutBits(stream, 8, 0x02);/* Video Object Type Indication = 2  ... Simple Scalable Object Type */
+
+            status = BitstreamPut1Bits(stream, 0x00);/*  is_object_layer_identifer = 0 */
+
+
+            status = BitstreamPutBits(stream, 4, 0x01); /* aspect_ratio_info = 1 ... 1:1(Square) */
+            status = BitstreamPut1Bits(stream, 0x00);/* vol_control_parameters = 0 */
+            status = BitstreamPutBits(stream, 2, 0x00);/* video_object_layer_shape = 00 ... rectangular */
+            status = BitstreamPut1Bits(stream, 0x01);/* marker bit */
+            status = BitstreamPutGT8Bits(stream, 16, currVol->timeIncrementResolution);/* vop_time_increment_resolution */
+            status = BitstreamPut1Bits(stream, 0x01);/* marker bit */
+            status = BitstreamPut1Bits(stream, currVol->fixedVopRate);/* fixed_vop_rate = 0 */
+
+            /* For Rectangular VO layer shape */
+            status = BitstreamPut1Bits(stream, 0x01);/* marker bit */
+            status = BitstreamPutGT8Bits(stream, 13, currVol->width);/* video_object_layer_width */
+            status = BitstreamPut1Bits(stream, 0x01);/* marker bit */
+            status = BitstreamPutGT8Bits(stream, 13, currVol->height);/* video_object_layer_height */
+            status = BitstreamPut1Bits(stream, 0x01);/*marker bit */
+
+            status = BitstreamPut1Bits(stream, 0x00);/*interlaced = 0 */
+            status = BitstreamPut1Bits(stream, 0x01);/* obmc_disable = 1 */
+            status = BitstreamPut1Bits(stream, 0x00);/* sprite_enable = 0 */
+            status = BitstreamPut1Bits(stream, 0x00);/* not_8_bit = 0 */
+            status = BitstreamPut1Bits(stream, currVol->quantType);/*   quant_type */
+
+            if (currVol->quantType)
+            {
+                status = BitstreamPut1Bits(stream, currVol->loadIntraQuantMat); /* Intra quant matrix */
+                if (currVol->loadIntraQuantMat)
+                {
+                    for (j = 63; j >= 1; j--)
+                        if (currVol->iqmat[*(zigzag_i+j)] != currVol->iqmat[*(zigzag_i+j-1)])
+                            break;
+                    if ((j == 1) && (currVol->iqmat[*(zigzag_i+j)] == currVol->iqmat[*(zigzag_i+j-1)]))
+                        j = 0;
+                    for (i = 0; i < j + 1; i++)
+                        BitstreamPutBits(stream, 8, currVol->iqmat[*(zigzag_i+i)]);
+                    if (j < 63)
+                        BitstreamPutBits(stream, 8, 0);
+                }
+                else
+                {
+                    for (j = 0; j < 64; j++)
+                        currVol->iqmat[j] = mpeg_iqmat_def[j];
+
+                }
+                status = BitstreamPut1Bits(stream, currVol->loadNonIntraQuantMat); /* Non-Intra quant matrix */
+                if (currVol->loadNonIntraQuantMat)
+                {
+                    for (j = 63; j >= 1; j--)
+                        if (currVol->niqmat[*(zigzag_i+j)] != currVol->niqmat[*(zigzag_i+j-1)])
+                            break;
+                    if ((j == 1) && (currVol->niqmat[*(zigzag_i+j)] == currVol->niqmat[*(zigzag_i+j-1)]))
+                        j = 0;
+                    for (i = 0; i < j + 1; i++)
+                        BitstreamPutBits(stream, 8, currVol->niqmat[*(zigzag_i+i)]);
+                    if (j < 63)
+                        BitstreamPutBits(stream, 8, 0);
+                }
+                else
+                {
+                    for (j = 0; j < 64; j++)
+                        currVol->niqmat[j] = mpeg_nqmat_def[j];
+                }
+            }
+
+            status = BitstreamPut1Bits(stream, 0x01);   /* complexity_estimation_disable = 1 */
+            status = BitstreamPut1Bits(stream, currVol->ResyncMarkerDisable);/* Resync_marker_disable */
+            status = BitstreamPut1Bits(stream, currVol->dataPartitioning);/* Data partitioned */
+
+            if (currVol->dataPartitioning)
+                status = BitstreamPut1Bits(stream, currVol->useReverseVLC); /* Reversible_vlc */
+
+
+            if (currVol->scalability) /* Scalability*/
+            {
+
+                status = BitstreamPut1Bits(stream, currVol->scalability);/* Scalability = 1 */
+                status = BitstreamPut1Bits(stream, currVol->scalType);/* hierarchy _type ... Spatial= 0 and Temporal = 1 */
+                status = BitstreamPutBits(stream, 4, currVol->refVolID);/* ref_layer_id  */
+                status = BitstreamPut1Bits(stream, currVol->refSampDir);/* ref_layer_sampling_direc*/
+                status = BitstreamPutBits(stream, 5, currVol->horSamp_n);/*hor_sampling_factor_n*/
+                status = BitstreamPutBits(stream, 5, currVol->horSamp_m);/*hor_sampling_factor_m*/
+                status = BitstreamPutBits(stream, 5, currVol->verSamp_n);/*vert_sampling_factor_n*/
+                status = BitstreamPutBits(stream, 5, currVol->verSamp_m);/*vert_sampling_factor_m*/
+                status = BitstreamPut1Bits(stream, currVol->enhancementType);/* enhancement_type*/
+            }
+            else /* No Scalability */
+                status = BitstreamPut1Bits(stream, currVol->scalability);/* Scalability = 0 */
+
+            /*temp = */
+            BitstreamMpeg4ByteAlignStuffing(stream); /* Byte align Headers for VOP */
+        }
+    }
+
+    return status;
+}
+
+/* ======================================================================== */
+/*  Function : VOS_End()                                                    */
+/*  Date     : 08/22/2000                                                   */
+/*  Purpose  : Visual Object Sequence End                                   */
+/*  In/out   :                                                              */
+/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
+/*  Modified :                                                              */
+/*                                                                          */
+/* ======================================================================== */
+
+PV_STATUS VOS_End(VideoEncControls *encoderControl)
+{
+    PV_STATUS status = PV_SUCCESS;
+    VideoEncData *video = (VideoEncData *)encoderControl->videoEncoderData;
+    Vol         *currVol = video->vol[video->currLayer];
+    BitstreamEncVideo *stream = currVol->stream;
+
+
+    status = BitstreamPutBits(stream, SESSION_END_CODE, 32);
+
+    return status;
+}
+
+/* ======================================================================== */
+/*  Function : DetermineCodingLayer                                         */
+/*  Date     : 06/02/2001                                                   */
+/*  Purpose  : Find layer to code based on current mod time, assuming that
+               it's time to encode enhanced layer.                          */
+/*  In/out   :                                                              */
+/*  Return   : Number of layer to code.                                     */
+/*  Modified :                                                              */
+/*                                                                          */
+/* ======================================================================== */
+
+Int DetermineCodingLayer(VideoEncData *video, Int *nLayer, ULong modTime)
+{
+    Vol **vol = video->vol;
+    VideoEncParams *encParams = video->encParams;
+    Int numLayers = encParams->nLayers;
+    UInt modTimeRef = video->modTimeRef;
+    float *LayerFrameRate = encParams->LayerFrameRate;
+    UInt frameNum[4], frameTick;
+    ULong frameModTime, nextFrmModTime;
+#ifdef REDUCE_FRAME_VARIANCE    /* To limit how close 2 frames can be */
+    float frameInterval;
+#endif
+    float srcFrameInterval;
+    Int frameInc;
+    Int i, extra_skip;
+    Int encodeVop = 0;
+
+    i = numLayers - 1;
+
+    if (modTime - video->nextModTime > ((ULong)(-1)) >> 1) /* next time wrapped around */
+        return 0; /* not time to code it yet */
+
+    video->relLayerCodeTime[i] -= 1000;
+    video->nextEncIVop--;  /* number of Vops in highest layer resolution. */
+    video->numVopsInGOP++;
+
+    /* from this point frameModTime and nextFrmModTime are internal */
+
+    frameNum[i] = (UInt)((modTime - modTimeRef) * LayerFrameRate[i] + 500) / 1000;
+    if (video->volInitialize[i])
+    {
+        video->prevFrameNum[i] = frameNum[i] - 1;
+    }
+    else if (frameNum[i] <= video->prevFrameNum[i])
+    {
+        return 0; /* do not encode this frame */
+    }
+
+    /**** this part computes expected next frame *******/
+    frameModTime = (ULong)(((frameNum[i] * 1000) / LayerFrameRate[i]) + modTimeRef + 0.5); /* rec. time */
+    nextFrmModTime = (ULong)((((frameNum[i] + 1) * 1000) / LayerFrameRate[i]) + modTimeRef + 0.5); /* rec. time */
+
+    srcFrameInterval = 1000 / video->FrameRate;
+
+    video->nextModTime = nextFrmModTime - (ULong)(srcFrameInterval / 2.) - 1; /* between current and next frame */
+
+#ifdef REDUCE_FRAME_VARIANCE    /* To limit how close 2 frames can be */
+    frameInterval = 1000 / LayerFrameRate[i]; /* next rec. time */
+    delta = (Int)(frameInterval / 4); /* empirical number */
+    if (video->nextModTime - modTime  < (ULong)delta) /* need to move nextModTime further. */
+    {
+        video->nextModTime += ((delta - video->nextModTime + modTime)); /* empirical formula  */
+    }
+#endif
+    /****************************************************/
+
+    /* map frame no.to tick from modTimeRef */
+    /*frameTick = (frameNum[i]*vol[i]->timeIncrementResolution) ;
+    frameTick = (UInt)((frameTick + (encParams->LayerFrameRate[i]/2))/encParams->LayerFrameRate[i]);*/
+    /*  11/16/01, change frameTick to be the closest tick from the actual modTime */
+    /*  12/12/02, add (double) to prevent large number wrap-around */
+    frameTick = (Int)(((double)(modTime - modTimeRef) * vol[i]->timeIncrementResolution + 500) / 1000);
+
+    /* find timeIncrement to be put in the bitstream */
+    /* refTick is second boundary reference. */
+    vol[i]->timeIncrement = frameTick - video->refTick[i];
+
+
+    vol[i]->moduloTimeBase = 0;
+    while (vol[i]->timeIncrement >= vol[i]->timeIncrementResolution)
+    {
+        vol[i]->timeIncrement -= vol[i]->timeIncrementResolution;
+        vol[i]->moduloTimeBase++;
+        /* do not update refTick and modTimeRef yet, do it after encoding!! */
+    }
+
+    if (video->relLayerCodeTime[i] <= 0)    /* no skipping */
+    {
+        encodeVop = 1;
+        video->currLayer = *nLayer = i;
+        video->relLayerCodeTime[i] += 1000;
+
+        /* takes care of more dropped frame than expected */
+        extra_skip = -1;
+        frameInc = (frameNum[i] - video->prevFrameNum[i]);
+        extra_skip += frameInc;
+
+        if (extra_skip > 0)
+        {   /* update rc->Nr, rc->B, (rc->Rr)*/
+            video->nextEncIVop -= extra_skip;
+            video->numVopsInGOP += extra_skip;
+            if (encParams->RC_Type != CONSTANT_Q)
+            {
+                RC_UpdateBuffer(video, i, extra_skip);
+            }
+        }
+
+    }
+    /* update frame no. */
+    video->prevFrameNum[i] = frameNum[i];
+
+    /* go through all lower layer */
+    for (i = (numLayers - 2); i >= 0; i--)
+    {
+
+        video->relLayerCodeTime[i] -= 1000;
+
+        /* find timeIncrement to be put in the bitstream */
+        vol[i]->timeIncrement = frameTick - video->refTick[i];
+
+        if (video->relLayerCodeTime[i] <= 0) /* time to encode base */
+        {
+            /* 12/27/00 */
+            encodeVop = 1;
+            video->currLayer = *nLayer = i;
+            video->relLayerCodeTime[i] +=
+                (Int)((1000.0 * encParams->LayerFrameRate[numLayers-1]) / encParams->LayerFrameRate[i]);
+
+            vol[i]->moduloTimeBase = 0;
+            while (vol[i]->timeIncrement >= vol[i]->timeIncrementResolution)
+            {
+                vol[i]->timeIncrement -= vol[i]->timeIncrementResolution;
+                vol[i]->moduloTimeBase++;
+                /* do not update refTick and modTimeRef yet, do it after encoding!! */
+            }
+
+            /* takes care of more dropped frame than expected */
+            frameNum[i] = (UInt)((frameModTime - modTimeRef) * encParams->LayerFrameRate[i] + 500) / 1000;
+            if (video->volInitialize[i])
+                video->prevFrameNum[i] = frameNum[i] - 1;
+
+            extra_skip = -1;
+            frameInc = (frameNum[i] - video->prevFrameNum[i]);
+            extra_skip += frameInc;
+
+            if (extra_skip > 0)
+            {   /* update rc->Nr, rc->B, (rc->Rr)*/
+                if (encParams->RC_Type != CONSTANT_Q)
+                {
+                    RC_UpdateBuffer(video, i, extra_skip);
+                }
+            }
+            /* update frame no. */
+            video->prevFrameNum[i] = frameNum[i];
+        }
+    }
+
+#ifdef _PRINT_STAT
+    if (encodeVop)
+        printf(" TI: %d ", vol[*nLayer]->timeIncrement);
+#endif
+
+    return encodeVop;
+}
+
+/* ======================================================================== */
+/*  Function : DetermineVopType                                             */
+/*  Date     : 06/02/2001                                                   */
+/*  Purpose  : The name says it all.                                        */
+/*  In/out   :                                                              */
+/*  Return   : void .                                                       */
+/*  Modified :                                                              */
+/*                                                                          */
+/* ======================================================================== */
+
+void DetermineVopType(VideoEncData *video, Int currLayer)
+{
+    VideoEncParams *encParams = video->encParams;
+//  Vol *currVol = video->vol[currLayer];
+
+    if (encParams->IntraPeriod == 0) /* I-VOPs only */
+    {
+        if (video->currLayer > 0)
+            video->currVop->predictionType = P_VOP;
+        else
+        {
+            video->currVop->predictionType = I_VOP;
+            if (video->numVopsInGOP >= 132)
+                video->numVopsInGOP = 0;
+        }
+    }
+    else if (encParams->IntraPeriod == -1)  /* IPPPPP... */
+    {
+
+        /* maintain frame type if previous frame is pre-skipped, 06/02/2001 */
+        if (encParams->RC_Type == CONSTANT_Q || video->rc[currLayer]->skip_next_frame != -1)
+            video->currVop->predictionType = P_VOP;
+
+        if (video->currLayer == 0)
+        {
+            if (/*video->numVopsInGOP>=132 || */video->volInitialize[currLayer])
+            {
+                video->currVop->predictionType = I_VOP;
+                video->numVopsInGOP = 0; /* force INTRA update every 132 base frames*/
+                video->nextEncIVop = 1;
+            }
+            else if (video->nextEncIVop == 0 || video->currVop->predictionType == I_VOP)
+            {
+                video->numVopsInGOP = 0;
+                video->nextEncIVop = 1;
+            }
+        }
+    }
+    else   /* IntraPeriod>0 : IPPPPPIPPPPPI... */
+    {
+
+        /* maintain frame type if previous frame is pre-skipped, 06/02/2001 */
+        if (encParams->RC_Type == CONSTANT_Q || video->rc[currLayer]->skip_next_frame != -1)
+            video->currVop->predictionType = P_VOP;
+
+        if (currLayer == 0)
+        {
+            if (video->nextEncIVop <= 0 || video->currVop->predictionType == I_VOP)
+            {
+                video->nextEncIVop = encParams->IntraPeriod;
+                video->currVop->predictionType = I_VOP;
+                video->numVopsInGOP = 0;
+            }
+        }
+    }
+
+    return ;
+}
+
+/* ======================================================================== */
+/*  Function : UpdateSkipNextFrame                                          */
+/*  Date     : 06/02/2001                                                   */
+/*  Purpose  : From rate control frame skipping decision, update timing
+                related parameters.                                         */
+/*  In/out   :                                                              */
+/*  Return   : Current coded layer.                                         */
+/*  Modified :                                                              */
+/*                                                                          */
+/* ======================================================================== */
+
+Int UpdateSkipNextFrame(VideoEncData *video, ULong *modTime, Int *size, PV_STATUS status)
+{
+    Int currLayer = video->currLayer;
+    Int nLayer = currLayer;
+    VideoEncParams *encParams = video->encParams;
+    Int numLayers = encParams->nLayers;
+    Vol *currVol = video->vol[currLayer];
+    Vol **vol = video->vol;
+    Int num_skip, extra_skip;
+    Int i;
+    UInt newRefTick, deltaModTime;
+    UInt temp;
+
+    if (encParams->RC_Type != CONSTANT_Q)
+    {
+        if (video->volInitialize[0] && currLayer == 0)  /* always encode the first frame */
+        {
+            RC_ResetSkipNextFrame(video, currLayer);
+            //return currLayer;  09/15/05
+        }
+        else
+        {
+            if (RC_GetSkipNextFrame(video, currLayer) < 0 || status == PV_END_OF_BUF)   /* Skip Current Frame */
+            {
+
+#ifdef _PRINT_STAT
+                printf("Skip current frame");
+#endif
+                currVol->moduloTimeBase = currVol->prevModuloTimeBase;
+
+                /*********************/
+                /* prepare to return */
+                /*********************/
+                *size = 0;  /* Set Bitstream buffer to zero */
+
+                /* Determine nLayer and modTime for next encode */
+
+                *modTime = video->nextModTime;
+                nLayer = -1;
+
+                return nLayer; /* return immediately without updating RefTick & modTimeRef */
+                /* If I-VOP was attempted, then ensure next base is I-VOP */
+                /*if((encParams->IntraPeriod>0) && (video->currVop->predictionType == I_VOP))
+                video->nextEncIVop = 0; commented out by 06/05/01 */
+
+            }
+            else if ((num_skip = RC_GetSkipNextFrame(video, currLayer)) > 0)
+            {
+
+#ifdef _PRINT_STAT
+                printf("Skip next %d frames", num_skip);
+#endif
+                /* to keep the Nr of enh layer the same */
+                /* adjust relLayerCodeTime only, do not adjust layerCodeTime[numLayers-1] */
+                extra_skip = 0;
+                for (i = 0; i < currLayer; i++)
+                {
+                    if (video->relLayerCodeTime[i] <= 1000)
+                    {
+                        extra_skip = 1;
+                        break;
+                    }
+                }
+
+                for (i = currLayer; i < numLayers; i++)
+                {
+                    video->relLayerCodeTime[i] += (num_skip + extra_skip) *
+                                                  ((Int)((1000.0 * encParams->LayerFrameRate[numLayers-1]) / encParams->LayerFrameRate[i]));
+                }
+            }
+        }/* first frame */
+    }
+    /*****  current frame is encoded, now update refTick ******/
+
+    video->refTick[currLayer] += vol[currLayer]->prevModuloTimeBase * vol[currLayer]->timeIncrementResolution;
+
+    /* Reset layerCodeTime every I-VOP to prevent overflow */
+    if (currLayer == 0)
+    {
+        /*  12/12/02, fix for weird targer frame rate of 9.99 fps or 3.33 fps */
+        if (((encParams->IntraPeriod != 0) /*&& (video->currVop->predictionType==I_VOP)*/) ||
+                ((encParams->IntraPeriod == 0) && (video->numVopsInGOP == 0)))
+        {
+            newRefTick = video->refTick[0];
+
+            for (i = 1; i < numLayers; i++)
+            {
+                if (video->refTick[i] < newRefTick)
+                    newRefTick = video->refTick[i];
+            }
+
+            /* check to make sure that the update is integer multiple of frame number */
+            /* how many msec elapsed from last modTimeRef */
+            deltaModTime = (newRefTick / vol[0]->timeIncrementResolution) * 1000;
+
+            for (i = numLayers - 1; i >= 0; i--)
+            {
+                temp = (UInt)(deltaModTime * encParams->LayerFrameRate[i]); /* 12/12/02 */
+                if (temp % 1000)
+                    newRefTick = 0;
+
+            }
+            if (newRefTick > 0)
+            {
+                video->modTimeRef += deltaModTime;
+                for (i = numLayers - 1; i >= 0; i--)
+                {
+                    video->prevFrameNum[i] -= (UInt)(deltaModTime * encParams->LayerFrameRate[i]) / 1000;
+                    video->refTick[i] -= newRefTick;
+                }
+            }
+        }
+    }
+
+    *modTime =  video->nextModTime;
+
+    return nLayer;
+}
+
+
+#ifndef ORIGINAL_VERSION
+
+/* ======================================================================== */
+/*  Function : SetProfile_BufferSize                                        */
+/*  Date     : 04/08/2002                                                   */
+/*  Purpose  : Set profile and video buffer size, copied from Jim's code    */
+/*             in PVInitVideoEncoder(.), since we have different places     */
+/*             to reset profile and video buffer size                       */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/*                                                                          */
+/* ======================================================================== */
+
+Bool SetProfile_BufferSize(VideoEncData *video, float delay, Int bInitialized)
+{
+    Int i, j, start, end;
+//  Int BaseMBsPerSec = 0, EnhMBsPerSec = 0;
+    Int nTotalMB = 0;
+    Int idx, temp_w, temp_h, max = 0, max_width, max_height;
+
+    Int nLayers = video->encParams->nLayers; /* Number of Layers to be encoded */
+
+    Int total_bitrate = 0, base_bitrate;
+    Int total_packet_size = 0, base_packet_size;
+    Int total_MBsPerSec = 0, base_MBsPerSec;
+    Int total_VBV_size = 0, base_VBV_size, enhance_VBV_size = 0;
+    float total_framerate, base_framerate;
+    float upper_bound_ratio;
+    Int bFound = 0;
+    Int k = 0, width16, height16, index;
+    Int lowest_level;
+
+#define MIN_BUFF    16000 /* 16k minimum buffer size */
+#define BUFF_CONST  2.0    /* 2000ms */
+#define UPPER_BOUND_RATIO 8.54 /* upper_bound = 1.4*(1.1+bound/10)*bitrate/framerate */
+
+#define QCIF_WIDTH  176
+#define QCIF_HEIGHT 144
+
+    index = video->encParams->profile_table_index;
+
+    /* Calculate "nTotalMB" */
+    /* Find the maximum width*height for memory allocation of the VOPs */
+    for (idx = 0; idx < nLayers; idx++)
+    {
+        temp_w = video->encParams->LayerWidth[idx];
+        temp_h = video->encParams->LayerHeight[idx];
+
+        if ((temp_w*temp_h) > max)
+        {
+            max = temp_w * temp_h;
+            max_width = temp_w;
+            max_height = temp_h;
+            nTotalMB = ((max_width + 15) >> 4) * ((max_height + 15) >> 4);
+        }
+    }
+    upper_bound_ratio = (video->encParams->RC_Type == CBR_LOWDELAY ? (float)5.0 : (float)UPPER_BOUND_RATIO);
+
+
+    /* Get the basic information: bitrate, packet_size, MBs/s and VBV_size */
+    base_bitrate        = video->encParams->LayerBitRate[0];
+    if (video->encParams->LayerMaxBitRate[0] != 0) /* video->encParams->LayerMaxBitRate[0] == 0 means it has not been set */
+    {
+        base_bitrate    = PV_MAX(base_bitrate, video->encParams->LayerMaxBitRate[0]);
+    }
+    else /* if the max is not set, set it to the specified profile/level */
+    {
+        video->encParams->LayerMaxBitRate[0] = profile_level_max_bitrate[index];
+    }
+
+    base_framerate      = video->encParams->LayerFrameRate[0];
+    if (video->encParams->LayerMaxFrameRate[0] != 0)
+    {
+        base_framerate  = PV_MAX(base_framerate, video->encParams->LayerMaxFrameRate[0]);
+    }
+    else /* if the max is not set, set it to the specified profile/level */
+    {
+        video->encParams->LayerMaxFrameRate[0] = (float)profile_level_max_mbsPerSec[index] / nTotalMB;
+    }
+
+    base_packet_size    = video->encParams->ResyncPacketsize;
+    base_MBsPerSec      = (Int)(base_framerate * nTotalMB);
+    base_VBV_size       = PV_MAX((Int)(base_bitrate * delay),
+                                 (Int)(upper_bound_ratio * base_bitrate / base_framerate));
+    base_VBV_size       = PV_MAX(base_VBV_size, MIN_BUFF);
+
+    /* if the buffer is larger than maximum buffer size, we'll clip it */
+    if (base_VBV_size > profile_level_max_VBV_size[5])
+        base_VBV_size = profile_level_max_VBV_size[5];
+
+
+    /* Check if the buffer exceeds the maximum buffer size given the maximum profile and level */
+    if (nLayers == 1 && base_VBV_size > profile_level_max_VBV_size[index])
+        return FALSE;
+
+
+    if (nLayers == 2)
+    {
+        total_bitrate       = video->encParams->LayerBitRate[1];
+        if (video->encParams->LayerMaxBitRate[1] != 0)
+        {
+            total_bitrate   = PV_MIN(total_bitrate, video->encParams->LayerMaxBitRate[1]);
+        }
+        else /* if the max is not set, set it to the specified profile/level */
+        {
+            video->encParams->LayerMaxBitRate[1] = scalable_profile_level_max_bitrate[index];
+        }
+
+        total_framerate     = video->encParams->LayerFrameRate[1];
+        if (video->encParams->LayerMaxFrameRate[1] != 0)
+        {
+            total_framerate     = PV_MIN(total_framerate, video->encParams->LayerMaxFrameRate[1]);
+        }
+        else /* if the max is not set, set it to the specified profile/level */
+        {
+            video->encParams->LayerMaxFrameRate[1] = (float)scalable_profile_level_max_mbsPerSec[index] / nTotalMB;
+        }
+
+        total_packet_size   = video->encParams->ResyncPacketsize;
+        total_MBsPerSec     = (Int)(total_framerate * nTotalMB);
+
+        enhance_VBV_size    = PV_MAX((Int)((total_bitrate - base_bitrate) * delay),
+                                     (Int)(upper_bound_ratio * (total_bitrate - base_bitrate) / (total_framerate - base_framerate)));
+        enhance_VBV_size    = PV_MAX(enhance_VBV_size, MIN_BUFF);
+
+        total_VBV_size      = base_VBV_size + enhance_VBV_size;
+
+        /* if the buffer is larger than maximum buffer size, we'll clip it */
+        if (total_VBV_size > scalable_profile_level_max_VBV_size[6])
+        {
+            total_VBV_size = scalable_profile_level_max_VBV_size[6];
+            enhance_VBV_size = total_VBV_size - base_VBV_size;
+        }
+
+        /* Check if the buffer exceeds the maximum buffer size given the maximum profile and level */
+        if (total_VBV_size > scalable_profile_level_max_VBV_size[index])
+            return FALSE;
+    }
+
+
+    if (!bInitialized) /* Has been initialized --> profile @ level has been figured out! */
+    {
+        video->encParams->BufferSize[0] = base_VBV_size;
+        if (nLayers > 1)
+            video->encParams->BufferSize[1] = enhance_VBV_size;
+
+        return PV_TRUE;
+    }
+
+
+    /* Profile @ level determination */
+    if (nLayers == 1)
+    {
+        /* BASE ONLY : Simple Profile(SP) Or Core Profile(CP) */
+        if (base_bitrate     > profile_level_max_bitrate[index]     ||
+                base_packet_size > profile_level_max_packet_size[index] ||
+                base_MBsPerSec   > profile_level_max_mbsPerSec[index]   ||
+                base_VBV_size    > profile_level_max_VBV_size[index])
+
+            return PV_FALSE; /* Beyond the bound of Core Profile @ Level2 */
+
+        /* For H263/Short header, determine k*16384 */
+        width16  = ((video->encParams->LayerWidth[0] + 15) >> 4) << 4;
+        height16 = ((video->encParams->LayerHeight[0] + 15) >> 4) << 4;
+        if (video->encParams->H263_Enabled)
+        {
+            k = 4;
+            if (width16  == 2*QCIF_WIDTH && height16 == 2*QCIF_HEIGHT)  /* CIF */
+                k = 16;
+
+            else if (width16  == 4*QCIF_WIDTH && height16 == 4*QCIF_HEIGHT)  /* 4CIF */
+                k = 32;
+
+            else if (width16  == 8*QCIF_WIDTH && height16 == 8*QCIF_HEIGHT)  /* 16CIF */
+                k = 64;
+
+            video->encParams->maxFrameSize  = k * 16384;
+
+            /* Make sure the buffer size is limited to the top profile and level: the Core profile and level 2 */
+            if (base_VBV_size > (Int)(k*16384 + 4*(float)profile_level_max_bitrate[5]*1001.0 / 30000.0))
+                base_VBV_size = (Int)(k * 16384 + 4 * (float)profile_level_max_bitrate[5] * 1001.0 / 30000.0);
+
+            if (base_VBV_size > (Int)(k*16384 + 4*(float)profile_level_max_bitrate[index]*1001.0 / 30000.0))
+                return PV_FALSE;
+        }
+
+        /* Search the appropriate profile@level index */
+        if (!video->encParams->H263_Enabled &&
+                (video->encParams->IntraDCVlcThr != 0 || video->encParams->SearchRange > 16))
+        {
+            lowest_level = 1; /* cannot allow SPL0 */
+        }
+        else
+        {
+            lowest_level = 0; /* SPL0 */
+        }
+
+        for (i = lowest_level; i <= index; i++)
+        {
+            if (i != 4 && /* skip Core Profile@Level1 because the parameters in it are smaller than those in Simple Profile@Level3 */
+                    base_bitrate     <= profile_level_max_bitrate[i]     &&
+                    base_packet_size <= profile_level_max_packet_size[i] &&
+                    base_MBsPerSec   <= profile_level_max_mbsPerSec[i]   &&
+                    base_VBV_size    <= (video->encParams->H263_Enabled ? (Int)(k*16384 + 4*(float)profile_level_max_bitrate[i]*1001.0 / 30000.0) :
+                                         profile_level_max_VBV_size[i]))
+                break;
+        }
+        if (i > index) return PV_FALSE; /* Nothing found!! */
+
+        /* Found out the actual profile @ level : index "i" */
+        if (i == 0)
+        {
+            /* For Simple Profile @ Level 0, we need to do one more check: image size <= QCIF */
+            if (width16 > QCIF_WIDTH || height16 > QCIF_HEIGHT)
+                i = 1; /* image size > QCIF, then set SP level1 */
+        }
+
+        video->encParams->ProfileLevel[0] = profile_level_code[i];
+        video->encParams->BufferSize[0]   = base_VBV_size;
+
+        if (video->encParams->LayerMaxBitRate[0] == 0)
+            video->encParams->LayerMaxBitRate[0] = profile_level_max_bitrate[i];
+
+        if (video->encParams->LayerMaxFrameRate[0] == 0)
+            video->encParams->LayerMaxFrameRate[0] = PV_MIN(30, (float)profile_level_max_mbsPerSec[i] / nTotalMB);
+
+        /* For H263/Short header, one special constraint for VBV buffer size */
+        if (video->encParams->H263_Enabled)
+            video->encParams->BufferSize[0] = (Int)(k * 16384 + 4 * (float)profile_level_max_bitrate[i] * 1001.0 / 30000.0);
+
+    }
+    else
+    {
+        /* SCALABALE MODE: Simple Scalable Profile(SSP) Or Core Scalable Profile(CSP) */
+
+        if (total_bitrate       > scalable_profile_level_max_bitrate[index]     ||
+                total_packet_size   > scalable_profile_level_max_packet_size[index] ||
+                total_MBsPerSec     > scalable_profile_level_max_mbsPerSec[index]   ||
+                total_VBV_size      > scalable_profile_level_max_VBV_size[index])
+
+            return PV_FALSE; /* Beyond given profile and level */
+
+        /* One-time check: Simple Scalable Profile or Core Scalable Profile */
+        if (total_bitrate       <= scalable_profile_level_max_bitrate[2]        &&
+                total_packet_size   <= scalable_profile_level_max_packet_size[2]    &&
+                total_MBsPerSec     <= scalable_profile_level_max_mbsPerSec[2]      &&
+                total_VBV_size      <= scalable_profile_level_max_VBV_size[2])
+
+        {
+            start = 0;
+            end = index;
+        }
+
+        else
+        {
+            start = 4;
+            end = index;
+        }
+
+
+        /* Search the scalable profile */
+        for (i = start; i <= end; i++)
+        {
+            if (total_bitrate       <= scalable_profile_level_max_bitrate[i]     &&
+                    total_packet_size   <= scalable_profile_level_max_packet_size[i] &&
+                    total_MBsPerSec     <= scalable_profile_level_max_mbsPerSec[i]   &&
+                    total_VBV_size      <= scalable_profile_level_max_VBV_size[i])
+
+                break;
+        }
+        if (i > end) return PV_FALSE;
+
+        /* Search the base profile */
+        if (i == 0)
+        {
+            j = 0;
+            bFound = 1;
+        }
+        else        bFound = 0;
+
+        for (j = start; !bFound && j <= i; j++)
+        {
+            if (base_bitrate        <= profile_level_max_bitrate[j]      &&
+                    base_packet_size    <= profile_level_max_packet_size[j]  &&
+                    base_MBsPerSec      <= profile_level_max_mbsPerSec[j]    &&
+                    base_VBV_size       <= profile_level_max_VBV_size[j])
+
+            {
+                bFound = 1;
+                break;
+            }
+        }
+
+        if (!bFound) // && start == 4)
+            return PV_FALSE; /* mis-match in the profiles between base layer and enhancement layer */
+
+        /* j for base layer, i for enhancement layer */
+        video->encParams->ProfileLevel[0] = profile_level_code[j];
+        video->encParams->ProfileLevel[1] = scalable_profile_level_code[i];
+        video->encParams->BufferSize[0]   = base_VBV_size;
+        video->encParams->BufferSize[1]   = enhance_VBV_size;
+
+        if (video->encParams->LayerMaxBitRate[0] == 0)
+            video->encParams->LayerMaxBitRate[0] = profile_level_max_bitrate[j];
+
+        if (video->encParams->LayerMaxBitRate[1] == 0)
+            video->encParams->LayerMaxBitRate[1] = scalable_profile_level_max_bitrate[i];
+
+        if (video->encParams->LayerMaxFrameRate[0] == 0)
+            video->encParams->LayerMaxFrameRate[0] = PV_MIN(30, (float)profile_level_max_mbsPerSec[j] / nTotalMB);
+
+        if (video->encParams->LayerMaxFrameRate[1] == 0)
+            video->encParams->LayerMaxFrameRate[1] = PV_MIN(30, (float)scalable_profile_level_max_mbsPerSec[i] / nTotalMB);
+
+
+    } /* end of: if(nLayers == 1) */
+
+
+    if (!video->encParams->H263_Enabled && (video->encParams->ProfileLevel[0] == 0x08)) /* SPL0 restriction*/
+    {
+        /* PV only allow frame-based rate control, no QP change from one MB to another
+        if(video->encParams->ACDCPrediction == TRUE && MB-based rate control)
+         return PV_FALSE */
+    }
+
+    return PV_TRUE;
+}
+
+#endif /* #ifndef ORIGINAL_VERSION */
+
+
+
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/mp4enc_lib.h b/media/libstagefright/codecs/m4v_h263/enc/src/mp4enc_lib.h
new file mode 100644
index 0000000..8293576
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/mp4enc_lib.h
@@ -0,0 +1,207 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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 _MP4ENC_LIB_H_
+#define _MP4ENC_LIB_H_
+
+#include "mp4def.h"     // typedef
+#include "mp4lib_int.h" // main video structure
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    /* defined in vop.c */
+    PV_STATUS EncodeVop(VideoEncData *video);
+    PV_STATUS EncodeSlice(VideoEncData *video);
+    PV_STATUS EncodeVideoPacketHeader(VideoEncData *video, int MB_number,
+                                      int quant_scale, Int insert);
+#ifdef ALLOW_VOP_NOT_CODED
+    PV_STATUS EncodeVopNotCoded(VideoEncData *video, UChar *bstream, Int *size, ULong modTime);
+#endif
+
+    /* defined in combined_decode.c */
+    PV_STATUS EncodeFrameCombinedMode(VideoEncData *video);
+    PV_STATUS EncodeSliceCombinedMode(VideoEncData *video);
+
+    /* defined in datapart_decode.c */
+    PV_STATUS EncodeFrameDataPartMode(VideoEncData *video);
+    PV_STATUS EncodeSliceDataPartMode(VideoEncData *video);
+
+    /* defined in fastcodeMB.c */
+
+//void m4v_memset(void *adr_dst, uint8 value, uint32 size);
+
+    PV_STATUS CodeMB_H263(VideoEncData *video, approxDCT *function, Int offsetQP, Int ncoefblck[]);
+#ifndef NO_MPEG_QUANT
+    PV_STATUS CodeMB_MPEG(VideoEncData *video, approxDCT *function, Int offsetQP, Int ncoefblck[]);
+#endif
+    Int getBlockSAV(Short block[]);
+    Int Sad8x8(UChar *rec, UChar *prev, Int lx);
+    Int getBlockSum(UChar *rec, Int lx);
+
+    /* defined in dct.c */
+    void  blockIdct(Short *block);
+    void blockIdct_SSE(Short *input);
+    void BlockDCTEnc(Short *blockData, Short *blockCoeff);
+
+    /*---- FastQuant.c -----*/
+    Int cal_dc_scalerENC(Int QP, Int type) ;
+    Int BlockQuantDequantH263Inter(Short *rcoeff, Short *qcoeff, struct QPstruct *QuantParam,
+                                   UChar bitmapcol[ ], UChar *bitmaprow, UInt *bitmapzz,
+                                   Int dctMode, Int comp, Int dummy, UChar shortHeader);
+
+    Int BlockQuantDequantH263Intra(Short *rcoeff, Short *qcoeff, struct QPstruct *QuantParam,
+                                   UChar bitmapcol[ ], UChar *bitmaprow, UInt *bitmapzz,
+                                   Int dctMode, Int comp, Int dc_scaler, UChar shortHeader);
+
+    Int BlockQuantDequantH263DCInter(Short *rcoeff, Short *qcoeff, struct QPstruct *QuantParam,
+                                     UChar *bitmaprow, UInt *bitmapzz, Int dummy, UChar shortHeader);
+
+    Int BlockQuantDequantH263DCIntra(Short *rcoeff, Short *qcoeff, struct QPstruct *QuantParam,
+                                     UChar *bitmaprow, UInt *bitmapzz, Int dc_scaler, UChar shortHeader);
+
+#ifndef NO_MPEG_QUANT
+    Int BlockQuantDequantMPEGInter(Short *rcoeff, Short *qcoeff, Int QP, Int *qmat,
+                                   UChar bitmapcol[ ], UChar *bitmaprow, UInt *bitmapzz,
+                                   Int DctMode, Int comp, Int dc_scaler);
+
+    Int BlockQuantDequantMPEGIntra(Short *rcoeff, Short *qcoeff, Int QP, Int *qmat,
+                                   UChar bitmapcol[ ], UChar *bitmaprow, UInt *bitmapzz,
+                                   Int DctMode, Int comp, Int dc_scaler);
+
+    Int BlockQuantDequantMPEGDCInter(Short *rcoeff, Short *qcoeff, Int QP, Int *qmat,
+                                     UChar bitmapcol[ ], UChar *bitmaprow, UInt *bitmapzz, Int dummy);
+
+    Int BlockQuantDequantMPEGDCIntra(Short *rcoeff, Short *qcoeff, Int QP, Int *qmat,
+                                     UChar bitmapcol[ ], UChar *bitmaprow, UInt *bitmapzz, Int dc_scaler);
+#endif
+
+    /*---- FastIDCT.c -----*/
+    void BlockIDCTMotionComp(Short *block, UChar *bitmapcol, UChar bitmaprow,
+                             Int dctMode, UChar *rec, UChar *prev, Int lx_intra_zeroMV);
+
+
+    /* defined in motion_comp.c */
+    void getMotionCompensatedMB(VideoEncData *video, Int ind_x, Int ind_y, Int offset);
+    void EncPrediction_INTER(Int xpred, Int ypred, UChar *c_prev, UChar *c_rec,
+                             Int width, Int round1);
+
+    void EncPrediction_INTER4V(Int xpred, Int ypred, MOT *mot, UChar *c_prev, UChar *c_rec,
+                               Int width, Int round1);
+
+    void EncPrediction_Chrom(Int xpred, Int ypred, UChar *cu_prev, UChar *cv_prev, UChar *cu_rec,
+                             UChar *cv_rec, Int pitch_uv, Int width_uv, Int height_uv, Int round1);
+
+    void get_MB(UChar *c_prev, UChar *c_prev_u  , UChar *c_prev_v,
+                Short mb[6][64], Int width, Int width_uv);
+
+    void PutSkippedBlock(UChar *rec, UChar *prev, Int lx);
+
+    /* defined in motion_est.c */
+    void MotionEstimation(VideoEncData *video);
+#ifdef HTFM
+    void InitHTFM(VideoEncData *video, HTFM_Stat *htfm_stat, double *newvar, Int *collect);
+    void UpdateHTFM(VideoEncData *video, double *newvar, double *exp_lamda, HTFM_Stat *htfm_stat);
+#endif
+
+    /* defined in ME_utils.c */
+    void ChooseMode_C(UChar *Mode, UChar *cur, Int lx, Int min_SAD);
+    void ChooseMode_MMX(UChar *Mode, UChar *cur, Int lx, Int min_SAD);
+    void GetHalfPelMBRegion_C(UChar *cand, UChar *hmem, Int lx);
+    void GetHalfPelMBRegion_SSE(UChar *cand, UChar *hmem, Int lx);
+    void GetHalfPelBlkRegion(UChar *cand, UChar *hmem, Int lx);
+    void PaddingEdge(Vop *padVop);
+    void ComputeMBSum_C(UChar *cur, Int lx, MOT *mot_mb);
+    void ComputeMBSum_MMX(UChar *cur, Int lx, MOT *mot_mb);
+    void ComputeMBSum_SSE(UChar *cur, Int lx, MOT *mot_mb);
+    void GetHalfPelMBRegionPadding(UChar *ncand, UChar *hmem, Int lx, Int *reptl);
+    void GetHalfPelBlkRegionPadding(UChar *ncand, UChar *hmem, Int lx, Int *reptl);
+
+    /* defined in findhalfpel.c */
+    void FindHalfPelMB(VideoEncData *video, UChar *cur, MOT *mot, UChar *ncand,
+                       Int xpos, Int ypos, Int *xhmin, Int *yhmin, Int hp_guess);
+    Int  FindHalfPelBlk(VideoEncData *video, UChar *cur, MOT *mot, Int sad16, UChar *ncand8[],
+                        UChar *mode, Int xpos, Int ypos, Int *xhmin, Int *yhmin, UChar *hp_mem);
+
+
+    /* defined in sad.c */
+    Int SAD_MB_HalfPel_Cxhyh(UChar *ref, UChar *blk, Int dmin_lx, void *extra_info);
+    Int SAD_MB_HalfPel_Cyh(UChar *ref, UChar *blk, Int dmin_lx, void *extra_info);
+    Int SAD_MB_HalfPel_Cxh(UChar *ref, UChar *blk, Int dmin_lx, void *extra_info);
+    Int SAD_MB_HalfPel_MMX(UChar *ref, UChar *blk, Int dmin_lx, void *extra_info);
+    Int SAD_MB_HalfPel_SSE(UChar *ref, UChar *blk, Int dmin_lx, void *extra_info);
+    Int SAD_Blk_HalfPel_C(UChar *ref, UChar *blk, Int dmin, Int lx, Int rx, Int xh, Int yh, void *extra_info);
+    Int SAD_Blk_HalfPel_MMX(UChar *ref, UChar *blk, Int dmin, Int lx, void *extra_info);
+    Int SAD_Blk_HalfPel_SSE(UChar *ref, UChar *blk, Int dmin, Int lx, void *extra_info);
+    Int SAD_Macroblock_C(UChar *ref, UChar *blk, Int dmin_lx, void *extra_info);
+    Int SAD_Macroblock_MMX(UChar *ref, UChar *blk, Int dmin_lx, void *extra_info);
+    Int SAD_Macroblock_SSE(UChar *ref, UChar *blk, Int dmin_lx, void *extra_info);
+    Int SAD_Block_C(UChar *ref, UChar *blk, Int dmin, Int lx, void *extra_info);
+    Int SAD_Block_MMX(UChar *ref, UChar *blk, Int dmin, Int lx, void *extra_info);
+    Int SAD_Block_SSE(UChar *ref, UChar *blk, Int dmin, Int lx, void *extra_info);
+
+#ifdef HTFM /* Hypothesis Testing Fast Matching */
+    Int SAD_MB_HP_HTFM_Collectxhyh(UChar *ref, UChar *blk, Int dmin_x, void *extra_info);
+    Int SAD_MB_HP_HTFM_Collectyh(UChar *ref, UChar *blk, Int dmin_x, void *extra_info);
+    Int SAD_MB_HP_HTFM_Collectxh(UChar *ref, UChar *blk, Int dmin_x, void *extra_info);
+    Int SAD_MB_HP_HTFMxhyh(UChar *ref, UChar *blk, Int dmin_lx, void *extra_info);
+    Int SAD_MB_HP_HTFMyh(UChar *ref, UChar *blk, Int dmin_lx, void *extra_info);
+    Int SAD_MB_HP_HTFMxh(UChar *ref, UChar *blk, Int dmin_lx, void *extra_info);
+    Int SAD_MB_HTFM_Collect(UChar *ref, UChar *blk, Int dmin_lx, void *extra_info);
+    Int SAD_MB_HTFM(UChar *ref, UChar *blk, Int dmin_lx, void *extra_info);
+#endif
+    /* on-the-fly padding */
+    Int SAD_Blk_PADDING(UChar *ref, UChar *cur, Int dmin, Int lx, void *extra_info);
+    Int SAD_MB_PADDING(UChar *ref, UChar *cur, Int dmin, Int lx, void *extra_info);
+#ifdef HTFM
+    Int SAD_MB_PADDING_HTFM_Collect(UChar *ref, UChar *blk, Int dmin, Int lx, void *extra_info);
+    Int SAD_MB_PADDING_HTFM(UChar *ref, UChar *blk, Int dmin, Int lx, void *extra_info);
+#endif
+
+    /* defined in rate_control.c */
+    /* These are APIs to rate control exposed to core encoder module. */
+    PV_STATUS RC_Initialize(void *video);
+    PV_STATUS RC_VopQPSetting(VideoEncData *video, rateControl *rc[]);
+    PV_STATUS RC_VopUpdateStat(VideoEncData *video, rateControl *rc);
+    PV_STATUS RC_MBQPSetting(VideoEncData *video, rateControl *rc, Int start_packet_header);
+    PV_STATUS RC_MBUpdateStat(VideoEncData *video, rateControl *rc, Int Bi, Int Hi);
+    PV_STATUS RC_Cleanup(rateControl *rc[], Int numLayers);
+
+    Int       RC_GetSkipNextFrame(VideoEncData *video, Int currLayer);
+    Int       RC_GetRemainingVops(VideoEncData *video, Int currLayer);
+    void      RC_ResetSkipNextFrame(VideoEncData *video, Int currLayer);
+    PV_STATUS RC_UpdateBuffer(VideoEncData *video, Int currLayer, Int num_skip);
+    PV_STATUS RC_UpdateBXRCParams(void *input);
+
+
+    /* defined in vlc_encode.c */
+    void MBVlcEncodeDataPar_I_VOP(VideoEncData *video, Int ncoefblck[], void *blkCodePtr);
+    void MBVlcEncodeDataPar_P_VOP(VideoEncData *video, Int ncoefblck[], void *blkCodePtr);
+    void MBVlcEncodeCombined_I_VOP(VideoEncData *video, Int ncoefblck[], void *blkCodePtr);
+    void MBVlcEncodeCombined_P_VOP(VideoEncData *video, Int ncoefblck[], void *blkCodePtr);
+    void BlockCodeCoeff_ShortHeader(RunLevelBlock *RLB, BitstreamEncVideo *bs, Int j_start, Int j_stop, UChar Mode);
+    void BlockCodeCoeff_RVLC(RunLevelBlock *RLB, BitstreamEncVideo *bs, Int j_start, Int j_stop, UChar Mode);
+    void BlockCodeCoeff_Normal(RunLevelBlock *RLB, BitstreamEncVideo *bs, Int j_start, Int j_stop, UChar Mode);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _MP4ENC_LIB_H_ */
+
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/mp4lib_int.h b/media/libstagefright/codecs/m4v_h263/enc/src/mp4lib_int.h
new file mode 100644
index 0000000..3bc9421
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/mp4lib_int.h
@@ -0,0 +1,472 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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 _MP4LIB_INT_H_
+#define _MP4LIB_INT_H_
+
+#include "mp4def.h"
+#include "mp4enc_api.h"
+#include "rate_control.h"
+
+/* BitstreamEncVideo will be modified */
+typedef struct tagBitstream
+{
+    Int(*writeVideoPacket)(UChar *buf, Int nbytes_required);   /*write video packet out */
+    UChar *bitstreamBuffer; /*buffer to hold one video packet*/
+    Int bufferSize; /*total bitstream buffer size in bytes */
+    Int byteCount;  /*how many bytes already encoded*/
+    UInt word;      /*hold one word temporarily */
+    Int bitLeft;    /*number of bits left in "word" */
+    UChar* overrunBuffer;  /* pointer to overrun buffer */
+    Int oBSize;     /* length of overrun buffer */
+    struct tagVideoEncData *video;
+} BitstreamEncVideo;
+
+typedef struct tagVOP
+{
+    PIXEL   *yChan;             /* The Y component */
+    PIXEL   *uChan;             /* The U component */
+    PIXEL   *vChan;             /* The V component */
+    Int     frame;              /* frame number */
+    Int     volID;              /* Layer number */
+    //Int       timeStamp;          /* Vop TimeStamp in msec */
+
+    /* Syntax elements copied from VOL (standard) */
+    Int     width;              /* Width (multiple of 16) */
+    Int     height;             /* Height (multiple of 16) */
+    Int     pitch;              /* Pitch (differs from width for UMV case) */
+    Int     padded;     /* flag whether this frame has been padded */
+
+    /* Actual syntax elements for VOP (standard) */
+    Int     predictionType;     /* VOP prediction type */
+    Int     timeInc;            /* VOP time increment (relative to last mtb) */
+    Int     vopCoded;
+    Int     roundingType;
+    Int     intraDCVlcThr;
+    Int     quantizer;          /* VOP quantizer */
+    Int     fcodeForward;       /* VOP dynamic range of motion vectors */
+    Int     fcodeBackward;      /* VOP dynamic range of motion vectors */
+    Int     refSelectCode;      /* enhancement layer reference select code */
+
+    /* H.263 parameters */
+    Int     gobNumber;
+    Int     gobFrameID;
+    Int     temporalRef;        /* temporal reference, roll over at 256 */
+    Int     temporalInterval;   /* increase every 256 temporalRef */
+
+} Vop;
+
+typedef struct tagVol
+{
+    Int     volID;              /* VOL identifier (for tracking) */
+    Int     shortVideoHeader;   /* shortVideoHeader mode */
+    Int     GOVStart;           /* Insert GOV Header */
+    Int     timeIncrementResolution;    /* VOL time increment */
+    Int     nbitsTimeIncRes;    /* number of bits for time increment */
+    Int     timeIncrement;      /* time increment */
+    Int     moduloTimeBase;     /* internal decoder clock */
+    Int     prevModuloTimeBase; /* in case of pre-frameskip */
+
+    Int     fixedVopRate;
+    BitstreamEncVideo  *stream; /* library bitstream buffer (input buffer) */
+
+    /* VOL Dimensions */
+    Int     width;              /* Width */
+    Int     height;             /* Height */
+
+    /* Error Resilience Flags */
+    Int     ResyncMarkerDisable; /* VOL Disable Resynch Markers */
+    Int     useReverseVLC;      /* VOL reversible VLCs */
+    Int     dataPartitioning;   /* VOL data partitioning */
+
+    /* Quantization related parameters */
+    Int     quantPrecision;     /* Quantizer precision */
+    Int     quantType;          /* MPEG-4 or H.263 Quantization Type */
+
+    /* Added loaded quant mat, 05/22/2000 */
+    Int     loadIntraQuantMat;      /* Load intra quantization matrix */
+    Int     loadNonIntraQuantMat;   /* Load nonintra quantization matrix */
+    Int     iqmat[64];          /* Intra quant.matrix */
+    Int     niqmat[64];         /* Non-intra quant.matrix */
+
+
+    /* Parameters used for scalability */
+    Int     scalability;        /* VOL scalability (flag) */
+    Int     scalType;           /* temporal = 0, spatial = 1, both = 2 */
+
+    Int     refVolID;           /* VOL id of reference VOL */
+    Int     refSampDir;         /* VOL resol. of ref. VOL */
+    Int     horSamp_n;          /* VOL hor. resampling of ref. VOL given by */
+    Int     horSamp_m;          /* sampfac = hor_samp_n/hor_samp_m      */
+    Int     verSamp_n;          /* VOL ver. resampling of ref. VOL given by */
+    Int     verSamp_m;          /* sampfac = ver_samp_n/ver_samp_m      */
+    Int     enhancementType;    /* VOL type of enhancement layer */
+
+    /* These variables were added since they are used a lot. */
+    Int     nMBPerRow, nMBPerCol;   /* number of MBs in each row & column    */
+    Int     nTotalMB;
+    Int     nBitsForMBID;           /* how many bits required for MB number? */
+
+    /* for short video header */
+    Int     nMBinGOB;           /* number of MBs in GOB, 05/22/00 */
+    Int     nGOBinVop;          /* number of GOB in Vop  05/22/00 */
+} Vol;
+
+typedef struct tagMacroBlock
+{
+    Int     mb_x;               /* X coordinate */
+    Int     mb_y;               /* Y coordinate */
+    Short   block[9][64];       /* 4-Y, U and V blocks , and AAN Scale*/
+} MacroBlock;
+
+typedef struct tagRunLevelBlock
+{
+    Int run[64];        /* Runlength */
+    Int level[64];      /* Abs(level) */
+    Int s[64];          /* sign level */
+} RunLevelBlock;
+
+typedef struct tagHeaderInfoDecVideo
+{
+    UChar       *Mode;              /* Modes INTRA/INTER/etc. */
+    UChar       *CBP;               /* MCBPC/CBPY stuff */
+} HeaderInfoEncVideo;
+
+typedef Short typeDCStore[6];   /* ACDC */
+typedef Short typeDCACStore[4][8];
+
+typedef struct tagMOT
+{
+    Int x;  /* half-pel resolution x component */
+    Int y;      /* half-pel resolution y component */
+    Int sad;  /* SAD */
+} MOT;
+
+typedef struct tagHintTrackInfo
+{
+    UChar MTB;
+    UChar LayerID;
+    UChar CodeType;
+    UChar RefSelCode;
+
+} HintTrackInfo;
+
+
+typedef struct tagVideoEncParams
+{
+    //Int       Width;                  /* Input Width */
+    //Int       Height;                 /* Input Height */
+    //float FrameRate;              /* Input Frame Rate */
+    UInt    TimeIncrementRes;       /* timeIncrementRes */
+
+    /*VOL Parameters */
+    Int     nLayers;
+    Int     LayerWidth[4];          /* Encoded Width */
+    Int     LayerHeight[4];         /* Encoded Height */
+    float   LayerFrameRate[4];      /* Encoded Frame Rate */
+    Int     LayerBitRate[4];        /* Encoded BitRate */
+    Int     LayerMaxBitRate[4];     /* Maximum Encoded BitRate */
+    float   LayerMaxFrameRate[4];   /* Maximum Encoded Frame Rate */
+    Int     LayerMaxMbsPerSec[4];   /* Maximum mbs per second, according to the specified profile and level */
+    Int     LayerMaxBufferSize[4];  /* Maximum buffer size, according to the specified profile and level */
+
+    Bool    ResyncMarkerDisable;    /* Disable Resync Marker */
+    Bool    DataPartitioning;       /* Base Layer Data Partitioning */
+    Bool    ReversibleVLC;          /* RVLC when Data Partitioning */
+    Bool    ACDCPrediction;         /* AC/DC Prediction    */
+    Int     QuantType[4];           /* H263, MPEG2 */
+    Int     InitQuantBvop[4];
+    Int     InitQuantPvop[4];
+    Int     InitQuantIvop[4];
+    Int     ResyncPacketsize;
+
+    Int     RoundingType;
+    Int     IntraDCVlcThr;
+
+    /* Rate Control Parameters */
+    MP4RateControlType  RC_Type;        /*Constant Q, M4 constantRate, VM5+, M4RC,MPEG2TM5 */
+
+    /* Intra Refresh Parameters */
+    Int     IntraPeriod;            /* Intra update period */
+    Int     Refresh;                /* Number of MBs refresh in each frame */
+    /* Other Parameters */
+    Bool    SceneChange_Det;        /* scene change detection */
+    Bool    FineFrameSkip_Enabled;  /* src rate resolution frame skipping */
+    Bool    VBR_Enabled;            /* VBR rate control */
+    Bool    NoFrameSkip_Enabled;    /* do not allow frame skip */
+    Bool    NoPreSkip_Enabled;      /* do not allow pre-skip */
+
+    Bool    H263_Enabled;           /* H263 Short Header */
+    Bool    GOV_Enabled;            /* GOV Header Enabled */
+    Bool    SequenceStartCode;      /* This probably should be removed */
+    Bool    FullSearch_Enabled;     /* full-pel exhaustive search motion estimation */
+    Bool    HalfPel_Enabled;        /* Turn Halfpel ME on or off */
+    Bool    MV8x8_Enabled;          /* Enable 8x8 motion vectors */
+    Bool    RD_opt_Enabled;         /* Enable operational R-D optimization */
+    Int     GOB_Header_Interval;        /* Enable encoding GOB header in H263_WITH_ERR_RES and SHORT_HERDER_WITH_ERR_RES */
+    Int     SearchRange;            /* Search range for 16x16 motion vector */
+    Int     MemoryUsage;            /* Amount of memory allocated */
+    Int     GetVolHeader[2];        /* Flag to check if Vol Header has been retrieved */
+    Int     BufferSize[2];          /* Buffer Size for Base and Enhance Layers */
+    Int     ProfileLevel[2];        /* Profile and Level for encoding purposes */
+    float   VBV_delay;              /* VBV buffer size in the form of delay */
+    Int     maxFrameSize;           /* maximum frame size(bits) for H263/Short header mode, k*16384 */
+    Int     profile_table_index;    /* index for profile and level tables given the specified profile and level */
+
+} VideoEncParams;
+
+/* platform dependent functions */
+typedef struct tagFuncPtr
+{
+//  Int (*SAD_MB_HalfPel)(UChar *ref,UChar *blk,Int dmin_lx,Int xh,Int yh,void *extra_info);
+    Int(*SAD_MB_HalfPel[4])(UChar*, UChar*, Int, void *);
+    Int(*SAD_Blk_HalfPel)(UChar *ref, UChar *blk, Int dmin, Int lx, Int rx, Int xh, Int yh, void *extra_info);
+    Int(*SAD_Macroblock)(UChar *ref, UChar *blk, Int dmin_lx, void *extra_info);
+    Int(*SAD_Block)(UChar *ref, UChar *blk, Int dmin, Int lx, void *extra_info);
+    Int(*SAD_MB_PADDING)(UChar *ref, UChar *blk, Int dmin, Int lx, void *extra_info); /*, 4/21/01 */
+    void (*ComputeMBSum)(UChar *cur, Int lx, MOT *mot_mb);
+    void (*ChooseMode)(UChar *Mode, UChar *cur, Int lx, Int min_SAD);
+    void (*GetHalfPelMBRegion)(UChar *cand, UChar *hmem, Int lx);
+    void (*blockIdct)(Int *block);
+
+
+} FuncPtr;
+
+/* 04/09/01, for multipass rate control */
+
+typedef struct tagRDInfo
+{
+    Int QP;
+    Int actual_bits;
+    float mad;
+    float R_D;
+} RDInfo;
+
+typedef struct tagMultiPass
+{
+    /* multipass rate control data */
+    Int target_bits;    /* target bits for current frame, = rc->T */
+    Int actual_bits;    /* actual bits for current frame obtained after encoding, = rc->Rc*/
+    Int QP;             /* quantization level for current frame, = rc->Qc*/
+    Int prev_QP;        /* quantization level for previous frame */
+    Int prev_prev_QP;   /* quantization level for previous frame before last*/
+    float mad;          /* mad for current frame, = video->avgMAD*/
+    Int bitrate;        /* bitrate for current frame */
+    float framerate;    /* framerate for current frame*/
+
+    Int nRe_Quantized;  /* control variable for multipass encoding, */
+    /* 0 : first pass */
+    /* 1 : intermediate pass(quantization and VLC loop only) */
+    /* 2 : final pass(de-quantization, idct, etc) */
+    /* 3 : macroblock level rate control */
+
+    Int encoded_frames;     /* counter for all encoded frames */
+    Int re_encoded_frames;  /* counter for all multipass encoded frames*/
+    Int re_encoded_times;   /* counter for all times of multipass frame encoding */
+
+    /* Multiple frame prediction*/
+    RDInfo **pRDSamples;        /* pRDSamples[30][32], 30->30fps, 32 -> 5 bit quantizer, 32 candidates*/
+    Int framePos;               /* specific position in previous multiple frames*/
+    Int frameRange;             /* number of overall previous multiple frames */
+    Int samplesPerFrame[30];    /* number of samples per frame, 30->30fps */
+
+    /* Bit allocation for scene change frames and high motion frames */
+    float sum_mad;
+    Int counter_BTsrc;  /* BT = Bit Transfer, bit transfer from low motion frames or less complicatedly compressed frames */
+    Int counter_BTdst;  /* BT = Bit Transfer, bit transfer to scene change frames or high motion frames or more complicatedly compressed frames */
+    float sum_QP;
+    Int diff_counter;   /* diff_counter = -diff_counter_BTdst, or diff_counter_BTsrc */
+
+    /* For target bitrate or framerate update */
+    float target_bits_per_frame;        /* = C = bitrate/framerate */
+    float target_bits_per_frame_prev;   /* previous C */
+    float aver_mad;                     /* so-far average mad could replace sum_mad */
+    float aver_mad_prev;                /* previous average mad */
+    Int   overlapped_win_size;          /* transition period of time */
+    Int   encoded_frames_prev;          /* previous encoded_frames */
+} MultiPass;
+
+/* End */
+
+#ifdef HTFM
+typedef struct tagHTFM_Stat
+{
+    Int abs_dif_mad_avg;
+    UInt countbreak;
+    Int offsetArray[16];
+    Int offsetRef[16];
+} HTFM_Stat;
+#endif
+
+/* Global structure that can be passed around */
+typedef struct tagVideoEncData
+{
+    /* VOL Header Initialization */
+    UChar   volInitialize[4];       /* Used to Write VOL Headers */
+    /* Data For Layers (Scalability) */
+    Int     numberOfLayers;     /* Number of Layers */
+    Vol     **vol;              /* Data stored for each VOL */
+
+    /* Data used for encoding frames */
+    VideoEncFrameIO *input;     /* original input frame */
+    Vop     *currVop;           /* Current reconstructed VOP */
+    Vop     *prevBaseVop;       /* Previous reference Base Vop */
+    Vop     *nextBaseVop;       /* Next reference Base Vop */
+    Vop     *prevEnhanceVop;/* Previous Enhancement Layer Vop */
+    Vop     *forwardRefVop;     /* Forward Reference VOP */
+    Vop     *backwardRefVop;    /* Backward Reference VOP */
+
+    /* scratch memory */
+    BitstreamEncVideo  *bitstream1; /* Used for data partitioning */
+    BitstreamEncVideo  *bitstream2; /* and combined modes as      */
+    BitstreamEncVideo  *bitstream3; /* intermediate storages      */
+
+    UChar   *overrunBuffer;  /* extra output buffer to prevent current skip due to output buffer overrun*/
+    Int     oBSize;     /* size of allocated overrun buffer */
+
+    Int dc_scalar_1;            /*dc scalar for Y block */
+    Int dc_scalar_2;            /*dc scalar for U, V block*/
+
+    /* Annex L Rate Control */
+    rateControl     *rc[4];         /* Pointer to Rate Control structure*/
+    /* 12/25/00, each R.C. for each layer */
+
+    /********* motion compensation related variables ****************/
+    MOT     **mot;              /* Motion vectors */
+    /*  where [mbnum][0] = 1MV.
+        [mbnum][1...4] = 4MVs
+        [mbnum][5] = backward MV.
+        [mbnum][6] = delta MV for direct mode.
+        [mbnum][7] = nothing yet. */
+    UChar   *intraArray;            /* Intra Update Arrary */
+    float   sumMAD;             /* SAD/MAD for frame */
+
+    /* to speedup the SAD calculation */
+    void *sad_extra_info;
+#ifdef HTFM
+    Int nrmlz_th[48];       /* Threshold for fast SAD calculation using HTFM */
+    HTFM_Stat htfm_stat;    /* For statistics collection */
+#endif
+
+    /*Tao 04/09/00  For DCT routine */
+    UChar currYMB[256];     /* interleaved current macroblock in HTFM order */
+    MacroBlock  *outputMB;          /* Output MB to VLC encode */
+    UChar   predictedMB[384];   /* scrath memory for predicted value */
+    RunLevelBlock RLB[6];       /* Run and Level of coefficients! */
+    Short   dataBlock[128];     /* DCT block data before and after quant/dequant*/
+
+    UChar   bitmaprow[8];       /* Need to keep it for ACDCPrediction, 8 bytes for alignment, need only 6 */
+    UChar   bitmapcol[6][8];
+    UInt    bitmapzz[6][2]; /* for zigzag bitmap */
+    Int     zeroMV;         /* flag for zero MV */
+
+    Int     usePrevQP;      /* flag for intraDCVlcThreshold switch decision */
+    Int     QP_prev;            /* use for DQUANT calculation */
+    Int     *acPredFlag;        /* */
+    typeDCStore     *predDC;        /* The DC coeffs for each MB */
+    typeDCACStore   *predDCAC_row;
+    typeDCACStore   *predDCAC_col;
+
+
+    UChar   *sliceNo;           /* Slice Number for each MB */
+
+    Int     header_bits;        /* header bits in frmae */
+    HeaderInfoEncVideo  headerInfo; /* MB Header information */
+    UChar   zz_direction;       /* direction of zigzag scan */
+    UChar   *QPMB;              /* Quantizer value for each MB */
+
+    /* Miscellaneous data points to be passed */
+    float   FrameRate;          /* Src frame Rate */
+
+    ULong   nextModTime;        /* expected next frame time */
+    UInt    prevFrameNum[4];    /* previous frame number starting from modTimeRef */
+    UInt    modTimeRef;     /* Reference modTime update every I-Vop*/
+    UInt    refTick[4];         /* second aligned referenc tick */
+    Int     relLayerCodeTime[4];/* Next coding time for each Layer relative to highest layer */
+
+    ULong   modTime;            /* Input frame modTime */
+    Int     currLayer;          /* Current frame layer  */
+    Int     mbnum;              /*  Macroblock number */
+
+    /* slice coding, state variables */
+    Vop     *tempForwRefVop;
+    Int     tempRefSelCode;
+    Int     end_of_buf;         /* end of bitstream buffer flag */
+    Int     slice_coding;       /* flag for slice based coding */
+    Int     totalSAD;           /* So far total SAD for a frame */
+    Int     numIntra;           /* So far number of Intra MB */
+    Int     offset;             /* So far MB offset */
+    Int     ind_x, ind_y;       /* So far MB coordinate */
+    Int     collect;
+    Int     hp_guess;
+    /*********************************/
+
+    HintTrackInfo hintTrackInfo;    /* hintTrackInfo */
+    /* IntraPeriod, Timestamp, etc. */
+    float       nextEncIVop;    /* counter til the next I-Vop */
+    float       numVopsInGOP;   /* value at the beginning of nextEncIVop */
+
+    /* platform dependent functions */
+    FuncPtr     *functionPointer;   /* structure containing platform dependent functions */
+
+    /* Application controls */
+    VideoEncControls    *videoEncControls;
+    VideoEncParams      *encParams;
+
+    MultiPass *pMP[4]; /* for multipass encoding, 4 represents 4 layer encoding */
+
+} VideoEncData;
+
+/*************************************************************/
+/*                  VLC structures                           */
+/*************************************************************/
+
+typedef struct tagVLCtable
+{
+    unsigned int code; /* right justified */
+    int len;
+} VLCtable, *LPVLCtable;
+
+
+/*************************************************************/
+/*                  Approx DCT                               */
+/*************************************************************/
+typedef struct struct_approxDCT  approxDCT;
+struct struct_approxDCT
+{
+    Void(*BlockDCT8x8)(Int *, Int *, UChar *, UChar *, Int, Int);
+    Void(*BlockDCT8x8Intra)(Int *, Int *, UChar *, UChar *, Int, Int);
+    Void(*BlockDCT8x8wSub)(Int *, Int *, UChar *, UChar *, Int, Int);
+};
+
+/*************************************************************/
+/*                  QP structure                             */
+/*************************************************************/
+
+struct QPstruct
+{
+    Int QPx2 ;
+    Int QP;
+    Int QPdiv2;
+    Int QPx2plus;
+    Int Addition;
+};
+
+
+#endif /* _MP4LIB_INT_H_ */
+
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/rate_control.cpp b/media/libstagefright/codecs/m4v_h263/enc/src/rate_control.cpp
new file mode 100644
index 0000000..53149c1
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/rate_control.cpp
@@ -0,0 +1,885 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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 "mp4def.h"
+#include "mp4lib_int.h"
+#include "rate_control.h"
+#include "mp4enc_lib.h"
+#include "bitstream_io.h"
+#include "m4venc_oscl.h"
+
+void targetBitCalculation(void *input);
+void calculateQuantizer_Multipass(void *video);
+void updateRateControl(rateControl *rc, VideoEncData *video);
+void updateRC_PostProc(rateControl *rc, VideoEncData *video);
+
+/***************************************************************************
+**************  RC APIs to core encoding modules  *******************
+
+PV_STATUS RC_Initialize(void *video);
+PV_STATUS RC_Cleanup(rateControl *rc[],Int numLayers);
+PV_STATUS RC_VopQPSetting(VideoEncData *video,rateControl *rc[]);
+PV_STATUS RC_VopUpdateStat(VideoEncData *video,rateControl *rc[]);
+PV_STATUS RC_UpdateBuffer(VideoEncData *video, Int currLayer, Int num_skip);
+Int       RC_GetSkipNextFrame(VideoEncData *video,Int currLayer);
+void      RC_ResetSkipNextFrame(void *video,Int currLayer);
+
+PV_STATUS RC_UpdateBXRCParams(void *input);  Parameters update for target bitrate or framerate change
+
+****************************************************************************/
+
+
+/************************************************************************/
+/************ API part **************************************************/
+/* must be called before each sequence*/
+
+PV_STATUS RC_Initialize(void *input)
+{
+    VideoEncData *video = (VideoEncData *) input;
+    VideoEncParams *encParams = video->encParams;
+    rateControl **rc = video->rc;
+    Int numLayers = encParams->nLayers;
+    Int *LayerBitRate = encParams->LayerBitRate;
+    float *LayerFrameRate = encParams->LayerFrameRate;
+    MultiPass **pMP = video->pMP;
+
+    Int n;
+
+    for (n = 0; n < numLayers; n++)
+    {
+        /* rate control */
+        rc[n]->fine_frame_skip = encParams->FineFrameSkip_Enabled;
+        rc[n]->no_frame_skip = encParams->NoFrameSkip_Enabled;
+        rc[n]->no_pre_skip = encParams->NoPreSkip_Enabled;
+        rc[n]->skip_next_frame = 0; /* must be initialized */
+
+        //rc[n]->TMN_TH = (Int)((float)LayerBitRate[n]/LayerFrameRate[n]);
+        rc[n]->Bs = video->encParams->BufferSize[n];
+        rc[n]->TMN_W = 0;
+        rc[n]->VBV_fullness = (Int)(rc[n]->Bs * 0.5); /* rc[n]->Bs */
+        rc[n]->encoded_frames = 0;
+        rc[n]->framerate = LayerFrameRate[n];
+        if (n == 0)
+        {
+            rc[n]->TMN_TH = (Int)((float)LayerBitRate[n] / LayerFrameRate[n]);
+            rc[n]->bitrate = LayerBitRate[n];
+            rc[n]->framerate = LayerFrameRate[n];
+
+            // For h263 or short header mode, the bit variation is within (-2*Rmax*1001/3000, 2*Rmax*1001/3000)
+            if (video->encParams->H263_Enabled)
+            {
+                rc[n]->max_BitVariance_num = (Int)((rc[n]->Bs - video->encParams->maxFrameSize) / 2 / (rc[n]->bitrate / rc[n]->framerate / 10.0)) - 5;
+                if (rc[n]->max_BitVariance_num < 0) rc[n]->max_BitVariance_num += 5;
+            }
+            else   // MPEG-4 normal modes
+            {
+                rc[n]->max_BitVariance_num = (Int)((float)(rc[n]->Bs - rc[n]->VBV_fullness) / ((float)LayerBitRate[n] / LayerFrameRate[n] / 10.0)) - 5;
+                if (rc[n]->max_BitVariance_num < 0) rc[n]->max_BitVariance_num += 5;
+            }
+        }
+        else
+        {
+            if (LayerFrameRate[n] - LayerFrameRate[n-1] > 0) /*  7/31/03 */
+            {
+                rc[n]->TMN_TH = (Int)((float)(LayerBitRate[n] - LayerBitRate[n-1]) / (LayerFrameRate[n] - LayerFrameRate[n-1]));
+                rc[n]->max_BitVariance_num = (Int)((float)(rc[n]->Bs - rc[n]->VBV_fullness) * 10 / ((float)rc[n]->TMN_TH)) - 5;
+                if (rc[n]->max_BitVariance_num < 0) rc[n]->max_BitVariance_num += 5;
+            }
+            else   /*  7/31/03 */
+            {
+                rc[n]->TMN_TH = 1 << 30;
+                rc[n]->max_BitVariance_num = 0;
+            }
+            rc[n]->bitrate = LayerBitRate[n] - LayerBitRate[n-1];
+            rc[n]->framerate = LayerFrameRate[n] - LayerFrameRate[n-1];
+        }
+
+        // Set the initial buffer fullness
+        if (1) //!video->encParams->H263_Enabled)  { // MPEG-4
+        {
+            /* According to the spec, the initial buffer fullness needs to be set to 1/3 */
+            rc[n]->VBV_fullness = (Int)(rc[n]->Bs / 3.0 - rc[n]->Bs / 2.0); /* the buffer range is [-Bs/2, Bs/2] */
+            pMP[n]->counter_BTsrc = (Int)((rc[n]->Bs / 2.0 - rc[n]->Bs / 3.0) / (rc[n]->bitrate / rc[n]->framerate / 10.0));
+            rc[n]->TMN_W = (Int)(rc[n]->VBV_fullness + pMP[n]->counter_BTsrc * (rc[n]->bitrate / rc[n]->framerate / 10.0));
+
+            rc[n]->low_bound = -rc[n]->Bs / 2;
+            rc[n]-> VBV_fullness_offset = 0;
+        }
+        else   /* this part doesn't work in some cases, the low_bound is too high, Jan 4,2006 */
+        {
+            rc[n]->VBV_fullness =  rc[n]->Bs - (Int)(video->encParams->VBV_delay * rc[n]->bitrate);
+            if (rc[n]->VBV_fullness < 0) rc[n]->VBV_fullness = 0;
+            //rc[n]->VBV_fullness = (rc[n]->Bs-video->encParams->maxFrameSize)/2 + video->encParams->maxFrameSize;
+
+            rc[n]->VBV_fullness -= rc[n]->Bs / 2; /* the buffer range is [-Bs/2, Bs/2] */
+            rc[n]->low_bound = -rc[n]->Bs / 2 + video->encParams->maxFrameSize;  /*  too high */
+            rc[n]->VBV_fullness_offset = video->encParams->maxFrameSize / 2; /*  don't understand the meaning of this */
+            pMP[n]->counter_BTdst = pMP[n]->counter_BTsrc = 0;
+
+        }
+
+        /* Setting the bitrate and framerate */
+        pMP[n]->bitrate = rc[n]->bitrate;
+        pMP[n]->framerate = rc[n]->framerate;
+        pMP[n]->target_bits_per_frame = pMP[n]->bitrate / pMP[n]->framerate;
+
+    }
+
+    return PV_SUCCESS;
+}
+
+
+/* ======================================================================== */
+/*  Function : RC_Cleanup                                                   */
+/*  Date     : 12/20/2000                                                   */
+/*  Purpose  : free Rate Control memory                                     */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+
+
+PV_STATUS RC_Cleanup(rateControl *rc[], Int numLayers)
+{
+    OSCL_UNUSED_ARG(rc);
+    OSCL_UNUSED_ARG(numLayers);
+
+    return PV_SUCCESS;
+}
+
+
+
+/* ======================================================================== */
+/*  Function : RC_VopQPSetting                                              */
+/*  Date     : 4/11/2001                                                    */
+/*  Purpose  : Reset rate control before coding VOP, moved from vop.c       */
+/*              Compute QP for the whole VOP and initialize MB-based RC
+                reset QPMB[], currVop->quantizer, rc->Ec, video->header_bits */
+/* to          In order to  work RC_VopQPSetting has to do the followings
+                1. Set video->QPMB of all macroblocks.
+                2. Set currVop->quantizer
+                3. Reset video->header_bits to zero.
+                4. Initialize internal RC parameters for Vop cooding        */
+/*  In/out   :                                                              */
+/*  Return   : PV_STATUS                                                    */
+/*  Modified :                                                              */
+/* ======================================================================== */
+/* To be moved to rate_control.c and separate between BX_RC and ANNEX_L     */
+
+PV_STATUS RC_VopQPSetting(VideoEncData *video, rateControl *prc[])
+{
+    Int currLayer = video->currLayer;
+    Vol *currVol = video->vol[currLayer];
+    Vop *currVop = video->currVop;
+#ifdef TEST_MBBASED_QP
+    int i;
+#endif
+
+    rateControl *rc = video->rc[currLayer];
+    MultiPass *pMP = video->pMP[currLayer];
+
+    OSCL_UNUSED_ARG(prc);
+
+    if (video->encParams->RC_Type == CONSTANT_Q)
+    {
+        M4VENC_MEMSET(video->QPMB, currVop->quantizer, sizeof(UChar)*currVol->nTotalMB);
+        return PV_SUCCESS;
+    }
+    else
+    {
+
+        if (video->rc[currLayer]->encoded_frames == 0) /* rc[currLayer]->totalFrameNumber*/
+        {
+            M4VENC_MEMSET(video->QPMB, currVop->quantizer, sizeof(UChar)*currVol->nTotalMB);
+            video->rc[currLayer]->Qc = video->encParams->InitQuantIvop[currLayer];
+        }
+        else
+        {
+            calculateQuantizer_Multipass((void*) video);
+            currVop->quantizer = video->rc[currLayer]->Qc;
+#ifdef TEST_MBBASED_QP
+            i = currVol->nTotalMB;  /* testing changing QP at MB level */
+            while (i)
+            {
+                i--;
+                video->QPMB[i] = (i & 1) ? currVop->quantizer - 1 : currVop->quantizer + 1;
+            }
+#else
+            M4VENC_MEMSET(video->QPMB, currVop->quantizer, sizeof(UChar)*currVol->nTotalMB);
+#endif
+        }
+
+        video->header_bits = 0;
+    }
+
+    /* update pMP->framePos */
+    if (++pMP->framePos == pMP->frameRange) pMP->framePos = 0;
+
+    if (rc->T == 0)
+    {
+        pMP->counter_BTdst = (Int)(video->encParams->LayerFrameRate[video->currLayer] * 7.5 + 0.5); /* 0.75s time frame */
+        pMP->counter_BTdst = PV_MIN(pMP->counter_BTdst, (Int)(rc->max_BitVariance_num / 2 * 0.40)); /* 0.75s time frame may go beyond VBV buffer if we set the buffer size smaller than 0.75s */
+        pMP->counter_BTdst = PV_MAX(pMP->counter_BTdst, (Int)((rc->Bs / 2 - rc->VBV_fullness) * 0.30 / (rc->TMN_TH / 10.0) + 0.5)); /* At least 30% of VBV buffer size/2 */
+        pMP->counter_BTdst = PV_MIN(pMP->counter_BTdst, 20); /* Limit the target to be smaller than 3C */
+
+        pMP->target_bits = rc->T = rc->TMN_TH = (Int)(rc->TMN_TH * (1.0 + pMP->counter_BTdst * 0.1));
+        pMP->diff_counter = pMP->counter_BTdst;
+    }
+
+    /* collect the necessary data: target bits, actual bits, mad and QP */
+    pMP->target_bits = rc->T;
+    pMP->QP  = currVop->quantizer;
+
+    pMP->mad = video->sumMAD / (float)currVol->nTotalMB;
+    if (pMP->mad < MAD_MIN) pMP->mad = MAD_MIN; /* MAD_MIN is defined as 1 in mp4def.h */
+
+    pMP->bitrate = rc->bitrate; /* calculated in RCVopQPSetting */
+    pMP->framerate = rc->framerate;
+
+    /* first pass encoding */
+    pMP->nRe_Quantized = 0;
+
+    return  PV_SUCCESS;
+}
+
+
+/* ======================================================================== */
+/*  Function : SaveRDSamples()                                              */
+/*  Date     : 08/29/2001                                                   */
+/*  History  :                                                              */
+/*  Purpose  : Save QP, actual_bits, mad and R_D of the current iteration   */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/*                                                                          */
+/* ======================================================================== */
+
+Void SaveRDSamples(MultiPass *pMP, Int counter_samples)
+{
+    /* for pMP->pRDSamples */
+    pMP->pRDSamples[pMP->framePos][counter_samples].QP    = pMP->QP;
+    pMP->pRDSamples[pMP->framePos][counter_samples].actual_bits = pMP->actual_bits;
+    pMP->pRDSamples[pMP->framePos][counter_samples].mad   = pMP->mad;
+    pMP->pRDSamples[pMP->framePos][counter_samples].R_D = (float)(pMP->actual_bits / (pMP->mad + 0.0001));
+
+    return ;
+}
+/* ======================================================================== */
+/*  Function : RC_VopUpdateStat                                             */
+/*  Date     : 12/20/2000                                                   */
+/*  Purpose  : Update statistics for rate control after encoding each VOP.  */
+/*             No need to change anything in VideoEncData structure.        */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+
+PV_STATUS RC_VopUpdateStat(VideoEncData *video, rateControl *rc)
+{
+    Int currLayer = video->currLayer;
+    Vol *currVol = video->vol[currLayer];
+    MultiPass *pMP = video->pMP[currLayer];
+    Int diff_BTCounter;
+
+    switch (video->encParams->RC_Type)
+    {
+        case CONSTANT_Q:
+            break;
+
+        case CBR_1:
+        case CBR_2:
+        case VBR_1:
+        case VBR_2:
+        case CBR_LOWDELAY:
+
+            pMP->actual_bits = currVol->stream->byteCount << 3;
+
+            SaveRDSamples(pMP, 0);
+
+            pMP->encoded_frames++;
+
+            /* for pMP->samplesPerFrame */
+            pMP->samplesPerFrame[pMP->framePos] = 0;
+
+            pMP->sum_QP += pMP->QP;
+
+
+            /* update pMP->counter_BTsrc, pMP->counter_BTdst */
+            /* re-allocate the target bit again and then stop encoding */
+            diff_BTCounter = (Int)((float)(rc->TMN_TH - rc->TMN_W - pMP->actual_bits) /
+                                   (pMP->bitrate / (pMP->framerate + 0.0001) + 0.0001) / 0.1);
+            if (diff_BTCounter >= 0)
+                pMP->counter_BTsrc += diff_BTCounter; /* pMP->actual_bits is smaller */
+            else
+                pMP->counter_BTdst -= diff_BTCounter; /* pMP->actual_bits is bigger */
+
+            rc->TMN_TH -= (Int)((float)pMP->bitrate / (pMP->framerate + 0.0001) * (diff_BTCounter * 0.1));
+            rc->T = pMP->target_bits = rc->TMN_TH - rc->TMN_W;
+            pMP->diff_counter -= diff_BTCounter;
+
+            rc->Rc = currVol->stream->byteCount << 3;   /* Total Bits for current frame */
+            rc->Hc = video->header_bits;    /* Total Bits in Header and Motion Vector */
+
+            /* BX_RC */
+            updateRateControl(rc, video);
+
+            break;
+
+        default: /* for case CBR_1/2, VBR_1/2 */
+
+            return PV_FAIL;
+    }
+
+
+    return PV_SUCCESS;
+}
+
+/* ======================================================================== */
+/*  Function : RC_GetSkipNextFrame, RC_GetRemainingVops                     */
+/*  Date     : 2/20/2001                                                    */
+/*  Purpose  : To access RC parameters from other parts of the code.        */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+
+Int RC_GetSkipNextFrame(VideoEncData *video, Int currLayer)
+{
+    return video->rc[currLayer]->skip_next_frame;
+}
+
+void RC_ResetSkipNextFrame(VideoEncData *video, Int currLayer)
+{
+
+    video->rc[currLayer]->skip_next_frame = 0;
+    return ;
+}
+
+/* ======================================================================== */
+/*  Function : RC_UpdateBuffer                                      */
+/*  Date     : 2/20/2001                                                    */
+/*  Purpose  : Update RC in case of there are frames skipped (camera freeze)*/
+/*              from the application level in addition to what RC requested */
+/*  In/out   : Nr, B, Rr                                                    */
+/*  Return   : Void                                                         */
+/*  Modified :                                                              */
+/* ======================================================================== */
+
+
+PV_STATUS RC_UpdateBuffer(VideoEncData *video, Int currLayer, Int num_skip)
+{
+    rateControl *rc  = video->rc[currLayer];
+    MultiPass   *pMP = video->pMP[currLayer];
+
+    if (video == NULL || rc == NULL || pMP == NULL)
+        return PV_FAIL;
+
+    rc->VBV_fullness   -= (Int)(rc->bitrate / rc->framerate * num_skip); //rc[currLayer]->Rp;
+    pMP->counter_BTsrc += 10 * num_skip;
+
+    /* Check buffer underflow */
+    if (rc->VBV_fullness < rc->low_bound)
+    {
+        rc->VBV_fullness = rc->low_bound; // -rc->Bs/2;
+        rc->TMN_W = rc->VBV_fullness - rc->low_bound;
+        pMP->counter_BTsrc = pMP->counter_BTdst + (Int)((float)(rc->Bs / 2 - rc->low_bound) / 2.0 / (pMP->target_bits_per_frame / 10));
+    }
+
+    return PV_SUCCESS;
+}
+
+
+/* ======================================================================== */
+/*  Function : RC_UpdateBXRCParams                                          */
+/*  Date     : 4/08/2002                                                    */
+/*  Purpose  : Update RC parameters specifically for target bitrate or      */
+/*             framerate update during an encoding session                  */
+/*  In/out   :                                                              */
+/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
+/*  Modified :                                                              */
+/* ======================================================================== */
+
+PV_STATUS RC_UpdateBXRCParams(void *input)
+{
+    VideoEncData *video = (VideoEncData *) input;
+    VideoEncParams *encParams = video->encParams;
+    rateControl **rc = video->rc;
+    Int numLayers = encParams->nLayers;
+    Int *LayerBitRate = encParams->LayerBitRate;
+    float *LayerFrameRate = encParams->LayerFrameRate;
+    MultiPass **pMP = video->pMP;
+
+    Int n, VBV_fullness;
+    Int diff_counter;
+
+    extern Bool SetProfile_BufferSize(VideoEncData *video, float delay, Int bInitialized);
+
+
+    /* Reset video buffer size due to target bitrate change */
+    SetProfile_BufferSize(video, video->encParams->VBV_delay, 0); /* output: video->encParams->BufferSize[] */
+
+    for (n = 0; n < numLayers; n++)
+    {
+        /* Remaining stuff about frame dropping and underflow check in update RC */
+        updateRC_PostProc(rc[n], video);
+        rc[n]->skip_next_frame = 0; /* must be initialized */
+
+        /* New changes: bitrate and framerate, Bs, max_BitVariance_num, TMN_TH(optional), encoded_frames(optional) */
+        rc[n]->Bs = video->encParams->BufferSize[n];
+        VBV_fullness = (Int)(rc[n]->Bs * 0.5);
+
+        if (n == 0)
+        {
+            rc[n]->TMN_TH = (Int)((float)LayerBitRate[n] / LayerFrameRate[n]);
+            rc[n]->bitrate   = pMP[n]->bitrate   = LayerBitRate[n];
+            rc[n]->framerate = pMP[n]->framerate = LayerFrameRate[n];
+
+            // For h263 or short header mode, the bit variation is within (-2*Rmax*1001/3000, 2*Rmax*1001/3000)
+            if (video->encParams->H263_Enabled)
+            {
+                rc[n]->max_BitVariance_num = (Int)((rc[n]->Bs - video->encParams->maxFrameSize) / 2 / (rc[n]->bitrate / rc[n]->framerate / 10.0)) - 5;
+                //rc[n]->max_BitVariance_num = (Int)((float)(rc[n]->Bs - rc[n]->VBV_fullness)/((float)LayerBitRate[n]/LayerFrameRate[n]/10.0))-5;
+            }
+            else   // MPEG-4 normal modes
+            {
+                rc[n]->max_BitVariance_num = (Int)((float)(rc[n]->Bs - VBV_fullness) * 10 / ((float)LayerBitRate[n] / LayerFrameRate[n])) - 5;
+            }
+        }
+        else
+        {
+            if (LayerFrameRate[n] - LayerFrameRate[n-1] > 0) /*  7/31/03 */
+            {
+                rc[n]->TMN_TH = (Int)((float)(LayerBitRate[n] - LayerBitRate[n-1]) / (LayerFrameRate[n] - LayerFrameRate[n-1]));
+                rc[n]->max_BitVariance_num = (Int)((float)(rc[n]->Bs - VBV_fullness) * 10 / ((float)rc[n]->TMN_TH)) - 5;
+                if (rc[n]->max_BitVariance_num < 0) rc[n]->max_BitVariance_num += 5;
+            }
+            else   /*  7/31/03 */
+            {
+                rc[n]->TMN_TH = 1 << 30;
+                rc[n]->max_BitVariance_num = 0;
+            }
+            rc[n]->bitrate   = pMP[n]->bitrate   = LayerBitRate[n] - LayerBitRate[n-1];
+            rc[n]->framerate = pMP[n]->framerate = LayerFrameRate[n] - LayerFrameRate[n-1];
+        }
+
+        pMP[n]->target_bits_per_frame_prev = pMP[n]->target_bits_per_frame;
+        pMP[n]->target_bits_per_frame = pMP[n]->bitrate / (float)(pMP[n]->framerate + 0.0001);  /*  7/31/03 */
+
+        /* rc[n]->VBV_fullness and rc[n]->TMN_W should be kept same */
+        /* update pMP[n]->counter_BTdst and pMP[n]->counter_BTsrc   */
+        diff_counter = (Int)((float)(rc[n]->VBV_fullness - rc[n]->TMN_W) /
+                             (pMP[n]->target_bits_per_frame / 10 + 0.0001)); /*  7/31/03 */
+
+        pMP[n]->counter_BTdst = pMP[n]->counter_BTsrc = 0;
+        if (diff_counter > 0)
+            pMP[n]->counter_BTdst = diff_counter;
+
+        else if (diff_counter < 0)
+            pMP[n]->counter_BTsrc = -diff_counter;
+
+        rc[n]->TMN_W = (Int)(rc[n]->VBV_fullness -      /* re-calculate rc[n]->TMN_W in order for higher accuracy */
+                             (pMP[n]->target_bits_per_frame / 10) * (pMP[n]->counter_BTdst - pMP[n]->counter_BTsrc));
+
+        /* Keep the current average mad */
+        if (pMP[n]->aver_mad != 0)
+        {
+            pMP[n]->aver_mad_prev = pMP[n]->aver_mad;
+            pMP[n]->encoded_frames_prev = pMP[n]->encoded_frames;
+        }
+
+        pMP[n]->aver_mad = 0;
+        pMP[n]->overlapped_win_size = 4;
+
+        /* Misc */
+        pMP[n]->sum_mad = pMP[n]->sum_QP = 0;
+        //pMP[n]->encoded_frames_prev = pMP[n]->encoded_frames;
+        pMP[n]->encoded_frames = pMP[n]->re_encoded_frames = pMP[n]->re_encoded_times = 0;
+
+    } /* end of: for(n=0; n<numLayers; n++) */
+
+    return PV_SUCCESS;
+
+}
+
+
+/* ================================================================================ */
+/*  Function : targetBitCalculation                                                 */
+/*  Date     : 10/01/2001                                                           */
+/*  Purpose  : quadratic bit allocation model: T(n) = C*sqrt(mad(n)/aver_mad(n-1))  */
+/*                                                                                  */
+/*  In/out   : rc->T                                                                */
+/*  Return   : Void                                                                 */
+/*  Modified :                                                                      */
+/* ================================================================================ */
+
+void targetBitCalculation(void *input)
+{
+    VideoEncData *video = (VideoEncData *) input;
+    MultiPass *pMP = video->pMP[video->currLayer];
+    Vol *currVol = video->vol[video->currLayer];
+    rateControl *rc = video->rc[video->currLayer];
+
+    float curr_mad;//, average_mad;
+    Int diff_counter_BTsrc, diff_counter_BTdst, prev_counter_diff, curr_counter_diff, bound;
+    /* BT = Bit Transfer, for pMP->counter_BTsrc, pMP->counter_BTdst */
+
+    if (video == NULL || currVol == NULL || pMP == NULL || rc == NULL)
+        return;
+
+    /* some stuff about frame dropping remained here to be done because pMP cannot be inserted into updateRateControl()*/
+    updateRC_PostProc(rc, video);
+
+    /* update pMP->counter_BTsrc and pMP->counter_BTdst to avoid interger overflow */
+    if (pMP->counter_BTsrc > 1000 && pMP->counter_BTdst > 1000)
+    {
+        pMP->counter_BTsrc -= 1000;
+        pMP->counter_BTdst -= 1000;
+    }
+
+    /* ---------------------------------------------------------------------------------------------------*/
+    /* target calculation */
+    curr_mad = video->sumMAD / (float)currVol->nTotalMB;
+    if (curr_mad < MAD_MIN) curr_mad = MAD_MIN; /* MAD_MIN is defined as 1 in mp4def.h */
+    diff_counter_BTsrc = diff_counter_BTdst = 0;
+    pMP->diff_counter = 0;
+
+
+    /*1.calculate average mad */
+    pMP->sum_mad += curr_mad;
+    //average_mad = (pMP->encoded_frames < 1 ? curr_mad : pMP->sum_mad/(float)(pMP->encoded_frames+1)); /* this function is called from the scond encoded frame*/
+    //pMP->aver_mad = average_mad;
+    if (pMP->encoded_frames >= 0) /* pMP->encoded_frames is set to -1 initially, so forget about the very first I frame */
+        pMP->aver_mad = (pMP->aver_mad * pMP->encoded_frames + curr_mad) / (pMP->encoded_frames + 1);
+
+    if (pMP->overlapped_win_size > 0 && pMP->encoded_frames_prev >= 0)  /*  7/31/03 */
+        pMP->aver_mad_prev = (pMP->aver_mad_prev * pMP->encoded_frames_prev + curr_mad) / (pMP->encoded_frames_prev + 1);
+
+    /*2.average_mad, mad ==> diff_counter_BTsrc, diff_counter_BTdst */
+    if (pMP->overlapped_win_size == 0)
+    {
+        /* original verison */
+        if (curr_mad > pMP->aver_mad*1.1)
+        {
+            if (curr_mad / (pMP->aver_mad + 0.0001) > 2)
+                diff_counter_BTdst = (Int)(M4VENC_SQRT(curr_mad / (pMP->aver_mad + 0.0001)) * 10 + 0.4) - 10;
+            //diff_counter_BTdst = (Int)((sqrt(curr_mad/pMP->aver_mad)*2+curr_mad/pMP->aver_mad)/(3*0.1) + 0.4) - 10;
+            else
+                diff_counter_BTdst = (Int)(curr_mad / (pMP->aver_mad + 0.0001) * 10 + 0.4) - 10;
+        }
+        else /* curr_mad <= average_mad*1.1 */
+            //diff_counter_BTsrc = 10 - (Int)((sqrt(curr_mad/pMP->aver_mad) + pow(curr_mad/pMP->aver_mad, 1.0/3.0))/(2.0*0.1) + 0.4);
+            diff_counter_BTsrc = 10 - (Int)(M4VENC_SQRT(curr_mad / (pMP->aver_mad + 0.0001)) * 10 + 0.5);
+        //diff_counter_BTsrc = 10 - (Int)(curr_mad/pMP->aver_mad/0.1 + 0.5)
+
+        /* actively fill in the possible gap */
+        if (diff_counter_BTsrc == 0 && diff_counter_BTdst == 0 &&
+                curr_mad <= pMP->aver_mad*1.1 && pMP->counter_BTsrc < pMP->counter_BTdst)
+            diff_counter_BTsrc = 1;
+
+    }
+    else if (pMP->overlapped_win_size > 0)
+    {
+        /* transition time: use previous average mad "pMP->aver_mad_prev" instead of the current average mad "pMP->aver_mad" */
+        if (curr_mad > pMP->aver_mad_prev*1.1)
+        {
+            if (curr_mad / pMP->aver_mad_prev > 2)
+                diff_counter_BTdst = (Int)(M4VENC_SQRT(curr_mad / (pMP->aver_mad_prev + 0.0001)) * 10 + 0.4) - 10;
+            //diff_counter_BTdst = (Int)((M4VENC_SQRT(curr_mad/pMP->aver_mad_prev)*2+curr_mad/pMP->aver_mad_prev)/(3*0.1) + 0.4) - 10;
+            else
+                diff_counter_BTdst = (Int)(curr_mad / (pMP->aver_mad_prev + 0.0001) * 10 + 0.4) - 10;
+        }
+        else /* curr_mad <= average_mad*1.1 */
+            //diff_counter_BTsrc = 10 - (Int)((sqrt(curr_mad/pMP->aver_mad_prev) + pow(curr_mad/pMP->aver_mad_prev, 1.0/3.0))/(2.0*0.1) + 0.4);
+            diff_counter_BTsrc = 10 - (Int)(M4VENC_SQRT(curr_mad / (pMP->aver_mad_prev + 0.0001)) * 10 + 0.5);
+        //diff_counter_BTsrc = 10 - (Int)(curr_mad/pMP->aver_mad_prev/0.1 + 0.5)
+
+        /* actively fill in the possible gap */
+        if (diff_counter_BTsrc == 0 && diff_counter_BTdst == 0 &&
+                curr_mad <= pMP->aver_mad_prev*1.1 && pMP->counter_BTsrc < pMP->counter_BTdst)
+            diff_counter_BTsrc = 1;
+
+        if (--pMP->overlapped_win_size <= 0)    pMP->overlapped_win_size = 0;
+    }
+
+
+    /* if difference is too much, do clipping */
+    /* First, set the upper bound for current bit allocation variance: 80% of available buffer */
+    bound = (Int)((rc->Bs / 2 - rc->VBV_fullness) * 0.6 / (pMP->target_bits_per_frame / 10)); /* rc->Bs */
+    diff_counter_BTsrc =  PV_MIN(diff_counter_BTsrc, bound);
+    diff_counter_BTdst =  PV_MIN(diff_counter_BTdst, bound);
+
+    /* Second, set another upper bound for current bit allocation: 4-5*bitrate/framerate */
+    bound = 50;
+//  if(video->encParams->RC_Type == CBR_LOWDELAY)
+//  not necessary       bound = 10;     /*  1/17/02 -- For Low delay */
+
+    diff_counter_BTsrc =  PV_MIN(diff_counter_BTsrc, bound);
+    diff_counter_BTdst =  PV_MIN(diff_counter_BTdst, bound);
+
+
+    /* Third, check the buffer */
+    prev_counter_diff = pMP->counter_BTdst - pMP->counter_BTsrc;
+    curr_counter_diff = prev_counter_diff + (diff_counter_BTdst - diff_counter_BTsrc);
+
+    if (PV_ABS(prev_counter_diff) >= rc->max_BitVariance_num || PV_ABS(curr_counter_diff) >= rc->max_BitVariance_num) // PV_ABS(curr_counter_diff) >= PV_ABS(prev_counter_diff) )
+    {   //diff_counter_BTsrc = diff_counter_BTdst = 0;
+
+        if (curr_counter_diff > rc->max_BitVariance_num && diff_counter_BTdst)
+        {
+            diff_counter_BTdst = (rc->max_BitVariance_num - prev_counter_diff) + diff_counter_BTsrc;
+            if (diff_counter_BTdst < 0) diff_counter_BTdst = 0;
+        }
+
+        else if (curr_counter_diff < -rc->max_BitVariance_num && diff_counter_BTsrc)
+        {
+            diff_counter_BTsrc = diff_counter_BTdst - (-rc->max_BitVariance_num - prev_counter_diff);
+            if (diff_counter_BTsrc < 0) diff_counter_BTsrc = 0;
+        }
+    }
+
+
+    /*3.diff_counter_BTsrc, diff_counter_BTdst ==> TMN_TH */
+    //rc->TMN_TH = (Int)((float)pMP->bitrate/pMP->framerate);
+    rc->TMN_TH = (Int)(pMP->target_bits_per_frame);
+    pMP->diff_counter = 0;
+
+    if (diff_counter_BTsrc)
+    {
+        rc->TMN_TH -= (Int)(pMP->target_bits_per_frame * diff_counter_BTsrc * 0.1);
+        pMP->diff_counter = -diff_counter_BTsrc;
+    }
+    else if (diff_counter_BTdst)
+    {
+        rc->TMN_TH += (Int)(pMP->target_bits_per_frame * diff_counter_BTdst * 0.1);
+        pMP->diff_counter = diff_counter_BTdst;
+    }
+
+
+    /*4.update pMP->counter_BTsrc, pMP->counter_BTdst */
+    pMP->counter_BTsrc += diff_counter_BTsrc;
+    pMP->counter_BTdst += diff_counter_BTdst;
+
+
+    /*5.target bit calculation */
+    rc->T = rc->TMN_TH - rc->TMN_W;
+    //rc->T = rc->TMN_TH - (Int)((float)rc->TMN_W/rc->frameRate);
+
+    if (video->encParams->H263_Enabled && rc->T > video->encParams->maxFrameSize)
+    {
+        rc->T = video->encParams->maxFrameSize;  //  added this 11/07/05
+    }
+
+}
+
+/* ================================================================================ */
+/*  Function : calculateQuantizer_Multipass                                         */
+/*  Date     : 10/01/2001                                                           */
+/*  Purpose  : variable rate bit allocation + new QP determination scheme           */
+/*                                                                                  */
+/*  In/out   : rc->T and rc->Qc                                                     */
+/*  Return   : Void                                                                 */
+/*  Modified :                                                                      */
+/* ================================================================================ */
+
+/* Mad based variable bit allocation + QP calculation with a new quadratic method */
+void calculateQuantizer_Multipass(void *input)
+{
+    VideoEncData *video = (VideoEncData *) input;
+    MultiPass *pMP = video->pMP[video->currLayer];
+    Vol *currVol = video->vol[video->currLayer];
+    rateControl *rc = video->rc[video->currLayer];
+
+    Int prev_QP, prev_actual_bits, curr_target, i, j;
+
+    float curr_mad, prev_mad, curr_RD, prev_RD, average_mad, aver_QP;
+
+
+    if (video == NULL || currVol == NULL || pMP == NULL || rc == NULL)
+        return;
+
+    /* Mad based variable bit allocation */
+    targetBitCalculation((void*) video);
+
+    if (rc->T <= 0 || video->sumMAD == 0)
+    {
+        if (rc->T < 0)  rc->Qc = 31;
+        return;
+    }
+
+    /* ---------------------------------------------------------------------------------------------------*/
+    /* current frame QP estimation */
+    curr_target = rc->T;
+    curr_mad = video->sumMAD / (float)currVol->nTotalMB;
+    if (curr_mad < MAD_MIN) curr_mad = MAD_MIN; /* MAD_MIN is defined as 1 in mp4def.h */
+    curr_RD  = (float)curr_target / curr_mad;
+
+    /* Another version of search the optimal point */
+    prev_actual_bits = pMP->pRDSamples[0][0].actual_bits;
+    prev_mad = pMP->pRDSamples[0][0].mad;
+
+    for (i = 0, j = 0; i < pMP->frameRange; i++)
+    {
+        if (pMP->pRDSamples[i][0].mad != 0 && prev_mad != 0 &&
+                PV_ABS(prev_mad - curr_mad) > PV_ABS(pMP->pRDSamples[i][0].mad - curr_mad))
+        {
+            prev_mad = pMP->pRDSamples[i][0].mad;
+            prev_actual_bits = pMP->pRDSamples[i][0].actual_bits;
+            j = i;
+        }
+    }
+    prev_QP = pMP->pRDSamples[j][0].QP;
+    for (i = 1; i < pMP->samplesPerFrame[j]; i++)
+    {
+        if (PV_ABS(prev_actual_bits - curr_target) > PV_ABS(pMP->pRDSamples[j][i].actual_bits - curr_target))
+        {
+            prev_actual_bits = pMP->pRDSamples[j][i].actual_bits;
+            prev_QP = pMP->pRDSamples[j][i].QP;
+        }
+    }
+
+    // quadratic approximation
+    prev_RD = (float)prev_actual_bits / prev_mad;
+    //rc->Qc = (Int)(prev_QP * sqrt(prev_actual_bits/curr_target) + 0.4);
+    if (prev_QP == 1) // 11/14/05, added this to allow getting out of QP = 1 easily
+    {
+        rc->Qc = (Int)(prev_RD / curr_RD + 0.5);
+    }
+    else
+    {
+        rc->Qc = (Int)(prev_QP * M4VENC_SQRT(prev_RD / curr_RD) + 0.9);
+
+        if (prev_RD / curr_RD > 0.5 && prev_RD / curr_RD < 2.0)
+            rc->Qc = (Int)(prev_QP * (M4VENC_SQRT(prev_RD / curr_RD) + prev_RD / curr_RD) / 2.0 + 0.9); /* Quadratic and linear approximation */
+        else
+            rc->Qc = (Int)(prev_QP * (M4VENC_SQRT(prev_RD / curr_RD) + M4VENC_POW(prev_RD / curr_RD, 1.0 / 3.0)) / 2.0 + 0.9);
+    }
+    //rc->Qc =(Int)(prev_QP * sqrt(prev_RD/curr_RD) + 0.4);
+    // 11/08/05
+    // lower bound on Qc should be a function of curr_mad
+    // When mad is already low, lower bound on Qc doesn't have to be small.
+    // Note, this doesn't work well for low complexity clip encoded at high bit rate
+    // it doesn't hit the target bit rate due to this QP lower bound.
+/// if((curr_mad < 8) && (rc->Qc < 12)) rc->Qc = 12;
+//  else    if((curr_mad < 128) && (rc->Qc < 3)) rc->Qc = 3;
+
+    if (rc->Qc < 1) rc->Qc = 1;
+    if (rc->Qc > 31)    rc->Qc = 31;
+
+
+    /* active bit resource protection */
+    aver_QP = (pMP->encoded_frames == 0 ? 0 : pMP->sum_QP / (float)pMP->encoded_frames);
+    average_mad = (pMP->encoded_frames == 0 ? 0 : pMP->sum_mad / (float)pMP->encoded_frames); /* this function is called from the scond encoded frame*/
+    if (pMP->diff_counter == 0 &&
+            ((float)rc->Qc <= aver_QP*1.1 || curr_mad <= average_mad*1.1) &&
+            pMP->counter_BTsrc <= (pMP->counter_BTdst + (Int)(pMP->framerate*1.0 + 0.5)))
+    {
+        rc->TMN_TH -= (Int)(pMP->target_bits_per_frame / 10.0);
+        rc->T = rc->TMN_TH - rc->TMN_W;
+        pMP->counter_BTsrc++;
+        pMP->diff_counter--;
+    }
+
+}
+
+
+/* ======================================================================== */
+/*  Function : updateRateControl                                            */
+/*  Date     : 11/17/2000                                                   */
+/*  Purpose  :Update the RD Modal (After Encoding the Current Frame)        */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+
+void updateRateControl(rateControl *rc, VideoEncData *video)
+{
+    Int  frame_bits;
+
+
+    /* rate contro\l */
+    frame_bits = (Int)(rc->bitrate / rc->framerate);
+    rc->TMN_W += (rc->Rc - rc->TMN_TH);
+    rc->VBV_fullness += (rc->Rc - frame_bits); //rc->Rp);
+    //if(rc->VBV_fullness < 0) rc->VBV_fullness = -1;
+
+    rc->encoded_frames++;
+
+    /* frame dropping */
+    rc->skip_next_frame = 0;
+
+    if ((video->encParams->H263_Enabled && rc->Rc > video->encParams->maxFrameSize) || /*  For H263/short header mode, drop the frame if the actual frame size exceeds the bound */
+            (rc->VBV_fullness > rc->Bs / 2 && !rc->no_pre_skip)) /* skip the current frame */ /* rc->Bs */
+    {
+        rc->TMN_W -= (rc->Rc - rc->TMN_TH);
+        rc->VBV_fullness -= rc->Rc;
+        rc->skip_next_frame = -1;
+    }
+    else if ((float)(rc->VBV_fullness - rc->VBV_fullness_offset) > (rc->Bs / 2 - rc->VBV_fullness_offset)*0.95 &&
+             !rc->no_frame_skip) /* skip next frame */
+    {
+        rc->VBV_fullness -= frame_bits; //rc->Rp;
+        rc->skip_next_frame = 1;
+        /*  skip more than 1 frames  */
+        //while(rc->VBV_fullness > rc->Bs*0.475)
+        while ((rc->VBV_fullness - rc->VBV_fullness_offset) > (rc->Bs / 2 - rc->VBV_fullness_offset)*0.95)
+        {
+            rc->VBV_fullness -= frame_bits; //rc->Rp;
+            rc->skip_next_frame++;
+        }
+        /* END  */
+    }
+
+}
+
+/* ======================================================================== */
+/*  Function : updateRC_PostProc                                            */
+/*  Date     : 04/08/2002                                                   */
+/*  Purpose  : Remaing RC update stuff for frame skip and buffer underflow  */
+/*             check                                                        */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+void updateRC_PostProc(rateControl *rc, VideoEncData *video)
+{
+    MultiPass *pMP = video->pMP[video->currLayer];
+
+    if (rc->skip_next_frame == 1 && !rc->no_frame_skip) /* skip next frame */
+    {
+        pMP->counter_BTsrc += 10 * rc->skip_next_frame;
+
+    }
+    else if (rc->skip_next_frame == -1 && !rc->no_pre_skip) /* skip current frame */
+    {
+        pMP->counter_BTdst -= pMP->diff_counter;
+        pMP->counter_BTsrc += 10;
+
+        pMP->sum_mad -= pMP->mad;
+        pMP->aver_mad = (pMP->aver_mad * pMP->encoded_frames - pMP->mad) / (float)(pMP->encoded_frames - 1 + 0.0001);
+        pMP->sum_QP  -= pMP->QP;
+        pMP->encoded_frames --;
+    }
+    /* some stuff in update VBV_fullness remains here */
+    //if(rc->VBV_fullness < -rc->Bs/2) /* rc->Bs */
+    if (rc->VBV_fullness < rc->low_bound)
+    {
+        rc->VBV_fullness = rc->low_bound; // -rc->Bs/2;
+        rc->TMN_W = rc->VBV_fullness - rc->low_bound;
+        pMP->counter_BTsrc = pMP->counter_BTdst + (Int)((float)(rc->Bs / 2 - rc->low_bound) / 2.0 / (pMP->target_bits_per_frame / 10));
+    }
+}
+
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/rate_control.h b/media/libstagefright/codecs/m4v_h263/enc/src/rate_control.h
new file mode 100644
index 0000000..ad29549
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/rate_control.h
@@ -0,0 +1,96 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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 _RATE_CONTROL_H_
+#define _RATE_CONTROL_H_
+
+#include "mp4def.h"
+
+typedef struct tagdataPointArray
+{
+    Int Qp;
+    Int Rp;
+    float Mp;   /* for MB-based RC, 3/14/01 */
+    struct tagdataPointArray *next;
+    struct tagdataPointArray *prev;
+} dataPointArray;
+
+
+typedef struct
+{
+    Int alpha;  /* weight for I frame */
+    Int Rs;     /*bit rate for the sequence (or segment) e.g., 24000 bits/sec */
+    Int Rc;     /*bits used for the current frame. It is the bit count obtained after encoding. */
+    Int Rp;     /*bits to be removed from the buffer per picture. */
+    /*? is this the average one, or just the bits coded for the previous frame */
+    Int Rps;    /*bit to be removed from buffer per src frame */
+    float Ts;   /*number of seconds for the sequence  (or segment). e.g., 10 sec */
+    float Ep;
+    float Ec;   /*mean absolute difference for the current frame after motion compensation.*/
+    /*If the macroblock is intra coded, the original spatial pixel values are summed.*/
+    Int Qc;     /*quantization level used for the current frame. */
+    Int Nr;     /*number of P frames remaining for encoding.*/
+    Int Rr; /*number of bits remaining for encoding this sequence (or segment).*/
+    Int Rr_Old;/* 12/24/00 */
+    Int T;      /*target bit to be used for the current frame.*/
+    Int S;      /*number of bits used for encoding the previous frame.*/
+    Int Hc; /*header and motion vector bits used in the current frame. It includes all the  information except to the residual information.*/
+    Int Hp; /*header and motion vector bits used in the previous frame. It includes all the     information except to the residual information.*/
+    Int Ql; /*quantization level used in the previous frame */
+    Int Bs; /*buffer size e.g., R/2 */
+    Int B;      /*current buffer level e.g., R/4 - start from the middle of the buffer */
+    float X1;
+    float X2;
+    float X11;
+    float M;            /*safe margin for the buffer */
+    float smTick;    /*ratio of src versus enc frame rate */
+    double remnant;  /*remainder frame of src/enc frame for fine frame skipping */
+    Int timeIncRes; /* vol->timeIncrementResolution */
+
+    dataPointArray   *end; /*quantization levels for the past (20) frames */
+
+    Int     frameNumber; /* ranging from 0 to 20 nodes*/
+    Int     w;
+    Int     Nr_Original;
+    Int     Nr_Old, Nr_Old2;
+    Int     skip_next_frame;
+    Int     Qdep;       /* smooth Q adjustment */
+    Int     fine_frame_skip;
+    Int     VBR_Enabled;
+    Int     no_frame_skip;
+    Int     no_pre_skip;
+
+    Int totalFrameNumber; /* total coded frames, for debugging!!*/
+
+    char    oFirstTime;
+
+    /* BX rate control */
+    Int     TMN_W;
+    Int     TMN_TH;
+    Int     VBV_fullness;
+    Int     max_BitVariance_num; /* the number of the maximum bit variance within the given buffer with the unit of 10% of bitrate/framerate*/
+    Int     encoded_frames; /* counter for all encoded frames */
+    float   framerate;
+    Int     bitrate;
+    Int     low_bound;              /* bound for underflow detection, usually low_bound=-Bs/2, but could be changed in H.263 mode */
+    Int     VBV_fullness_offset;    /* offset of VBV_fullness, usually is zero, but can be changed in H.263 mode*/
+    /* End BX */
+
+} rateControl;
+
+
+#endif /* _RATE_CONTROL_H_ */
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/sad.cpp b/media/libstagefright/codecs/m4v_h263/enc/src/sad.cpp
new file mode 100644
index 0000000..8d18f45
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/sad.cpp
@@ -0,0 +1,375 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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 "mp4def.h"
+#include "mp4lib_int.h"
+
+#include "sad_inline.h"
+
+#define Cached_lx 176
+
+#ifdef _SAD_STAT
+ULong num_sad_MB = 0;
+ULong num_sad_Blk = 0;
+ULong num_sad_MB_call = 0;
+ULong num_sad_Blk_call = 0;
+
+#define NUM_SAD_MB_CALL()       num_sad_MB_call++
+#define NUM_SAD_MB()            num_sad_MB++
+#define NUM_SAD_BLK_CALL()      num_sad_Blk_call++
+#define NUM_SAD_BLK()           num_sad_Blk++
+
+#else
+
+#define NUM_SAD_MB_CALL()
+#define NUM_SAD_MB()
+#define NUM_SAD_BLK_CALL()
+#define NUM_SAD_BLK()
+
+#endif
+
+
+/* consist of
+Int SAD_Macroblock_C(UChar *ref,UChar *blk,Int dmin,Int lx,void *extra_info)
+Int SAD_MB_HTFM_Collect(UChar *ref,UChar *blk,Int dmin,Int lx,void *extra_info)
+Int SAD_MB_HTFM(UChar *ref,UChar *blk,Int dmin,Int lx,void *extra_info)
+Int SAD_Block_C(UChar *ref,UChar *blk,Int dmin,Int lx,void *extra_info)
+Int SAD_Blk_PADDING(UChar *ref,UChar *cur,Int dmin,Int lx,void *extra_info)
+Int SAD_MB_PADDING(UChar *ref,UChar *cur,Int dmin,Int lx,void *extra_info)
+Int SAD_MB_PAD1(UChar *ref,UChar *cur,Int dmin,Int lx,Int *rep);
+Int SAD_MB_PADDING_HTFM_Collect(UChar *ref,UChar *cur,Int dmin,Int lx,void *extra_info)
+Int SAD_MB_PADDING_HTFM(UChar *ref,UChar *cur,Int dmin,Int lx,void *vptr)
+*/
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    Int SAD_MB_PAD1(UChar *ref, UChar *cur, Int dmin, Int lx, Int *rep);
+
+
+    /*==================================================================
+        Function:   SAD_Macroblock
+        Date:       09/07/2000
+        Purpose:    Compute SAD 16x16 between blk and ref.
+        To do:      Uniform subsampling will be inserted later!
+                    Hypothesis Testing Fast Matching to be used later!
+        Changes:
+    11/7/00:     implemented MMX
+    1/24/01:     implemented SSE
+    ==================================================================*/
+    /********** C ************/
+    Int SAD_Macroblock_C(UChar *ref, UChar *blk, Int dmin_lx, void *extra_info)
+    {
+        int32 x10;
+        Int dmin = (ULong)dmin_lx >> 16;
+        Int lx = dmin_lx & 0xFFFF;
+
+        OSCL_UNUSED_ARG(extra_info);
+
+        NUM_SAD_MB_CALL();
+
+        x10 = simd_sad_mb(ref, blk, dmin, lx);
+
+        return x10;
+    }
+
+#ifdef HTFM   /* HTFM with uniform subsampling implementation, 2/28/01 */
+    /*===============================================================
+        Function:   SAD_MB_HTFM_Collect and SAD_MB_HTFM
+        Date:       3/2/1
+        Purpose:    Compute the SAD on a 16x16 block using
+                    uniform subsampling and hypothesis testing fast matching
+                    for early dropout. SAD_MB_HP_HTFM_Collect is to collect
+                    the statistics to compute the thresholds to be used in
+                    SAD_MB_HP_HTFM.
+        Input/Output:
+        Changes:
+      ===============================================================*/
+
+    Int SAD_MB_HTFM_Collect(UChar *ref, UChar *blk, Int dmin_lx, void *extra_info)
+    {
+        Int i;
+        Int sad = 0;
+        UChar *p1;
+        Int lx4 = (dmin_lx << 2) & 0x3FFFC;
+        ULong cur_word;
+        Int saddata[16], tmp, tmp2;    /* used when collecting flag (global) is on */
+        Int difmad;
+        HTFM_Stat *htfm_stat = (HTFM_Stat*) extra_info;
+        Int *abs_dif_mad_avg = &(htfm_stat->abs_dif_mad_avg);
+        UInt *countbreak = &(htfm_stat->countbreak);
+        Int *offsetRef = htfm_stat->offsetRef;
+
+        NUM_SAD_MB_CALL();
+
+        blk -= 4;
+        for (i = 0; i < 16; i++)
+        {
+            p1 = ref + offsetRef[i];
+            cur_word = *((ULong*)(blk += 4));
+            tmp = p1[12];
+            tmp2 = (cur_word >> 24) & 0xFF;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = p1[8];
+            tmp2 = (cur_word >> 16) & 0xFF;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = p1[4];
+            tmp2 = (cur_word >> 8) & 0xFF;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = p1[0];
+            p1 += lx4;
+            tmp2 = (cur_word & 0xFF);
+            sad = SUB_SAD(sad, tmp, tmp2);
+
+            cur_word = *((ULong*)(blk += 4));
+            tmp = p1[12];
+            tmp2 = (cur_word >> 24) & 0xFF;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = p1[8];
+            tmp2 = (cur_word >> 16) & 0xFF;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = p1[4];
+            tmp2 = (cur_word >> 8) & 0xFF;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = p1[0];
+            p1 += lx4;
+            tmp2 = (cur_word & 0xFF);
+            sad = SUB_SAD(sad, tmp, tmp2);
+
+            cur_word = *((ULong*)(blk += 4));
+            tmp = p1[12];
+            tmp2 = (cur_word >> 24) & 0xFF;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = p1[8];
+            tmp2 = (cur_word >> 16) & 0xFF;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = p1[4];
+            tmp2 = (cur_word >> 8) & 0xFF;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = p1[0];
+            p1 += lx4;
+            tmp2 = (cur_word & 0xFF);
+            sad = SUB_SAD(sad, tmp, tmp2);
+
+            cur_word = *((ULong*)(blk += 4));
+            tmp = p1[12];
+            tmp2 = (cur_word >> 24) & 0xFF;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = p1[8];
+            tmp2 = (cur_word >> 16) & 0xFF;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = p1[4];
+            tmp2 = (cur_word >> 8) & 0xFF;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = p1[0];
+            p1 += lx4;
+            tmp2 = (cur_word & 0xFF);
+            sad = SUB_SAD(sad, tmp, tmp2);
+
+            NUM_SAD_MB();
+
+            saddata[i] = sad;
+
+            if (i > 0)
+            {
+                if ((ULong)sad > ((ULong)dmin_lx >> 16))
+                {
+                    difmad = saddata[0] - ((saddata[1] + 1) >> 1);
+                    (*abs_dif_mad_avg) += ((difmad > 0) ? difmad : -difmad);
+                    (*countbreak)++;
+                    return sad;
+                }
+            }
+        }
+
+        difmad = saddata[0] - ((saddata[1] + 1) >> 1);
+        (*abs_dif_mad_avg) += ((difmad > 0) ? difmad : -difmad);
+        (*countbreak)++;
+        return sad;
+    }
+
+    Int SAD_MB_HTFM(UChar *ref, UChar *blk, Int dmin_lx, void *extra_info)
+    {
+        Int sad = 0;
+        UChar *p1;
+
+        Int i;
+        Int tmp, tmp2;
+        Int lx4 = (dmin_lx << 2) & 0x3FFFC;
+        Int sadstar = 0, madstar;
+        Int *nrmlz_th = (Int*) extra_info;
+        Int *offsetRef = (Int*) extra_info + 32;
+        ULong cur_word;
+
+        madstar = (ULong)dmin_lx >> 20;
+
+        NUM_SAD_MB_CALL();
+
+        blk -= 4;
+        for (i = 0; i < 16; i++)
+        {
+            p1 = ref + offsetRef[i];
+            cur_word = *((ULong*)(blk += 4));
+            tmp = p1[12];
+            tmp2 = (cur_word >> 24) & 0xFF;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = p1[8];
+            tmp2 = (cur_word >> 16) & 0xFF;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = p1[4];
+            tmp2 = (cur_word >> 8) & 0xFF;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = p1[0];
+            p1 += lx4;
+            tmp2 = (cur_word & 0xFF);
+            sad = SUB_SAD(sad, tmp, tmp2);
+
+            cur_word = *((ULong*)(blk += 4));
+            tmp = p1[12];
+            tmp2 = (cur_word >> 24) & 0xFF;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = p1[8];
+            tmp2 = (cur_word >> 16) & 0xFF;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = p1[4];
+            tmp2 = (cur_word >> 8) & 0xFF;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = p1[0];
+            p1 += lx4;
+            tmp2 = (cur_word & 0xFF);
+            sad = SUB_SAD(sad, tmp, tmp2);
+
+            cur_word = *((ULong*)(blk += 4));
+            tmp = p1[12];
+            tmp2 = (cur_word >> 24) & 0xFF;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = p1[8];
+            tmp2 = (cur_word >> 16) & 0xFF;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = p1[4];
+            tmp2 = (cur_word >> 8) & 0xFF;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = p1[0];
+            p1 += lx4;
+            tmp2 = (cur_word & 0xFF);
+            sad = SUB_SAD(sad, tmp, tmp2);
+
+            cur_word = *((ULong*)(blk += 4));
+            tmp = p1[12];
+            tmp2 = (cur_word >> 24) & 0xFF;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = p1[8];
+            tmp2 = (cur_word >> 16) & 0xFF;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = p1[4];
+            tmp2 = (cur_word >> 8) & 0xFF;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = p1[0];
+            p1 += lx4;
+            tmp2 = (cur_word & 0xFF);
+            sad = SUB_SAD(sad, tmp, tmp2);
+
+            NUM_SAD_MB();
+
+            sadstar += madstar;
+            if (((ULong)sad <= ((ULong)dmin_lx >> 16)) && (sad <= (sadstar - *nrmlz_th++)))
+                ;
+            else
+                return 65536;
+        }
+
+        return sad;
+    }
+#endif /* HTFM */
+
+#ifndef NO_INTER4V
+    /*==================================================================
+        Function:   SAD_Block
+        Date:       09/07/2000
+        Purpose:    Compute SAD 16x16 between blk and ref.
+        To do:      Uniform subsampling will be inserted later!
+                    Hypothesis Testing Fast Matching to be used later!
+        Changes:
+    11/7/00:     implemented MMX
+    1/24/01:     implemented SSE
+      ==================================================================*/
+    /********** C ************/
+    Int SAD_Block_C(UChar *ref, UChar *blk, Int dmin, Int lx, void *)
+    {
+        Int sad = 0;
+
+        Int i;
+        UChar *ii;
+        Int *kk;
+        Int tmp, tmp2, tmp3, mask = 0xFF;
+        Int width = (lx - 32);
+
+        NUM_SAD_BLK_CALL();
+
+        ii = ref;
+        kk  = (Int*)blk; /* assuming word-align for blk */
+        for (i = 0; i < 8; i++)
+        {
+            tmp3 = kk[1];
+            tmp = ii[7];
+            tmp2 = (UInt)tmp3 >> 24;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = ii[6];
+            tmp2 = (tmp3 >> 16) & mask;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = ii[5];
+            tmp2 = (tmp3 >> 8) & mask;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = ii[4];
+            tmp2 = tmp3 & mask;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp3 = *kk;
+            kk += (width >> 2);
+            tmp = ii[3];
+            tmp2 = (UInt)tmp3 >> 24;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = ii[2];
+            tmp2 = (tmp3 >> 16) & mask;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = ii[1];
+            tmp2 = (tmp3 >> 8) & mask;
+            sad = SUB_SAD(sad, tmp, tmp2);
+            tmp = *ii;
+            ii += lx;
+            tmp2 = tmp3 & mask;
+            sad = SUB_SAD(sad, tmp, tmp2);
+
+            NUM_SAD_BLK();
+
+            if (sad > dmin)
+                return sad;
+        }
+
+        return sad;
+    }
+
+#endif /* NO_INTER4V */
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/sad_halfpel.cpp b/media/libstagefright/codecs/m4v_h263/enc/src/sad_halfpel.cpp
new file mode 100644
index 0000000..f05697c
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/sad_halfpel.cpp
@@ -0,0 +1,855 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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.
+ * -------------------------------------------------------------------
+ */
+/* contains
+Int HalfPel1_SAD_MB(UChar *ref,UChar *blk,Int dmin,Int width,Int ih,Int jh)
+Int HalfPel2_SAD_MB(UChar *ref,UChar *blk,Int dmin,Int width)
+Int HalfPel1_SAD_Blk(UChar *ref,UChar *blk,Int dmin,Int width,Int ih,Int jh)
+Int HalfPel2_SAD_Blk(UChar *ref,UChar *blk,Int dmin,Int width)
+
+Int SAD_MB_HalfPel_C(UChar *ref,UChar *blk,Int dmin,Int width,Int rx,Int xh,Int yh,void *extra_info)
+Int SAD_MB_HP_HTFM_Collect(UChar *ref,UChar *blk,Int dmin,Int width,Int rx,Int xh,Int yh,void *extra_info)
+Int SAD_MB_HP_HTFM(UChar *ref,UChar *blk,Int dmin,Int width,Int rx,Int xh,Int yh,void *extra_info)
+Int SAD_Blk_HalfPel_C(UChar *ref,UChar *blk,Int dmin,Int width,Int rx,Int xh,Int yh,void *extra_info)
+*/
+
+//#include <stdlib.h> /* for RAND_MAX */
+#include "mp4def.h"
+#include "mp4lib_int.h"
+#include "sad_halfpel_inline.h"
+
+#ifdef _SAD_STAT
+ULong num_sad_HP_MB = 0;
+ULong num_sad_HP_Blk = 0;
+ULong num_sad_HP_MB_call = 0;
+ULong num_sad_HP_Blk_call = 0;
+#define NUM_SAD_HP_MB_CALL()    num_sad_HP_MB_call++
+#define NUM_SAD_HP_MB()         num_sad_HP_MB++
+#define NUM_SAD_HP_BLK_CALL()   num_sad_HP_Blk_call++
+#define NUM_SAD_HP_BLK()        num_sad_HP_Blk++
+#else
+#define NUM_SAD_HP_MB_CALL()
+#define NUM_SAD_HP_MB()
+#define NUM_SAD_HP_BLK_CALL()
+#define NUM_SAD_HP_BLK()
+#endif
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+    /*==================================================================
+        Function:   HalfPel1_SAD_MB
+        Date:       03/27/2001
+        Purpose:    Compute SAD 16x16 between blk and ref in halfpel
+                    resolution,
+        Changes:
+      ==================================================================*/
+    /* One component is half-pel */
+    Int HalfPel1_SAD_MB(UChar *ref, UChar *blk, Int dmin, Int width, Int ih, Int jh)
+    {
+        Int i, j;
+        Int sad = 0;
+        UChar *kk, *p1, *p2;
+        Int temp;
+
+        OSCL_UNUSED_ARG(jh);
+
+        p1 = ref;
+        if (ih) p2 = ref + 1;
+        else p2 = ref + width;
+        kk  = blk;
+
+        for (i = 0; i < 16; i++)
+        {
+            for (j = 0; j < 16; j++)
+            {
+
+                temp = ((p1[j] + p2[j] + 1) >> 1) - *kk++;
+                sad += PV_ABS(temp);
+            }
+
+            if (sad > dmin)
+                return sad;
+            p1 += width;
+            p2 += width;
+        }
+        return sad;
+    }
+
+    /* Two components need half-pel */
+    Int HalfPel2_SAD_MB(UChar *ref, UChar *blk, Int dmin, Int width)
+    {
+        Int i, j;
+        Int sad = 0;
+        UChar *kk, *p1, *p2, *p3, *p4;
+        Int temp;
+
+        p1 = ref;
+        p2 = ref + 1;
+        p3 = ref + width;
+        p4 = ref + width + 1;
+        kk  = blk;
+
+        for (i = 0; i < 16; i++)
+        {
+            for (j = 0; j < 16; j++)
+            {
+
+                temp = ((p1[j] + p2[j] + p3[j] + p4[j] + 2) >> 2) - *kk++;
+                sad += PV_ABS(temp);
+            }
+
+            if (sad > dmin)
+                return sad;
+
+            p1 += width;
+            p3 += width;
+            p2 += width;
+            p4 += width;
+        }
+        return sad;
+    }
+
+#ifndef NO_INTER4V
+    /*==================================================================
+        Function:   HalfPel1_SAD_Blk
+        Date:       03/27/2001
+        Purpose:    Compute SAD 8x8 between blk and ref in halfpel
+                    resolution.
+        Changes:
+      ==================================================================*/
+    /* One component needs half-pel */
+    Int HalfPel1_SAD_Blk(UChar *ref, UChar *blk, Int dmin, Int width, Int ih, Int jh)
+    {
+        Int i, j;
+        Int sad = 0;
+        UChar *kk, *p1, *p2;
+        Int temp;
+
+        OSCL_UNUSED_ARG(jh);
+
+        p1 = ref;
+        if (ih) p2 = ref + 1;
+        else p2 = ref + width;
+        kk  = blk;
+
+        for (i = 0; i < 8; i++)
+        {
+            for (j = 0; j < 8; j++)
+            {
+
+                temp = ((p1[j] + p2[j] + 1) >> 1) - *kk++;
+                sad += PV_ABS(temp);
+            }
+
+            if (sad > dmin)
+                return sad;
+            p1 += width;
+            p2 += width;
+            kk += 8;
+        }
+        return sad;
+    }
+    /* Two components need half-pel */
+    Int HalfPel2_SAD_Blk(UChar *ref, UChar *blk, Int dmin, Int width)
+    {
+        Int i, j;
+        Int sad = 0;
+        UChar *kk, *p1, *p2, *p3, *p4;
+        Int temp;
+
+        p1 = ref;
+        p2 = ref + 1;
+        p3 = ref + width;
+        p4 = ref + width + 1;
+        kk  = blk;
+
+        for (i = 0; i < 8; i++)
+        {
+            for (j = 0; j < 8; j++)
+            {
+
+                temp = ((p1[j] + p2[j] + p3[j] + p4[j] + 2) >> 2) - *kk++;
+                sad += PV_ABS(temp);
+            }
+
+            if (sad > dmin)
+                return sad;
+
+            p1 += width;
+            p3 += width;
+            p2 += width;
+            p4 += width;
+            kk += 8;
+        }
+        return sad;
+    }
+#endif // NO_INTER4V
+    /*===============================================================
+        Function:   SAD_MB_HalfPel
+        Date:       09/17/2000
+        Purpose:    Compute the SAD on the half-pel resolution
+        Input/Output:   hmem is assumed to be a pointer to the starting
+                    point of the search in the 33x33 matrix search region
+        Changes:
+    11/7/00:     implemented MMX
+      ===============================================================*/
+    /*==================================================================
+        Function:   SAD_MB_HalfPel_C
+        Date:       04/30/2001
+        Purpose:    Compute SAD 16x16 between blk and ref in halfpel
+                    resolution,
+        Changes:
+      ==================================================================*/
+    /* One component is half-pel */
+    Int SAD_MB_HalfPel_Cxhyh(UChar *ref, UChar *blk, Int dmin_rx, void *extra_info)
+    {
+        Int i, j;
+        Int sad = 0;
+        UChar *kk, *p1, *p2, *p3, *p4;
+//  Int sumref=0;
+        Int temp;
+        Int rx = dmin_rx & 0xFFFF;
+
+        OSCL_UNUSED_ARG(extra_info);
+
+        NUM_SAD_HP_MB_CALL();
+
+        p1 = ref;
+        p2 = ref + 1;
+        p3 = ref + rx;
+        p4 = ref + rx + 1;
+        kk  = blk;
+
+        for (i = 0; i < 16; i++)
+        {
+            for (j = 0; j < 16; j++)
+            {
+
+                temp = ((p1[j] + p2[j] + p3[j] + p4[j] + 2) >> 2) - *kk++;
+                sad += PV_ABS(temp);
+            }
+
+            NUM_SAD_HP_MB();
+
+            if (sad > (Int)((ULong)dmin_rx >> 16))
+                return sad;
+
+            p1 += rx;
+            p3 += rx;
+            p2 += rx;
+            p4 += rx;
+        }
+        return sad;
+    }
+
+    Int SAD_MB_HalfPel_Cyh(UChar *ref, UChar *blk, Int dmin_rx, void *extra_info)
+    {
+        Int i, j;
+        Int sad = 0;
+        UChar *kk, *p1, *p2;
+//  Int sumref=0;
+        Int temp;
+        Int rx = dmin_rx & 0xFFFF;
+
+        OSCL_UNUSED_ARG(extra_info);
+
+        NUM_SAD_HP_MB_CALL();
+
+        p1 = ref;
+        p2 = ref + rx; /* either left/right or top/bottom pixel */
+        kk  = blk;
+
+        for (i = 0; i < 16; i++)
+        {
+            for (j = 0; j < 16; j++)
+            {
+
+                temp = ((p1[j] + p2[j] + 1) >> 1) - *kk++;
+                sad += PV_ABS(temp);
+            }
+
+            NUM_SAD_HP_MB();
+
+            if (sad > (Int)((ULong)dmin_rx >> 16))
+                return sad;
+            p1 += rx;
+            p2 += rx;
+        }
+        return sad;
+    }
+
+    Int SAD_MB_HalfPel_Cxh(UChar *ref, UChar *blk, Int dmin_rx, void *extra_info)
+    {
+        Int i, j;
+        Int sad = 0;
+        UChar *kk, *p1;
+//  Int sumref=0;
+        Int temp;
+        Int rx = dmin_rx & 0xFFFF;
+
+        OSCL_UNUSED_ARG(extra_info);
+
+        NUM_SAD_HP_MB_CALL();
+
+        p1 = ref;
+        kk  = blk;
+
+        for (i = 0; i < 16; i++)
+        {
+            for (j = 0; j < 16; j++)
+            {
+
+                temp = ((p1[j] + p1[j+1] + 1) >> 1) - *kk++;
+                sad += PV_ABS(temp);
+            }
+
+            NUM_SAD_HP_MB();
+
+            if (sad > (Int)((ULong)dmin_rx >> 16))
+                return sad;
+            p1 += rx;
+        }
+        return sad;
+    }
+
+#ifdef HTFM  /* HTFM with uniform subsampling implementation, 2/28/01 */
+
+//Checheck here
+    Int SAD_MB_HP_HTFM_Collectxhyh(UChar *ref, UChar *blk, Int dmin_rx, void *extra_info)
+    {
+        Int i, j;
+        Int sad = 0;
+        UChar *p1, *p2;
+        Int rx = dmin_rx & 0xFFFF;
+        Int refwx4 = rx << 2;
+        Int saddata[16];      /* used when collecting flag (global) is on */
+        Int difmad, tmp, tmp2;
+        HTFM_Stat *htfm_stat = (HTFM_Stat*) extra_info;
+        Int *abs_dif_mad_avg = &(htfm_stat->abs_dif_mad_avg);
+        UInt *countbreak = &(htfm_stat->countbreak);
+        Int *offsetRef = htfm_stat->offsetRef;
+        ULong cur_word;
+
+        NUM_SAD_HP_MB_CALL();
+
+        blk -= 4;
+
+        for (i = 0; i < 16; i++) /* 16 stages */
+        {
+            p1 = ref + offsetRef[i];
+            p2 = p1 + rx;
+
+            j = 4;/* 4 lines */
+            do
+            {
+                cur_word = *((ULong*)(blk += 4));
+                tmp = p1[12] + p2[12];
+                tmp2 = p1[13] + p2[13];
+                tmp += tmp2;
+                tmp2 = (cur_word >> 24) & 0xFF;
+                tmp += 2;
+                sad = INTERP2_SUB_SAD(sad, tmp, tmp2);;
+                tmp = p1[8] + p2[8];
+                tmp2 = p1[9] + p2[9];
+                tmp += tmp2;
+                tmp2 = (cur_word >> 16) & 0xFF;
+                tmp += 2;
+                sad = INTERP2_SUB_SAD(sad, tmp, tmp2);;
+                tmp = p1[4] + p2[4];
+                tmp2 = p1[5] + p2[5];
+                tmp += tmp2;
+                tmp2 = (cur_word >> 8) & 0xFF;
+                tmp += 2;
+                sad = INTERP2_SUB_SAD(sad, tmp, tmp2);;
+                tmp2 = p1[1] + p2[1];
+                tmp = p1[0] + p2[0];
+                p1 += refwx4;
+                p2 += refwx4;
+                tmp += tmp2;
+                tmp2 = (cur_word & 0xFF);
+                tmp += 2;
+                sad = INTERP2_SUB_SAD(sad, tmp, tmp2);;
+            }
+            while (--j);
+
+            NUM_SAD_HP_MB();
+
+            saddata[i] = sad;
+
+            if (i > 0)
+            {
+                if (sad > (Int)((ULong)dmin_rx >> 16))
+                {
+                    difmad = saddata[0] - ((saddata[1] + 1) >> 1);
+                    (*abs_dif_mad_avg) += ((difmad > 0) ? difmad : -difmad);
+                    (*countbreak)++;
+                    return sad;
+                }
+            }
+        }
+        difmad = saddata[0] - ((saddata[1] + 1) >> 1);
+        (*abs_dif_mad_avg) += ((difmad > 0) ? difmad : -difmad);
+        (*countbreak)++;
+
+        return sad;
+    }
+
+    Int SAD_MB_HP_HTFM_Collectyh(UChar *ref, UChar *blk, Int dmin_rx, void *extra_info)
+    {
+        Int i, j;
+        Int sad = 0;
+        UChar *p1, *p2;
+        Int rx = dmin_rx & 0xFFFF;
+        Int refwx4 = rx << 2;
+        Int saddata[16];      /* used when collecting flag (global) is on */
+        Int difmad, tmp, tmp2;
+        HTFM_Stat *htfm_stat = (HTFM_Stat*) extra_info;
+        Int *abs_dif_mad_avg = &(htfm_stat->abs_dif_mad_avg);
+        UInt *countbreak = &(htfm_stat->countbreak);
+        Int *offsetRef = htfm_stat->offsetRef;
+        ULong cur_word;
+
+        NUM_SAD_HP_MB_CALL();
+
+        blk -= 4;
+
+        for (i = 0; i < 16; i++) /* 16 stages */
+        {
+            p1 = ref + offsetRef[i];
+            p2 = p1 + rx;
+            j = 4;
+            do
+            {
+                cur_word = *((ULong*)(blk += 4));
+                tmp = p1[12];
+                tmp2 = p2[12];
+                tmp++;
+                tmp2 += tmp;
+                tmp = (cur_word >> 24) & 0xFF;
+                sad = INTERP1_SUB_SAD(sad, tmp, tmp2);;
+                tmp = p1[8];
+                tmp2 = p2[8];
+                tmp++;
+                tmp2 += tmp;
+                tmp = (cur_word >> 16) & 0xFF;
+                sad = INTERP1_SUB_SAD(sad, tmp, tmp2);;
+                tmp = p1[4];
+                tmp2 = p2[4];
+                tmp++;
+                tmp2 += tmp;
+                tmp = (cur_word >> 8) & 0xFF;
+                sad = INTERP1_SUB_SAD(sad, tmp, tmp2);;
+                tmp = p1[0];
+                p1 += refwx4;
+                tmp2 = p2[0];
+                p2 += refwx4;
+                tmp++;
+                tmp2 += tmp;
+                tmp = (cur_word & 0xFF);
+                sad = INTERP1_SUB_SAD(sad, tmp, tmp2);;
+            }
+            while (--j);
+
+            NUM_SAD_HP_MB();
+
+            saddata[i] = sad;
+
+            if (i > 0)
+            {
+                if (sad > (Int)((ULong)dmin_rx >> 16))
+                {
+                    difmad = saddata[0] - ((saddata[1] + 1) >> 1);
+                    (*abs_dif_mad_avg) += ((difmad > 0) ? difmad : -difmad);
+                    (*countbreak)++;
+                    return sad;
+                }
+            }
+        }
+        difmad = saddata[0] - ((saddata[1] + 1) >> 1);
+        (*abs_dif_mad_avg) += ((difmad > 0) ? difmad : -difmad);
+        (*countbreak)++;
+
+        return sad;
+    }
+
+    Int SAD_MB_HP_HTFM_Collectxh(UChar *ref, UChar *blk, Int dmin_rx, void *extra_info)
+    {
+        Int i, j;
+        Int sad = 0;
+        UChar *p1;
+        Int rx = dmin_rx & 0xFFFF;
+        Int refwx4 = rx << 2;
+        Int saddata[16];      /* used when collecting flag (global) is on */
+        Int difmad, tmp, tmp2;
+        HTFM_Stat *htfm_stat = (HTFM_Stat*) extra_info;
+        Int *abs_dif_mad_avg = &(htfm_stat->abs_dif_mad_avg);
+        UInt *countbreak = &(htfm_stat->countbreak);
+        Int *offsetRef = htfm_stat->offsetRef;
+        ULong cur_word;
+
+        NUM_SAD_HP_MB_CALL();
+
+        blk -= 4;
+
+        for (i = 0; i < 16; i++) /* 16 stages */
+        {
+            p1 = ref + offsetRef[i];
+
+            j = 4; /* 4 lines */
+            do
+            {
+                cur_word = *((ULong*)(blk += 4));
+                tmp = p1[12];
+                tmp2 = p1[13];
+                tmp++;
+                tmp2 += tmp;
+                tmp = (cur_word >> 24) & 0xFF;
+                sad = INTERP1_SUB_SAD(sad, tmp, tmp2);;
+                tmp = p1[8];
+                tmp2 = p1[9];
+                tmp++;
+                tmp2 += tmp;
+                tmp = (cur_word >> 16) & 0xFF;
+                sad = INTERP1_SUB_SAD(sad, tmp, tmp2);;
+                tmp = p1[4];
+                tmp2 = p1[5];
+                tmp++;
+                tmp2 += tmp;
+                tmp = (cur_word >> 8) & 0xFF;
+                sad = INTERP1_SUB_SAD(sad, tmp, tmp2);;
+                tmp = p1[0];
+                tmp2 = p1[1];
+                p1 += refwx4;
+                tmp++;
+                tmp2 += tmp;
+                tmp = (cur_word & 0xFF);
+                sad = INTERP1_SUB_SAD(sad, tmp, tmp2);;
+            }
+            while (--j);
+
+            NUM_SAD_HP_MB();
+
+            saddata[i] = sad;
+
+            if (i > 0)
+            {
+                if (sad > (Int)((ULong)dmin_rx >> 16))
+                {
+                    difmad = saddata[0] - ((saddata[1] + 1) >> 1);
+                    (*abs_dif_mad_avg) += ((difmad > 0) ? difmad : -difmad);
+                    (*countbreak)++;
+                    return sad;
+                }
+            }
+        }
+        difmad = saddata[0] - ((saddata[1] + 1) >> 1);
+        (*abs_dif_mad_avg) += ((difmad > 0) ? difmad : -difmad);
+        (*countbreak)++;
+
+        return sad;
+    }
+
+    Int SAD_MB_HP_HTFMxhyh(UChar *ref, UChar *blk, Int dmin_rx, void *extra_info)
+    {
+        Int i, j;
+        Int sad = 0, tmp, tmp2;
+        UChar *p1, *p2;
+        Int rx = dmin_rx & 0xFFFF;
+        Int refwx4 = rx << 2;
+        Int sadstar = 0, madstar;
+        Int *nrmlz_th = (Int*) extra_info;
+        Int *offsetRef = nrmlz_th + 32;
+        ULong cur_word;
+
+        madstar = (ULong)dmin_rx >> 20;
+
+        NUM_SAD_HP_MB_CALL();
+
+        blk -= 4;
+
+        for (i = 0; i < 16; i++) /* 16 stages */
+        {
+            p1 = ref + offsetRef[i];
+            p2 = p1 + rx;
+
+            j = 4; /* 4 lines */
+            do
+            {
+                cur_word = *((ULong*)(blk += 4));
+                tmp = p1[12] + p2[12];
+                tmp2 = p1[13] + p2[13];
+                tmp += tmp2;
+                tmp2 = (cur_word >> 24) & 0xFF;
+                tmp += 2;
+                sad = INTERP2_SUB_SAD(sad, tmp, tmp2);;
+                tmp = p1[8] + p2[8];
+                tmp2 = p1[9] + p2[9];
+                tmp += tmp2;
+                tmp2 = (cur_word >> 16) & 0xFF;
+                tmp += 2;
+                sad = INTERP2_SUB_SAD(sad, tmp, tmp2);;
+                tmp = p1[4] + p2[4];
+                tmp2 = p1[5] + p2[5];
+                tmp += tmp2;
+                tmp2 = (cur_word >> 8) & 0xFF;
+                tmp += 2;
+                sad = INTERP2_SUB_SAD(sad, tmp, tmp2);;
+                tmp2 = p1[1] + p2[1];
+                tmp = p1[0] + p2[0];
+                p1 += refwx4;
+                p2 += refwx4;
+                tmp += tmp2;
+                tmp2 = (cur_word & 0xFF);
+                tmp += 2;
+                sad = INTERP2_SUB_SAD(sad, tmp, tmp2);;
+            }
+            while (--j);
+
+            NUM_SAD_HP_MB();
+
+            sadstar += madstar;
+            if (sad > sadstar - nrmlz_th[i] || sad > (Int)((ULong)dmin_rx >> 16))
+            {
+                return 65536;
+            }
+        }
+
+        return sad;
+    }
+
+    Int SAD_MB_HP_HTFMyh(UChar *ref, UChar *blk, Int dmin_rx, void *extra_info)
+    {
+        Int i, j;
+        Int sad = 0, tmp, tmp2;
+        UChar *p1, *p2;
+        Int rx = dmin_rx & 0xFFFF;
+        Int refwx4 = rx << 2;
+        Int sadstar = 0, madstar;
+        Int *nrmlz_th = (Int*) extra_info;
+        Int *offsetRef = nrmlz_th + 32;
+        ULong cur_word;
+
+        madstar = (ULong)dmin_rx >> 20;
+
+        NUM_SAD_HP_MB_CALL();
+
+        blk -= 4;
+
+        for (i = 0; i < 16; i++) /* 16 stages */
+        {
+            p1 = ref + offsetRef[i];
+            p2 = p1 + rx;
+            j = 4;
+            do
+            {
+                cur_word = *((ULong*)(blk += 4));
+                tmp = p1[12];
+                tmp2 = p2[12];
+                tmp++;
+                tmp2 += tmp;
+                tmp = (cur_word >> 24) & 0xFF;
+                sad = INTERP1_SUB_SAD(sad, tmp, tmp2);;
+                tmp = p1[8];
+                tmp2 = p2[8];
+                tmp++;
+                tmp2 += tmp;
+                tmp = (cur_word >> 16) & 0xFF;
+                sad = INTERP1_SUB_SAD(sad, tmp, tmp2);;
+                tmp = p1[4];
+                tmp2 = p2[4];
+                tmp++;
+                tmp2 += tmp;
+                tmp = (cur_word >> 8) & 0xFF;
+                sad = INTERP1_SUB_SAD(sad, tmp, tmp2);;
+                tmp = p1[0];
+                p1 += refwx4;
+                tmp2 = p2[0];
+                p2 += refwx4;
+                tmp++;
+                tmp2 += tmp;
+                tmp = (cur_word & 0xFF);
+                sad = INTERP1_SUB_SAD(sad, tmp, tmp2);;
+            }
+            while (--j);
+
+            NUM_SAD_HP_MB();
+            sadstar += madstar;
+            if (sad > sadstar - nrmlz_th[i] || sad > (Int)((ULong)dmin_rx >> 16))
+            {
+                return 65536;
+            }
+        }
+
+        return sad;
+    }
+
+    Int SAD_MB_HP_HTFMxh(UChar *ref, UChar *blk, Int dmin_rx, void *extra_info)
+    {
+        Int i, j;
+        Int sad = 0, tmp, tmp2;
+        UChar *p1;
+        Int rx = dmin_rx & 0xFFFF;
+        Int refwx4 = rx << 2;
+        Int sadstar = 0, madstar;
+        Int *nrmlz_th = (Int*) extra_info;
+        Int *offsetRef = nrmlz_th + 32;
+        ULong cur_word;
+
+        madstar = (ULong)dmin_rx >> 20;
+
+        NUM_SAD_HP_MB_CALL();
+
+        blk -= 4;
+
+        for (i = 0; i < 16; i++) /* 16 stages */
+        {
+            p1 = ref + offsetRef[i];
+
+            j = 4;/* 4 lines */
+            do
+            {
+                cur_word = *((ULong*)(blk += 4));
+                tmp = p1[12];
+                tmp2 = p1[13];
+                tmp++;
+                tmp2 += tmp;
+                tmp = (cur_word >> 24) & 0xFF;
+                sad = INTERP1_SUB_SAD(sad, tmp, tmp2);;
+                tmp = p1[8];
+                tmp2 = p1[9];
+                tmp++;
+                tmp2 += tmp;
+                tmp = (cur_word >> 16) & 0xFF;
+                sad = INTERP1_SUB_SAD(sad, tmp, tmp2);;
+                tmp = p1[4];
+                tmp2 = p1[5];
+                tmp++;
+                tmp2 += tmp;
+                tmp = (cur_word >> 8) & 0xFF;
+                sad = INTERP1_SUB_SAD(sad, tmp, tmp2);;
+                tmp = p1[0];
+                tmp2 = p1[1];
+                p1 += refwx4;
+                tmp++;
+                tmp2 += tmp;
+                tmp = (cur_word & 0xFF);
+                sad = INTERP1_SUB_SAD(sad, tmp, tmp2);;
+            }
+            while (--j);
+
+            NUM_SAD_HP_MB();
+
+            sadstar += madstar;
+            if (sad > sadstar - nrmlz_th[i] || sad > (Int)((ULong)dmin_rx >> 16))
+            {
+                return 65536;
+            }
+        }
+
+        return sad;
+    }
+
+#endif /* HTFM */
+
+#ifndef NO_INTER4V
+    /*==================================================================
+        Function:   SAD_Blk_HalfPel_C
+        Date:       04/30/2001
+        Purpose:    Compute SAD 16x16 between blk and ref in halfpel
+                    resolution,
+        Changes:
+      ==================================================================*/
+    /* One component is half-pel */
+    Int SAD_Blk_HalfPel_C(UChar *ref, UChar *blk, Int dmin, Int width, Int rx, Int xh, Int yh, void *extra_info)
+    {
+        Int i, j;
+        Int sad = 0;
+        UChar *kk, *p1, *p2, *p3, *p4;
+        Int temp;
+
+        OSCL_UNUSED_ARG(extra_info);
+
+        NUM_SAD_HP_BLK_CALL();
+
+        if (xh && yh)
+        {
+            p1 = ref;
+            p2 = ref + xh;
+            p3 = ref + yh * rx;
+            p4 = ref + yh * rx + xh;
+            kk  = blk;
+
+            for (i = 0; i < 8; i++)
+            {
+                for (j = 0; j < 8; j++)
+                {
+
+                    temp = ((p1[j] + p2[j] + p3[j] + p4[j] + 2) >> 2) - kk[j];
+                    sad += PV_ABS(temp);
+                }
+
+                NUM_SAD_HP_BLK();
+
+                if (sad > dmin)
+                    return sad;
+
+                p1 += rx;
+                p3 += rx;
+                p2 += rx;
+                p4 += rx;
+                kk += width;
+            }
+            return sad;
+        }
+        else
+        {
+            p1 = ref;
+            p2 = ref + xh + yh * rx; /* either left/right or top/bottom pixel */
+
+            kk  = blk;
+
+            for (i = 0; i < 8; i++)
+            {
+                for (j = 0; j < 8; j++)
+                {
+
+                    temp = ((p1[j] + p2[j] + 1) >> 1) - kk[j];
+                    sad += PV_ABS(temp);
+                }
+
+                NUM_SAD_HP_BLK();
+
+                if (sad > dmin)
+                    return sad;
+                p1 += rx;
+                p2 += rx;
+                kk += width;
+            }
+            return sad;
+        }
+    }
+#endif /* NO_INTER4V */
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/sad_halfpel_inline.h b/media/libstagefright/codecs/m4v_h263/enc/src/sad_halfpel_inline.h
new file mode 100644
index 0000000..d55778f
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/sad_halfpel_inline.h
@@ -0,0 +1,130 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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.
+ * -------------------------------------------------------------------
+ */
+/*********************************************************************************/
+/*  Filename: sad_halfpel_inline.h                                                      */
+/*  Description: Implementation for in-line functions used in dct.cpp           */
+/*  Modified:                                                                   */
+/*********************************************************************************/
+
+#ifndef _SAD_HALFPEL_INLINE_H_
+#define _SAD_HALFPEL_INLINE_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#if !defined(PV_ARM_GCC_V5) && !defined(PV_ARM_GCC_V4) /* ARM GNU COMPILER  */
+
+    __inline int32 INTERP1_SUB_SAD(int32 sad, int32 tmp, int32 tmp2)
+    {
+        tmp = (tmp2 >> 1) - tmp;
+        if (tmp > 0) sad += tmp;
+        else sad -= tmp;
+
+        return sad;
+    }
+
+    __inline int32 INTERP2_SUB_SAD(int32 sad, int32 tmp, int32 tmp2)
+    {
+        tmp = (tmp >> 2) - tmp2;
+        if (tmp > 0) sad += tmp;
+        else sad -= tmp;
+
+        return sad;
+    }
+
+#elif defined(__CC_ARM)  /* only work with arm v5 */
+
+    __inline int32 INTERP1_SUB_SAD(int32 sad, int32 tmp, int32 tmp2)
+    {
+        __asm
+        {
+            rsbs    tmp, tmp, tmp2, asr #1 ;
+            rsbmi   tmp, tmp, #0 ;
+            add     sad, sad, tmp ;
+        }
+
+        return sad;
+    }
+
+    __inline int32 INTERP2_SUB_SAD(int32 sad, int32 tmp, int32 tmp2)
+    {
+        __asm
+        {
+            rsbs    tmp, tmp2, tmp, asr #2 ;
+            rsbmi   tmp, tmp, #0 ;
+            add     sad, sad, tmp ;
+        }
+
+        return sad;
+    }
+
+#elif ( defined(PV_ARM_GCC_V5) || defined(PV_ARM_GCC_V4) ) /* ARM GNU COMPILER  */
+
+
+    __inline int32 INTERP1_SUB_SAD(int32 sad, int32 tmp, int32 tmp2)
+    {
+        register int32 out;
+        register int32 temp1;
+        register int32 ss = sad;
+        register int32 tt = tmp;
+        register int32 uu = tmp2;
+
+        asm volatile("rsbs	%1, %3, %4, asr #1\n\t"
+                     "rsbmi %1, %1, #0\n\t"
+                     "add  %0, %2, %1"
+             : "=&r"(out),
+                     "=&r"(temp1)
+                             : "r"(ss),
+                             "r"(tt),
+                             "r"(uu));
+        return out;
+    }
+
+
+    __inline int32 INTERP2_SUB_SAD(int32 sad, int32 tmp, int32 tmp2)
+{
+        register int32 out;
+        register int32 temp1;
+        register int32 ss = sad;
+        register int32 tt = tmp;
+        register int32 uu = tmp2;
+
+        asm volatile("rsbs      %1, %4, %3, asr #2\n\t"
+                     "rsbmi %1, %1, #0\n\t"
+                     "add  %0, %2, %1"
+             : "=&r"(out),
+                     "=&r"(temp1)
+                             : "r"(ss),
+                             "r"(tt),
+                             "r"(uu));
+        return out;
+    }
+
+
+#endif // Diff OS
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //_SAD_HALFPEL_INLINE_H_
+
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/sad_inline.h b/media/libstagefright/codecs/m4v_h263/enc/src/sad_inline.h
new file mode 100644
index 0000000..ba77dfd
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/sad_inline.h
@@ -0,0 +1,539 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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.
+ * -------------------------------------------------------------------
+ */
+/*********************************************************************************/
+/*  Filename: sad_inline.h                                                      */
+/*  Description: Implementation for in-line functions used in dct.cpp           */
+/*  Modified:                                                                   */
+/*********************************************************************************/
+#ifndef _SAD_INLINE_H_
+#define _SAD_INLINE_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#if !defined(PV_ARM_GCC_V5) && !defined(PV_ARM_GCC_V4) /* ARM GNU COMPILER  */
+
+    __inline int32 SUB_SAD(int32 sad, int32 tmp, int32 tmp2)
+    {
+        tmp = tmp - tmp2;
+        if (tmp > 0) sad += tmp;
+        else sad -= tmp;
+
+        return sad;
+    }
+
+    __inline int32 sad_4pixel(int32 src1, int32 src2, int32 mask)
+    {
+        int32 x7;
+
+        x7 = src2 ^ src1;       /* check odd/even combination */
+        if ((uint32)src2 >= (uint32)src1)
+        {
+            src1 = src2 - src1;     /* subs */
+        }
+        else
+        {
+            src1 = src1 - src2;
+        }
+        x7 = x7 ^ src1;     /* only odd bytes need to add carry */
+        x7 = mask & ((uint32)x7 >> 1);
+        x7 = (x7 << 8) - x7;
+        src1 = src1 + (x7 >> 7); /* add 0xFF to the negative byte, add back carry */
+        src1 = src1 ^(x7 >> 7);   /* take absolute value of negative byte */
+
+        return src1;
+    }
+
+#define NUMBER 3
+#define SHIFT 24
+
+#include "sad_mb_offset.h"
+
+#undef NUMBER
+#define NUMBER 2
+#undef SHIFT
+#define SHIFT 16
+#include "sad_mb_offset.h"
+
+#undef NUMBER
+#define NUMBER 1
+#undef SHIFT
+#define SHIFT 8
+#include "sad_mb_offset.h"
+
+
+    __inline int32 simd_sad_mb(UChar *ref, UChar *blk, Int dmin, Int lx)
+    {
+        int32 x4, x5, x6, x8, x9, x10, x11, x12, x14;
+
+        x9 = 0x80808080; /* const. */
+
+        x8 = (uint32)ref & 0x3;
+        if (x8 == 3)
+            goto SadMBOffset3;
+        if (x8 == 2)
+            goto SadMBOffset2;
+        if (x8 == 1)
+            goto SadMBOffset1;
+
+//  x5 = (x4<<8)-x4; /* x5 = x4*255; */
+        x4 = x5 = 0;
+
+        x6 = 0xFFFF00FF;
+
+        ref -= lx;
+        blk -= 16;
+
+        x8 = 16;
+
+LOOP_SAD0:
+        /****** process 8 pixels ******/
+        x10 = *((uint32*)(ref += lx));
+        x11 = *((uint32*)(ref + 4));
+        x12 = *((uint32*)(blk += 16));
+        x14 = *((uint32*)(blk + 4));
+
+        /* process x11 & x14 */
+        x11 = sad_4pixel(x11, x14, x9);
+
+        /* process x12 & x10 */
+        x10 = sad_4pixel(x10, x12, x9);
+
+        x5 = x5 + x10; /* accumulate low bytes */
+        x10 = x10 & (x6 << 8); /* x10 & 0xFF00FF00 */
+        x4 = x4 + ((uint32)x10 >> 8);  /* accumulate high bytes */
+        x5 = x5 + x11;  /* accumulate low bytes */
+        x11 = x11 & (x6 << 8); /* x11 & 0xFF00FF00 */
+        x4 = x4 + ((uint32)x11 >> 8);  /* accumulate high bytes */
+
+        /****** process 8 pixels ******/
+        x10 = *((uint32*)(ref + 8));
+        x11 = *((uint32*)(ref + 12));
+        x12 = *((uint32*)(blk + 8));
+        x14 = *((uint32*)(blk + 12));
+
+        /* process x11 & x14 */
+        x11 = sad_4pixel(x11, x14, x9);
+
+        /* process x12 & x10 */
+        x10 = sad_4pixel(x10, x12, x9);
+
+        x5 = x5 + x10;  /* accumulate low bytes */
+        x10 = x10 & (x6 << 8); /* x10 & 0xFF00FF00 */
+        x4 = x4 + ((uint32)x10 >> 8); /* accumulate high bytes */
+        x5 = x5 + x11;  /* accumulate low bytes */
+        x11 = x11 & (x6 << 8); /* x11 & 0xFF00FF00 */
+        x4 = x4 + ((uint32)x11 >> 8);  /* accumulate high bytes */
+
+        /****************/
+        x10 = x5 - (x4 << 8); /* extract low bytes */
+        x10 = x10 + x4;     /* add with high bytes */
+        x10 = x10 + (x10 << 16); /* add with lower half word */
+
+        if (((uint32)x10 >> 16) <= (uint32)dmin) /* compare with dmin */
+        {
+            if (--x8)
+            {
+                goto LOOP_SAD0;
+            }
+
+        }
+
+        return ((uint32)x10 >> 16);
+
+SadMBOffset3:
+
+        return sad_mb_offset3(ref, blk, lx, dmin);
+
+SadMBOffset2:
+
+        return sad_mb_offset2(ref, blk, lx, dmin);
+
+SadMBOffset1:
+
+        return sad_mb_offset1(ref, blk, lx, dmin);
+
+    }
+
+#elif defined(__CC_ARM)  /* only work with arm v5 */
+
+    __inline int32 SUB_SAD(int32 sad, int32 tmp, int32 tmp2)
+    {
+        __asm
+        {
+            rsbs    tmp, tmp, tmp2 ;
+            rsbmi   tmp, tmp, #0 ;
+            add     sad, sad, tmp ;
+        }
+
+        return sad;
+    }
+
+    __inline int32 sad_4pixel(int32 src1, int32 src2, int32 mask)
+    {
+        int32 x7;
+
+        __asm
+        {
+            EOR     x7, src2, src1;     /* check odd/even combination */
+            SUBS    src1, src2, src1;
+            EOR     x7, x7, src1;
+            AND     x7, mask, x7, lsr #1;
+            ORRCC   x7, x7, #0x80000000;
+            RSB     x7, x7, x7, lsl #8;
+            ADD     src1, src1, x7, asr #7;   /* add 0xFF to the negative byte, add back carry */
+            EOR     src1, src1, x7, asr #7;   /* take absolute value of negative byte */
+        }
+
+        return src1;
+    }
+
+    __inline int32 sad_4pixelN(int32 src1, int32 src2, int32 mask)
+    {
+        int32 x7;
+
+        __asm
+        {
+            EOR      x7, src2, src1;        /* check odd/even combination */
+            ADDS     src1, src2, src1;
+            EOR      x7, x7, src1;      /* only odd bytes need to add carry */
+            ANDS     x7, mask, x7, rrx;
+            RSB      x7, x7, x7, lsl #8;
+            SUB      src1, src1, x7, asr #7;  /* add 0xFF to the negative byte, add back carry */
+            EOR      src1, src1, x7, asr #7; /* take absolute value of negative byte */
+        }
+
+        return src1;
+    }
+
+#define sum_accumulate  __asm{      SBC      x5, x5, x10;  /* accumulate low bytes */ \
+        BIC      x10, x6, x10;   /* x10 & 0xFF00FF00 */ \
+        ADD      x4, x4, x10,lsr #8;   /* accumulate high bytes */ \
+        SBC      x5, x5, x11;    /* accumulate low bytes */ \
+        BIC      x11, x6, x11;   /* x11 & 0xFF00FF00 */ \
+        ADD      x4, x4, x11,lsr #8; } /* accumulate high bytes */
+
+
+#define NUMBER 3
+#define SHIFT 24
+#define INC_X8 0x08000001
+
+#include "sad_mb_offset.h"
+
+#undef NUMBER
+#define NUMBER 2
+#undef SHIFT
+#define SHIFT 16
+#undef INC_X8
+#define INC_X8 0x10000001
+#include "sad_mb_offset.h"
+
+#undef NUMBER
+#define NUMBER 1
+#undef SHIFT
+#define SHIFT 8
+#undef INC_X8
+#define INC_X8 0x08000001
+#include "sad_mb_offset.h"
+
+
+    __inline int32 simd_sad_mb(UChar *ref, UChar *blk, Int dmin, Int lx)
+    {
+        int32 x4, x5, x6, x8, x9, x10, x11, x12, x14;
+
+        x9 = 0x80808080; /* const. */
+        x4 = x5 = 0;
+
+        __asm
+        {
+            MOVS    x8, ref, lsl #31 ;
+            BHI     SadMBOffset3;
+            BCS     SadMBOffset2;
+            BMI     SadMBOffset1;
+
+            MVN     x6, #0xFF00;
+        }
+LOOP_SAD0:
+        /****** process 8 pixels ******/
+        x11 = *((int32*)(ref + 12));
+        x10 = *((int32*)(ref + 8));
+        x14 = *((int32*)(blk + 12));
+        x12 = *((int32*)(blk + 8));
+
+        /* process x11 & x14 */
+        x11 = sad_4pixel(x11, x14, x9);
+
+        /* process x12 & x10 */
+        x10 = sad_4pixel(x10, x12, x9);
+
+        x5 = x5 + x10;  /* accumulate low bytes */
+        x10 = x10 & (x6 << 8); /* x10 & 0xFF00FF00 */
+        x4 = x4 + ((uint32)x10 >> 8); /* accumulate high bytes */
+        x5 = x5 + x11;  /* accumulate low bytes */
+        x11 = x11 & (x6 << 8); /* x11 & 0xFF00FF00 */
+        x4 = x4 + ((uint32)x11 >> 8);  /* accumulate high bytes */
+
+        __asm
+        {
+            /****** process 8 pixels ******/
+            LDR     x11, [ref, #4];
+            LDR     x10, [ref], lx ;
+            LDR     x14, [blk, #4];
+            LDR     x12, [blk], #16 ;
+        }
+
+        /* process x11 & x14 */
+        x11 = sad_4pixel(x11, x14, x9);
+
+        /* process x12 & x10 */
+        x10 = sad_4pixel(x10, x12, x9);
+
+        x5 = x5 + x10;  /* accumulate low bytes */
+        x10 = x10 & (x6 << 8); /* x10 & 0xFF00FF00 */
+        x4 = x4 + ((uint32)x10 >> 8); /* accumulate high bytes */
+        x5 = x5 + x11;  /* accumulate low bytes */
+        x11 = x11 & (x6 << 8); /* x11 & 0xFF00FF00 */
+        x4 = x4 + ((uint32)x11 >> 8);  /* accumulate high bytes */
+
+        /****************/
+        x10 = x5 - (x4 << 8); /* extract low bytes */
+        x10 = x10 + x4;     /* add with high bytes */
+        x10 = x10 + (x10 << 16); /* add with lower half word */
+
+        __asm
+        {
+            /****************/
+            RSBS    x11, dmin, x10, lsr #16;
+            ADDLSS  x8, x8, #0x10000001;
+            BLS     LOOP_SAD0;
+        }
+
+        return ((uint32)x10 >> 16);
+
+SadMBOffset3:
+
+        return sad_mb_offset3(ref, blk, lx, dmin, x8);
+
+SadMBOffset2:
+
+        return sad_mb_offset2(ref, blk, lx, dmin, x8);
+
+SadMBOffset1:
+
+        return sad_mb_offset1(ref, blk, lx, dmin, x8);
+    }
+
+
+#elif ( defined(PV_ARM_GCC_V5) || defined(PV_ARM_GCC_V4) ) /* ARM GNU COMPILER  */
+
+    __inline int32 SUB_SAD(int32 sad, int32 tmp, int32 tmp2)
+    {
+        register int32 out;
+        register int32 temp1;
+        register int32 ss = sad;
+        register int32 tt = tmp;
+        register int32 uu = tmp2;
+
+        asm volatile("rsbs  %1, %4, %3\n\t"
+                     "rsbmi %1, %1, #0\n\t"
+                     "add   %0, %2, %1"
+             : "=&r"(out),
+                     "=&r"(temp1)
+                             : "r"(ss),
+                             "r"(tt),
+                             "r"(uu));
+        return out;
+    }
+
+    __inline int32 sad_4pixel(int32 src1, int32 src2, int32 mask)
+{
+        register int32 out;
+        register int32 temp1;
+        register int32 s1 = src1;
+        register int32 s2 = src2;
+        register int32 mm = mask;
+
+        asm volatile("eor   %0, %3, %2\n\t"
+                     "subs  %1, %3, %2\n\t"
+                     "eor   %0, %0, %1\n\t"
+                     "and   %0, %4, %0, lsr #1\n\t"
+                     "orrcc %0, %0, #0x80000000\n\t"
+                     "rsb   %0, %0, %0, lsl #8\n\t"
+                     "add   %1, %1, %0, asr #7\n\t"
+                     "eor   %1, %1, %0, asr #7"
+             : "=&r"(out),
+                     "=&r"(temp1)
+                             : "r"(s1),
+                             "r"(s2),
+                             "r"(mm));
+
+        return temp1;
+    }
+
+    __inline int32 sad_4pixelN(int32 src1, int32 src2, int32 mask)
+{
+        register int32 out;
+        register int32 temp1;
+        register int32 s1 = src1;
+        register int32 s2 = src2;
+        register int32 mm = mask;
+
+        asm volatile("eor    %1, %3, %2\n\t"
+                     "adds   %0, %3, %2\n\t"
+                     "eor    %1, %1, %0\n\t"
+                     "ands   %1, %4, %1,rrx\n\t"
+                     "rsb    %1, %1, %1, lsl #8\n\t"
+                     "sub    %0, %0, %1, asr #7\n\t"
+                     "eor    %0, %0, %1, asr #7"
+             : "=&r"(out),
+                     "=&r"(temp1)
+                             : "r"(s1),
+                             "r"(s2),
+                             "r"(mm));
+
+        return (out);
+    }
+
+#define sum_accumulate asm volatile("sbc  %0, %0, %1\n\t" \
+                                "bic  %1, %4, %1\n\t" \
+                                "add  %2, %2, %1, lsr #8\n\t" \
+                                "sbc  %0, %0, %3\n\t" \
+                                "bic  %3, %4, %3\n\t" \
+                                "add  %2, %2, %3, lsr #8" \
+                                :"+r"(x5), "+r"(x10), "+r"(x4), "+r"(x11) \
+                                :"r"(x6));
+
+#define NUMBER 3
+#define SHIFT 24
+#define INC_X8 0x08000001
+
+#include "sad_mb_offset.h"
+
+#undef NUMBER
+#define NUMBER 2
+#undef SHIFT
+#define SHIFT 16
+#undef INC_X8
+#define INC_X8 0x10000001
+#include "sad_mb_offset.h"
+
+#undef NUMBER
+#define NUMBER 1
+#undef SHIFT
+#define SHIFT 8
+#undef INC_X8
+#define INC_X8 0x08000001
+#include "sad_mb_offset.h"
+
+
+    __inline int32 simd_sad_mb(UChar *ref, UChar *blk, Int dmin, Int lx)
+{
+        int32 x4, x5, x6, x8, x9, x10, x11, x12, x14;
+
+        x9 = 0x80808080; /* const. */
+        x4 = x5 = 0;
+
+        x8 = (uint32)ref & 0x3;
+        if (x8 == 3)
+            goto SadMBOffset3;
+        if (x8 == 2)
+            goto SadMBOffset2;
+        if (x8 == 1)
+            goto SadMBOffset1;
+
+asm volatile("mvn %0, #0xFF00": "=r"(x6));
+
+LOOP_SAD0:
+        /****** process 8 pixels ******/
+        x11 = *((int32*)(ref + 12));
+        x10 = *((int32*)(ref + 8));
+        x14 = *((int32*)(blk + 12));
+        x12 = *((int32*)(blk + 8));
+
+        /* process x11 & x14 */
+        x11 = sad_4pixel(x11, x14, x9);
+
+        /* process x12 & x10 */
+        x10 = sad_4pixel(x10, x12, x9);
+
+        x5 = x5 + x10;  /* accumulate low bytes */
+        x10 = x10 & (x6 << 8); /* x10 & 0xFF00FF00 */
+        x4 = x4 + ((uint32)x10 >> 8); /* accumulate high bytes */
+        x5 = x5 + x11;  /* accumulate low bytes */
+        x11 = x11 & (x6 << 8); /* x11 & 0xFF00FF00 */
+        x4 = x4 + ((uint32)x11 >> 8);  /* accumulate high bytes */
+
+        asm volatile("ldr  %0, [%4, #4]\n\t"
+                     "ldr  %1, [%4], %6\n\t"
+                     "ldr  %2, [%5, #4]\n\t"
+                     "ldr  %3, [%5], #16"
+             : "=r"(x11), "=r"(x10), "=r"(x14), "=r"(x12), "+r"(ref), "+r"(blk)
+                             : "r"(lx));
+
+        /* process x11 & x14 */
+        x11 = sad_4pixel(x11, x14, x9);
+
+        /* process x12 & x10 */
+        x10 = sad_4pixel(x10, x12, x9);
+
+        x5 = x5 + x10;  /* accumulate low bytes */
+        x10 = x10 & (x6 << 8); /* x10 & 0xFF00FF00 */
+        x4 = x4 + ((uint32)x10 >> 8); /* accumulate high bytes */
+        x5 = x5 + x11;  /* accumulate low bytes */
+        x11 = x11 & (x6 << 8); /* x11 & 0xFF00FF00 */
+        x4 = x4 + ((uint32)x11 >> 8);  /* accumulate high bytes */
+
+        /****************/
+        x10 = x5 - (x4 << 8); /* extract low bytes */
+        x10 = x10 + x4;     /* add with high bytes */
+        x10 = x10 + (x10 << 16); /* add with lower half word */
+
+        if (((uint32)x10 >> 16) <= (uint32)dmin) /* compare with dmin */
+        {
+            if (--x8)
+            {
+                goto LOOP_SAD0;
+            }
+
+        }
+
+        return ((uint32)x10 >> 16);
+
+SadMBOffset3:
+
+        return sad_mb_offset3(ref, blk, lx, dmin);
+
+SadMBOffset2:
+
+        return sad_mb_offset2(ref, blk, lx, dmin);
+
+SadMBOffset1:
+
+        return sad_mb_offset1(ref, blk, lx, dmin);
+    }
+
+#endif // OS
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _SAD_INLINE_H_
+
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/sad_mb_offset.h b/media/libstagefright/codecs/m4v_h263/enc/src/sad_mb_offset.h
new file mode 100644
index 0000000..4c7b929
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/sad_mb_offset.h
@@ -0,0 +1,317 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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.
+ * -------------------------------------------------------------------
+ */
+/*********************************************************************************/
+/*  Filename: sad_mb_offset.h                                                       */
+/*  Description: Implementation for in-line functions used in dct.cpp           */
+/*  Modified:                                                                   */
+/*********************************************************************************/
+
+#if !defined(PV_ARM_GCC_V4) && !defined(PV_ARM_GCC_V5) /* ARM GNU COMPILER  */
+
+#if (NUMBER==3)
+__inline int32 sad_mb_offset3(UChar *ref, UChar *blk, Int lx, Int dmin)
+#elif (NUMBER==2)
+__inline int32 sad_mb_offset2(UChar *ref, UChar *blk, Int lx, Int dmin)
+#elif (NUMBER==1)
+__inline int32 sad_mb_offset1(UChar *ref, UChar *blk, Int lx, Int dmin)
+#endif
+{
+    int32 x4, x5, x6, x8, x9, x10, x11, x12, x14;
+
+    //  x5 = (x4<<8) - x4;
+    x4 = x5 = 0;
+    x6 = 0xFFFF00FF;
+    x9 = 0x80808080; /* const. */
+    ref -= NUMBER; /* bic ref, ref, #3 */
+    ref -= lx;
+    blk -= 16;
+    x8 = 16;
+
+#if (NUMBER==3)
+LOOP_SAD3:
+#elif (NUMBER==2)
+LOOP_SAD2:
+#elif (NUMBER==1)
+LOOP_SAD1:
+#endif
+    /****** process 8 pixels ******/
+    x10 = *((uint32*)(ref += lx)); /* D C B A */
+    x11 = *((uint32*)(ref + 4));    /* H G F E */
+    x12 = *((uint32*)(ref + 8));    /* L K J I */
+
+    x10 = ((uint32)x10 >> SHIFT); /* 0 0 0 D */
+    x10 = x10 | (x11 << (32 - SHIFT));        /* G F E D */
+    x11 = ((uint32)x11 >> SHIFT); /* 0 0 0 H */
+    x11 = x11 | (x12 << (32 - SHIFT));        /* K J I H */
+
+    x12 = *((uint32*)(blk += 16));
+    x14 = *((uint32*)(blk + 4));
+
+    /* process x11 & x14 */
+    x11 = sad_4pixel(x11, x14, x9);
+
+    /* process x12 & x10 */
+    x10 = sad_4pixel(x10, x12, x9);
+
+    x5 = x5 + x10; /* accumulate low bytes */
+    x10 = x10 & (x6 << 8); /* x10 & 0xFF00FF00 */
+    x4 = x4 + ((uint32)x10 >> 8);  /* accumulate high bytes */
+    x5 = x5 + x11;  /* accumulate low bytes */
+    x11 = x11 & (x6 << 8); /* x11 & 0xFF00FF00 */
+    x4 = x4 + ((uint32)x11 >> 8);  /* accumulate high bytes */
+
+    /****** process 8 pixels ******/
+    x10 = *((uint32*)(ref + 8)); /* D C B A */
+    x11 = *((uint32*)(ref + 12));   /* H G F E */
+    x12 = *((uint32*)(ref + 16));   /* L K J I */
+
+    x10 = ((uint32)x10 >> SHIFT); /* mvn x10, x10, lsr #24  = 0xFF 0xFF 0xFF ~D */
+    x10 = x10 | (x11 << (32 - SHIFT));        /* bic x10, x10, x11, lsl #8 = ~G ~F ~E ~D */
+    x11 = ((uint32)x11 >> SHIFT); /* 0xFF 0xFF 0xFF ~H */
+    x11 = x11 | (x12 << (32 - SHIFT));        /* ~K ~J ~I ~H */
+
+    x12 = *((uint32*)(blk + 8));
+    x14 = *((uint32*)(blk + 12));
+
+    /* process x11 & x14 */
+    x11 = sad_4pixel(x11, x14, x9);
+
+    /* process x12 & x10 */
+    x10 = sad_4pixel(x10, x12, x9);
+
+    x5 = x5 + x10; /* accumulate low bytes */
+    x10 = x10 & (x6 << 8); /* x10 & 0xFF00FF00 */
+    x4 = x4 + ((uint32)x10 >> 8);  /* accumulate high bytes */
+    x5 = x5 + x11;  /* accumulate low bytes */
+    x11 = x11 & (x6 << 8); /* x11 & 0xFF00FF00 */
+    x4 = x4 + ((uint32)x11 >> 8);  /* accumulate high bytes */
+
+    /****************/
+    x10 = x5 - (x4 << 8); /* extract low bytes */
+    x10 = x10 + x4;     /* add with high bytes */
+    x10 = x10 + (x10 << 16); /* add with lower half word */
+
+    if (((uint32)x10 >> 16) <= (uint32)dmin) /* compare with dmin */
+    {
+        if (--x8)
+        {
+#if (NUMBER==3)
+            goto         LOOP_SAD3;
+#elif (NUMBER==2)
+            goto         LOOP_SAD2;
+#elif (NUMBER==1)
+            goto         LOOP_SAD1;
+#endif
+        }
+
+    }
+
+    return ((uint32)x10 >> 16);
+}
+
+#elif defined(__CC_ARM)  /* only work with arm v5 */
+
+#if (NUMBER==3)
+__inline int32 sad_mb_offset3(UChar *ref, UChar *blk, Int lx, Int dmin, int32 x8)
+#elif (NUMBER==2)
+__inline int32 sad_mb_offset2(UChar *ref, UChar *blk, Int lx, Int dmin, int32 x8)
+#elif (NUMBER==1)
+__inline int32 sad_mb_offset1(UChar *ref, UChar *blk, Int lx, Int dmin, int32 x8)
+#endif
+{
+    int32 x4, x5, x6, x9, x10, x11, x12, x14;
+
+    x9 = 0x80808080; /* const. */
+    x4 = x5 = 0;
+
+    __asm{
+        MVN      x6, #0xff0000;
+        BIC      ref, ref, #3;
+
+#if (NUMBER==3)
+LOOP_SAD3:
+#elif (NUMBER==2)
+LOOP_SAD2:
+#elif (NUMBER==1)
+LOOP_SAD1:
+#endif
+    }
+    /****** process 8 pixels ******/
+    x11 = *((int32*)(ref + 12));
+    x12 = *((int32*)(ref + 16));
+    x10 = *((int32*)(ref + 8));
+    x14 = *((int32*)(blk + 12));
+
+    __asm{
+        MVN      x10, x10, lsr #SHIFT;
+        BIC      x10, x10, x11, lsl #(32-SHIFT);
+        MVN      x11, x11, lsr #SHIFT;
+        BIC      x11, x11, x12, lsl #(32-SHIFT);
+
+        LDR      x12, [blk, #8];
+    }
+
+    /* process x11 & x14 */
+    x11 = sad_4pixelN(x11, x14, x9);
+
+    /* process x12 & x10 */
+    x10 = sad_4pixelN(x10, x12, x9);
+
+    sum_accumulate;
+
+    __asm{
+        /****** process 8 pixels ******/
+        LDR      x11, [ref, #4];
+        LDR      x12, [ref, #8];
+        LDR  x10, [ref], lx ;
+        LDR  x14, [blk, #4];
+
+        MVN      x10, x10, lsr #SHIFT;
+        BIC      x10, x10, x11, lsl #(32-SHIFT);
+        MVN      x11, x11, lsr #SHIFT;
+        BIC      x11, x11, x12, lsl #(32-SHIFT);
+
+        LDR      x12, [blk], #16;
+    }
+
+    /* process x11 & x14 */
+    x11 = sad_4pixelN(x11, x14, x9);
+
+    /* process x12 & x10 */
+    x10 = sad_4pixelN(x10, x12, x9);
+
+    sum_accumulate;
+
+    /****************/
+    x10 = x5 - (x4 << 8); /* extract low bytes */
+    x10 = x10 + x4;     /* add with high bytes */
+    x10 = x10 + (x10 << 16); /* add with lower half word */
+
+    __asm{
+        RSBS     x11, dmin, x10, lsr #16
+        ADDLSS   x8, x8, #INC_X8
+#if (NUMBER==3)
+        BLS      LOOP_SAD3;
+#elif (NUMBER==2)
+BLS      LOOP_SAD2;
+#elif (NUMBER==1)
+BLS      LOOP_SAD1;
+#endif
+    }
+
+    return ((uint32)x10 >> 16);
+}
+
+#elif ( defined(PV_ARM_GCC_V5) || defined(PV_ARM_GCC_V4) ) /* ARM GNU COMPILER  */
+
+#if (NUMBER==3)
+__inline int32 sad_mb_offset3(UChar *ref, UChar *blk, Int lx, Int dmin)
+#elif (NUMBER==2)
+__inline int32 sad_mb_offset2(UChar *ref, UChar *blk, Int lx, Int dmin)
+#elif (NUMBER==1)
+__inline int32 sad_mb_offset1(UChar *ref, UChar *blk, Int lx, Int dmin)
+#endif
+{
+    int32 x4, x5, x6, x8, x9, x10, x11, x12, x14;
+
+    //  x5 = (x4<<8) - x4;
+    x4 = x5 = 0;
+    x6 = 0xFFFF00FF;
+    x9 = 0x80808080; /* const. */
+    ref -= NUMBER; /* bic ref, ref, #3 */
+    ref -= lx;
+    x8 = 16;
+
+#if (NUMBER==3)
+LOOP_SAD3:
+#elif (NUMBER==2)
+LOOP_SAD2:
+#elif (NUMBER==1)
+LOOP_SAD1:
+#endif
+    /****** process 8 pixels ******/
+    x10 = *((uint32*)(ref += lx)); /* D C B A */
+    x11 = *((uint32*)(ref + 4));    /* H G F E */
+    x12 = *((uint32*)(ref + 8));    /* L K J I */
+
+    int32 shift = SHIFT;
+    int32 shift2 = 32 - SHIFT;
+    asm volatile("ldr  %3, [%4, #4]\n\t"
+                 "mvn  %0, %0, lsr %5\n\t"
+                 "bic  %0, %0, %1, lsl %6\n\t"
+                 "mvn  %1, %1, lsr %5\n\t"
+                 "bic  %1, %1, %2, lsl %6\n\t"
+                 "ldr  %2, [%4, #8]"
+             : "+r"(x10), "+r"(x11), "+r"(x12), "=r"(x14)
+                         : "r"(blk), "r"(shift), "r"(shift2));
+
+    /* process x11 & x14 */
+    x11 = sad_4pixel(x11, x14, x9);
+
+    /* process x12 & x10 */
+    x10 = sad_4pixel(x10, x12, x9);
+
+    sum_accumulate;
+
+    /****** process 8 pixels ******/
+    x10 = *((uint32*)(ref + 8)); /* D C B A */
+    x11 = *((uint32*)(ref + 12));   /* H G F E */
+    x12 = *((uint32*)(ref + 16));   /* L K J I */
+
+    asm volatile("ldr  %3, [%4, #4]\n\t"
+                 "mvn  %0, %0, lsr %5\n\t"
+                 "bic  %0, %0, %1, lsl %6\n\t"
+                 "mvn  %1, %1, lsr %5\n\t"
+                 "bic  %1, %1, %2, lsl %6\n\t"
+                 "ldr  %2, [%4, #8]"
+             : "+r"(x10), "+r"(x11), "+r"(x12), "=r"(x14)
+                         : "r"(blk), "r"(shift), "r"(shift2));
+
+    /* process x11 & x14 */
+    x11 = sad_4pixel(x11, x14, x9);
+
+    /* process x12 & x10 */
+    x10 = sad_4pixel(x10, x12, x9);
+
+    sum_accumulate;
+
+    /****************/
+    x10 = x5 - (x4 << 8); /* extract low bytes */
+    x10 = x10 + x4;     /* add with high bytes */
+    x10 = x10 + (x10 << 16); /* add with lower half word */
+
+    if (((uint32)x10 >> 16) <= (uint32)dmin) /* compare with dmin */
+    {
+        if (--x8)
+        {
+#if (NUMBER==3)
+            goto         LOOP_SAD3;
+#elif (NUMBER==2)
+goto         LOOP_SAD2;
+#elif (NUMBER==1)
+goto         LOOP_SAD1;
+#endif
+        }
+
+    }
+
+    return ((uint32)x10 >> 16);
+}
+
+#endif
+
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/vlc_enc_tab.h b/media/libstagefright/codecs/m4v_h263/enc/src/vlc_enc_tab.h
new file mode 100644
index 0000000..79d62e4
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/vlc_enc_tab.h
@@ -0,0 +1,1146 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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.
+ * -------------------------------------------------------------------
+ */
+/******************************************************************************
+ *
+ * This software module was originally developed by
+ *
+ * Robert Danielsen (Telenor / ACTS-MoMuSys).
+ *
+ * and edited by
+ *
+ * Minhua Zhou (HHI / ACTS-MoMuSys).
+ * Luis Ducla-Soares (IST / ACTS-MoMuSys).
+ *
+ * in the course of development of the MPEG-4 Video (ISO/IEC 14496-2) standard.
+ * This software module is an implementation of a part of one or more MPEG-4
+ * Video (ISO/IEC 14496-2) tools as specified by the MPEG-4 Video (ISO/IEC
+ * 14496-2) standard.
+ *
+ * ISO/IEC gives users of the MPEG-4 Video (ISO/IEC 14496-2) standard free
+ * license to this software module or modifications thereof for use in hardware
+ * or software products claiming conformance to the MPEG-4 Video (ISO/IEC
+ * 14496-2) standard.
+ *
+ * Those intending to use this software module in hardware or software products
+ * are advised that its use may infringe existing patents. The original
+ * developer of this software module and his/her company, the subsequent
+ * editors and their companies, and ISO/IEC have no liability for use of this
+ * software module or modifications thereof in an implementation. Copyright is
+ * not released for non MPEG-4 Video (ISO/IEC 14496-2) standard conforming
+ * products.
+ *
+ * ACTS-MoMuSys partners retain full right to use the code for his/her own
+ * purpose, assign or donate the code to a third party and to inhibit third
+ * parties from using the code for non MPEG-4 Video (ISO/IEC 14496-2) standard
+ * conforming products. This copyright notice must be included in all copies or
+ * derivative works.
+ *
+ * Copyright (c) 1997
+ *
+ *****************************************************************************/
+
+
+/***********************************************************HeaderBegin*******
+ *
+ * File:    vlc.h
+ *
+ * Author:  Robert Danielsen
+ * Created: 07.06.96
+ *
+ * Description: vlc tables for encoder
+ *
+ * Notes:   Idea taken from MPEG-2 software simulation group
+ *
+ * Modified:
+ *  28.10.96 Robert Danielsen: Added tables for Intra luminance
+ *          coefficients
+ *      01.05.97 Luis Ducla-Soares: added VM7.0 Reversible VLC tables (RVLC).
+ *      13.05.97 Minhua Zhou: added cbpy_tab3,cbpy_tab2
+ *
+ ***********************************************************HeaderEnd*********/
+
+/************************    INCLUDE FILES    ********************************/
+
+#ifndef _VLC_ENC_TAB_H_
+#define _VLC_ENC_TAB_H_
+
+
+#include "mp4def.h"
+/* type definitions for variable length code table entries */
+
+
+
+static const Int intra_max_level[2][64] =
+{
+    {27, 10,  5,  4,  3,  3,  3,  3,
+        2,  2,  1,  1,  1,  1,  1,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,
+    },
+
+    {8,  3,  2,  2,  2,  2,  2,  1,
+     1,  1,  1,  1,  1,  1,  1,  1,
+     1,  1,  1,  1,  1,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0
+    }
+};
+
+
+static const Int inter_max_level[2][64] =
+{
+    {12,  6,  4,  3,  3,  3,  3,  2,
+        2,  2,  2,  1,  1,  1,  1,  1,
+        1,  1,  1,  1,  1,  1,  1,  1,
+        1,  1,  1,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0},
+
+    {3,  2,  1,  1,  1,  1,  1,  1,
+     1,  1,  1,  1,  1,  1,  1,  1,
+     1,  1,  1,  1,  1,  1,  1,  1,
+     1,  1,  1,  1,  1,  1,  1,  1,
+     1,  1,  1,  1,  1,  1,  1,  1,
+     1,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0}
+};
+
+
+static const Int intra_max_run0[28] = { 999, 14,  9,  7,  3,  2,  1,
+                                        1,  1,  1,  1,  0,  0,  0,
+                                        0,  0,  0,  0,  0,  0,  0,
+                                        0,  0,  0,  0,  0,  0,  0
+                                      };
+
+
+static const Int intra_max_run1[9] = { 999, 20,  6,
+                                       1,  0,  0,
+                                       0,  0,  0
+                                     };
+
+static const Int inter_max_run0[13] = { 999,
+                                        26, 10,  6,  2,  1,  1,
+                                        0,  0,  0,  0,  0,  0
+                                      };
+
+
+static const Int inter_max_run1[4] = { 999, 40,  1,  0 };
+
+
+
+/* DC prediction sizes */
+
+static const VLCtable DCtab_lum[13] =
+{
+    {3, 3}, {3, 2}, {2, 2}, {2, 3}, {1, 3}, {1, 4}, {1, 5}, {1, 6}, {1, 7},
+    {1, 8}, {1, 9}, {1, 10}, {1, 11}
+};
+
+static const VLCtable DCtab_chrom[13] =
+{
+    {3, 2}, {2, 2}, {1, 2}, {1, 3}, {1, 4}, {1, 5}, {1, 6}, {1, 7}, {1, 8},
+    {1, 9}, {1, 10}, {1, 11}, {1, 12}
+};
+
+/* Motion vectors */
+
+static const VLCtable mvtab[33] =
+{
+    {1, 1}, {1, 2}, {1, 3}, {1, 4}, {3, 6}, {5, 7}, {4, 7}, {3, 7},
+    {11, 9}, {10, 9}, {9, 9}, {17, 10}, {16, 10}, {15, 10}, {14, 10}, {13, 10},
+    {12, 10}, {11, 10}, {10, 10}, {9, 10}, {8, 10}, {7, 10}, {6, 10}, {5, 10},
+    {4, 10}, {7, 11}, {6, 11}, {5, 11}, {4, 11}, {3, 11}, {2, 11}, {3, 12},
+    {2, 12}
+};
+
+
+/* MCBPC Indexing by cbpc in first two bits, mode in last two.
+ CBPC as in table 4/H.263, MB type (mode): 3 = 01, 4 = 10.
+ Example: cbpc = 01 and mode = 4 gives index = 0110 = 6. */
+
+static const VLCtable mcbpc_intra_tab[15] =
+{
+    {0x01, 9}, {0x01, 1}, {0x01, 4}, {0x00, 0},
+    {0x00, 0}, {0x01, 3}, {0x01, 6}, {0x00, 0},
+    {0x00, 0}, {0x02, 3}, {0x02, 6}, {0x00, 0},
+    {0x00, 0}, {0x03, 3}, {0x03, 6}
+};
+
+
+/* MCBPC inter.
+   Addressing: 5 bit ccmmm (cc = CBPC, mmm = mode (1-4 binary)) */
+
+static const VLCtable mcbpc_inter_tab[29] =
+{
+    {1, 1}, {3, 3}, {2, 3}, {3, 5}, {4, 6}, {1, 9}, {0, 0}, {0, 0},
+    {3, 4}, {7, 7}, {5, 7}, {4, 8}, {4, 9}, {0, 0}, {0, 0}, {0, 0},
+    {2, 4}, {6, 7}, {4, 7}, {3, 8}, {3, 9}, {0, 0}, {0, 0}, {0, 0},
+    {5, 6}, {5, 9}, {5, 8}, {3, 7}, {2, 9}
+};
+
+
+
+/* CBPY. Straightforward indexing */
+
+static const VLCtable cbpy_tab[16] =
+{
+    {3, 4}, {5, 5}, {4, 5}, {9, 4}, {3, 5}, {7, 4}, {2, 6}, {11, 4},
+    {2, 5}, {3, 6}, {5, 4}, {10, 4}, {4, 4}, {8, 4}, {6, 4}, {3, 2}
+};
+
+static const VLCtable cbpy_tab3[8] =
+{
+    {3, 3}, {1, 6}, {1, 5}, {2, 3}, {2, 5}, {3, 5}, {1, 3}, {1, 1}
+};
+static const VLCtable cbpy_tab2[4] =
+{
+    {1, 4}, {1, 3}, {1, 2}, {1, 1}
+};
+
+/* DCT coefficients. Four tables, two for last = 0, two for last = 1.
+   the sign bit must be added afterwards. */
+
+/* first part of coeffs for last = 0. Indexed by [run][level-1] */
+
+static const VLCtable coeff_tab0[2][12] =
+{
+    /* run = 0 */
+    {
+        {0x02, 2}, {0x0f, 4}, {0x15, 6}, {0x17, 7},
+        {0x1f, 8}, {0x25, 9}, {0x24, 9}, {0x21, 10},
+        {0x20, 10}, {0x07, 11}, {0x06, 11}, {0x20, 11}
+    },
+    /* run = 1 */
+    {
+        {0x06, 3}, {0x14, 6}, {0x1e, 8}, {0x0f, 10},
+        {0x21, 11}, {0x50, 12}, {0x00, 0}, {0x00, 0},
+        {0x00, 0}, {0x00, 0}, {0x00, 0}, {0x00, 0}
+    }
+};
+
+/* rest of coeffs for last = 0. indexing by [run-2][level-1] */
+
+static const VLCtable coeff_tab1[25][4] =
+{
+    /* run = 2 */
+    {
+        {0x0e, 4}, {0x1d, 8}, {0x0e, 10}, {0x51, 12}
+    },
+    /* run = 3 */
+    {
+        {0x0d, 5}, {0x23, 9}, {0x0d, 10}, {0x00, 0}
+    },
+    /* run = 4-26 */
+    {
+        {0x0c, 5}, {0x22, 9}, {0x52, 12}, {0x00, 0}
+    },
+    {
+        {0x0b, 5}, {0x0c, 10}, {0x53, 12}, {0x00, 0}
+    },
+    {
+        {0x13, 6}, {0x0b, 10}, {0x54, 12}, {0x00, 0}
+    },
+    {
+        {0x12, 6}, {0x0a, 10}, {0x00, 0}, {0x00, 0}
+    },
+    {
+        {0x11, 6}, {0x09, 10}, {0x00, 0}, {0x00, 0}
+    },
+    {
+        {0x10, 6}, {0x08, 10}, {0x00, 0}, {0x00, 0}
+    },
+    {
+        {0x16, 7}, {0x55, 12}, {0x00, 0}, {0x00, 0}
+    },
+    {
+        {0x15, 7}, {0x00, 0}, {0x00, 0}, {0x00, 0}
+    },
+    {
+        {0x14, 7}, {0x00, 0}, {0x00, 0}, {0x00, 0}
+    },
+    {
+        {0x1c, 8}, {0x00, 0}, {0x00, 0}, {0x00, 0}
+    },
+    {
+        {0x1b, 8}, {0x00, 0}, {0x00, 0}, {0x00, 0}
+    },
+    {
+        {0x21, 9}, {0x00, 0}, {0x00, 0}, {0x00, 0}
+    },
+    {
+        {0x20, 9}, {0x00, 0}, {0x00, 0}, {0x00, 0}
+    },
+    {
+        {0x1f, 9}, {0x00, 0}, {0x00, 0}, {0x00, 0}
+    },
+    {
+        {0x1e, 9}, {0x00, 0}, {0x00, 0}, {0x00, 0}
+    },
+    {
+        {0x1d, 9}, {0x00, 0}, {0x00, 0}, {0x00, 0}
+    },
+    {
+        {0x1c, 9}, {0x00, 0}, {0x00, 0}, {0x00, 0}
+    },
+    {
+        {0x1b, 9}, {0x00, 0}, {0x00, 0}, {0x00, 0}
+    },
+    {
+        {0x1a, 9}, {0x00, 0}, {0x00, 0}, {0x00, 0}
+    },
+    {
+        {0x22, 11}, {0x00, 0}, {0x00, 0}, {0x00, 0}
+    },
+    {
+        {0x23, 11}, {0x00, 0}, {0x00, 0}, {0x00, 0}
+    },
+    {
+        {0x56, 12}, {0x00, 0}, {0x00, 0}, {0x00, 0}
+    },
+    {
+        {0x57, 12}, {0x00, 0}, {0x00, 0}, {0x00, 0}
+    }
+};
+
+/* first coeffs of last = 1. indexing by [run][level-1] */
+
+static const VLCtable coeff_tab2[2][3] =
+{
+    /* run = 0 */
+    {
+        {0x07, 4}, {0x19, 9}, {0x05, 11}
+    },
+    /* run = 1 */
+    {
+        {0x0f, 6}, {0x04, 11}, {0x00, 0}
+    }
+};
+
+/* rest of coeffs for last = 1. indexing by [run-2] */
+
+static const VLCtable coeff_tab3[40] =
+{
+    {0x0e, 6}, {0x0d, 6}, {0x0c, 6},
+    {0x13, 7}, {0x12, 7}, {0x11, 7}, {0x10, 7},
+    {0x1a, 8}, {0x19, 8}, {0x18, 8}, {0x17, 8},
+    {0x16, 8}, {0x15, 8}, {0x14, 8}, {0x13, 8},
+    {0x18, 9}, {0x17, 9}, {0x16, 9}, {0x15, 9},
+    {0x14, 9}, {0x13, 9}, {0x12, 9}, {0x11, 9},
+    {0x07, 10}, {0x06, 10}, {0x05, 10}, {0x04, 10},
+    {0x24, 11}, {0x25, 11}, {0x26, 11}, {0x27, 11},
+    {0x58, 12}, {0x59, 12}, {0x5a, 12}, {0x5b, 12},
+    {0x5c, 12}, {0x5d, 12}, {0x5e, 12}, {0x5f, 12},
+    {0x00, 0}
+};
+
+/* New tables for Intra luminance coefficients. Same codewords,
+   different meaning */
+
+/* Coeffs for last = 0, run = 0. Indexed by [level-1] */
+
+static const VLCtable coeff_tab4[27] =
+{
+    /* run = 0 */
+    {0x02, 2}, {0x06, 3}, {0x0f, 4}, {0x0d, 5},
+    {0x0c, 5}, {0x15, 6}, {0x13, 6}, {0x12, 6},
+    {0x17, 7}, {0x1f, 8}, {0x1e, 8}, {0x1d, 8},
+    {0x25, 9}, {0x24, 9}, {0x23, 9}, {0x21, 9},
+    {0x21, 10}, {0x20, 10}, {0x0f, 10}, {0x0e, 10},
+    {0x07, 11}, {0x06, 11}, {0x20, 11}, {0x21, 11},
+    {0x50, 12}, {0x51, 12}, {0x52, 12}
+};
+
+/* Coeffs for last = 0, run = 1. Indexed by [level-1] */
+
+static const VLCtable coeff_tab5[10] =
+{
+    {0x0e, 4}, {0x14, 6}, {0x16, 7}, {0x1c, 8},
+    {0x20, 9}, {0x1f, 9}, {0x0d, 10}, {0x22, 11},
+    {0x53, 12}, {0x55, 12}
+};
+
+/* Coeffs for last = 0, run = 2 -> 9. Indexed by [run-2][level-1] */
+
+static const VLCtable coeff_tab6[8][5] =
+{
+    /* run = 2 */
+    {
+        {0x0b, 5}, {0x15, 7}, {0x1e, 9}, {0x0c, 10},
+        {0x56, 12}
+    },
+    /* run = 3 */
+    {
+        {0x11, 6}, {0x1b, 8}, {0x1d, 9}, {0x0b, 10},
+        {0x00, 0}
+    },
+    /* run = 4 */
+    {
+        {0x10, 6}, {0x22, 9}, {0x0a, 10}, {0x00, 0},
+        {0x00, 0}
+    },
+    /* run = 5 */
+    {
+        {0x0d, 6}, {0x1c, 9}, {0x08, 10}, {0x00, 0},
+        {0x00, 0}
+    },
+    /* run = 6 */
+    {
+        {0x12, 7}, {0x1b, 9}, {0x54, 12}, {0x00, 0},
+        {0x00, 0}
+    },
+    /* run = 7 */
+    {
+        {0x14, 7}, {0x1a, 9}, {0x57, 12}, {0x00, 0},
+        {0x00, 0}
+    },
+    /* run = 8 */
+    {
+        {0x19, 8}, {0x09, 10}, {0x00, 0}, {0x00, 0},
+        {0x00, 0}
+    },
+    /* run = 9 */
+    {
+        {0x18, 8}, {0x23, 11}, {0x00, 0}, {0x00, 0},
+        {0x00, 0}
+    }
+};
+
+/* Coeffs for last = 0, run = 10 -> 14. Indexed by [run-10] */
+
+static const VLCtable coeff_tab7[5] =
+{
+    {0x17, 8}, {0x19, 9}, {0x18, 9}, {0x07, 10},
+    {0x58, 12}
+};
+
+/* Coeffs for last = 1, run = 0. Indexed by [level-1] */
+
+static const VLCtable coeff_tab8[8] =
+{
+    {0x07, 4}, {0x0c, 6}, {0x16, 8}, {0x17, 9},
+    {0x06, 10}, {0x05, 11}, {0x04, 11}, {0x59, 12}
+};
+
+/* Coeffs for last = 1, run = 1 -> 6. Indexed by [run-1][level-1] */
+
+static const VLCtable coeff_tab9[6][3] =
+{
+    /* run = 1 */
+    {
+        {0x0f, 6}, {0x16, 9}, {0x05, 10}
+    },
+    /* run = 2 */
+    {
+        {0x0e, 6}, {0x04, 10}, {0x00, 0}
+    },
+    /* run = 3 */
+    {
+        {0x11, 7}, {0x24, 11}, {0x00, 0}
+    },
+    /* run = 4 */
+    {
+        {0x10, 7}, {0x25, 11}, {0x00, 0}
+    },
+    /* run = 5 */
+    {
+        {0x13, 7}, {0x5a, 12}, {0x00, 0}
+    },
+    /* run = 6 */
+    {
+        {0x15, 8}, {0x5b, 12}, {0x00, 0}
+    }
+};
+
+/* Coeffs for last = 1, run = 7 -> 20. Indexed by [run-7] */
+
+static const VLCtable coeff_tab10[14] =
+{
+    {0x14, 8}, {0x13, 8}, {0x1a, 8}, {0x15, 9},
+    {0x14, 9}, {0x13, 9}, {0x12, 9}, {0x11, 9},
+    {0x26, 11}, {0x27, 11}, {0x5c, 12}, {0x5d, 12},
+    {0x5e, 12}, {0x5f, 12}
+};
+
+
+#ifndef NO_RVLC
+/* RVLC tables */
+/* DCT coefficients. Four tables, two for last = 0, two for last = 1.
+   the sign bit must be added afterwards. */
+
+/* DCT  coeffs (intra) for last = 0.  */
+
+/* Indexed by [level-1] */
+
+static const VLCtable coeff_RVLCtab1[27] =
+{
+    /* run = 0 */
+    {     0x6,  3},
+    {     0x7,  3},
+    {     0xa,  4},
+    {     0x9,  5},
+    {    0x14,  6},
+    {    0x15,  6},
+    {    0x34,  7},
+    {    0x74,  8},
+    {    0x75,  8},
+    {    0xdd,  9},
+    {    0xec,  9},
+    {   0x1ec, 10},
+    {   0x1ed, 10},
+    {   0x1f4, 10},
+    {   0x3ec, 11},
+    {   0x3ed, 11},
+    {   0x3f4, 11},
+    {   0x77d, 12},
+    {   0x7bc, 12},
+    {   0xfbd, 13},
+    {   0xfdc, 13},
+    {   0x7bd, 12},
+    {   0xfdd, 13},
+    {  0x1fbd, 14},
+    {  0x1fdc, 14},
+    {  0x1fdd, 14},
+    {  0x1ffc, 15}
+};
+
+
+/* Indexed by [level-1] */
+
+static const VLCtable coeff_RVLCtab2[13] =
+{
+    /* run = 1 */
+    {     0x1,  4},
+    {     0x8,  5},
+    {    0x2d,  7},
+    {    0x6c,  8},
+    {    0x6d,  8},
+    {    0xdc,  9},
+    {   0x1dd, 10},
+    {   0x3dc, 11},
+    {   0x3dd, 11},
+    {   0x77c, 12},
+    {   0xfbc, 13},
+    {  0x1f7d, 14},
+    {  0x1fbc, 14}
+};
+
+
+/* Indexed by [level-1] */
+
+static const VLCtable coeff_RVLCtab3[11] =
+{
+    /* run = 2 */
+
+    {     0x4,  5},
+    {    0x2c,  7},
+    {    0xbc,  9},
+    {   0x1dc, 10},
+    {   0x3bc, 11},
+    {   0x3bd, 11},
+    {   0xefd, 13},
+    {   0xf7c, 13},
+    {   0xf7d, 13},
+    {  0x1efd, 14},
+    {  0x1f7c, 14}
+};
+
+
+/* Indexed by [level-1] */
+
+static const VLCtable coeff_RVLCtab4[9] =
+{
+    /* run = 3 */
+    {     0x5,  5},
+    {    0x5c,  8},
+    {    0xbd,  9},
+    {   0x37d, 11},
+    {   0x6fc, 12},
+    {   0xefc, 13},
+    {  0x1dfd, 14},
+    {  0x1efc, 14},
+    {  0x1ffd, 15}
+};
+
+
+/* Indexed by [run-4][level-1] */
+
+static const VLCtable coeff_RVLCtab5[2][6] =
+{
+    /* run = 4 */
+    {
+        {     0xc,  6},
+        {    0x5d,  8},
+        {   0x1bd, 10},
+        {   0x3fd, 12},
+        {   0x6fd, 12},
+        {  0x1bfd, 14}
+    },
+    /* run = 5 */
+    {
+        {     0xd,  6},
+        {    0x7d,  9},
+        {   0x2fc, 11},
+        {   0x5fc, 12},
+        {  0x1bfc, 14},
+        {  0x1dfc, 14}
+    }
+};
+
+
+/* Indexed by [run-6][level-1]       */
+
+static const VLCtable coeff_RVLCtab6[2][5] =
+{
+
+    /* run = 6 */
+    {
+        {    0x1c,  7},
+        {   0x17c, 10},
+        {   0x2fd, 11},
+        {   0x5fd, 12},
+        {  0x2ffc, 15}
+    },
+    /* run = 7 */
+    {
+        {    0x1d,  7},
+        {   0x17d, 10},
+        {   0x37c, 11},
+        {   0xdfd, 13},
+        {  0x2ffd, 15}
+    }
+
+};
+/* Indexed by [run-8][level-1] */
+
+static const VLCtable coeff_RVLCtab7[2][4] =
+{
+    /* run = 8 */
+    {
+        {    0x3c,  8},
+        {   0x1bc, 10},
+        {   0xbfd, 13},
+        {  0x17fd, 14}
+    },
+    /* run = 9 */
+    {
+        {    0x3d,  8},
+        {   0x1fd, 11},
+        {   0xdfc, 13},
+        {  0x37fc, 15},
+    }
+};
+
+
+
+/* Indexed by [run-10][level-1] */
+
+static const VLCtable coeff_RVLCtab8[3][2] =
+{
+    /* run = 10 */
+    {
+        {    0x7c,  9},
+        {   0x3fc, 12}
+    },
+    /* run = 11 */
+    {
+        {    0xfc, 10},
+        {   0xbfc, 13}
+    },
+    /* run = 12 */
+    {
+        {    0xfd, 10},
+        {  0x37fd, 15}
+    }
+};
+
+
+/* Indexed by [level-1] */
+
+static const VLCtable coeff_RVLCtab9[7] =
+{
+    /* run = 13 -> 19 */
+    {   0x1fc, 11},
+    {   0x7fc, 13},
+    {   0x7fd, 13},
+    {   0xffc, 14},
+    {   0xffd, 14},
+    {  0x17fc, 14},
+    {  0x3bfc, 15}
+};
+
+
+
+/* first coeffs of last = 1. indexing by [run][level-1] */
+
+static const VLCtable coeff_RVLCtab10[2][5] =
+{
+    /* run = 0 */
+    {
+        {     0xb,  4},
+        {    0x78,  8},
+        {   0x3f5, 11},
+        {   0xfec, 13},
+        {  0x1fec, 14}
+    },
+    /* run = 1 */
+    {
+        {    0x12,  5},
+        {    0xed,  9},
+        {   0x7dc, 12},
+        {  0x1fed, 14},
+        {  0x3bfd, 15}
+    }
+
+};
+
+static const VLCtable coeff_RVLCtab11[3] =
+{
+    /* run = 2 */
+    {    0x13,  5},
+    {   0x3f8, 11},
+    {  0x3dfc, 15}
+
+};
+
+static const VLCtable coeff_RVLCtab12[11][2] =
+{
+    /* run = 3 */
+    {
+        {    0x18,  6},
+        {   0x7dd, 12}
+    },
+    /* run = 4 */
+    {
+        {    0x19,  6},
+        {   0x7ec, 12}
+    },
+    /* run = 5 */
+    {
+        {    0x22,  6},
+        {   0xfed, 13}
+    },
+    /* run = 6 */
+    {
+        {    0x23,  6},
+        {   0xff4, 13}
+    },
+    /* run = 7 */
+    {
+        {    0x35,  7},
+        {   0xff5, 13}
+    },
+    /* run = 8 */
+    {
+        {    0x38,  7},
+        {   0xff8, 13}
+    },
+    /* run = 9 */
+    {
+        {    0x39,  7},
+        {   0xff9, 13}
+    },
+    /* run = 10 */
+    {
+        {    0x42,  7},
+        {  0x1ff4, 14}
+    },
+    /* run = 11 */
+    {
+        {    0x43,  7},
+        {  0x1ff5, 14}
+    },
+    /* run = 12 */
+    {
+        {    0x79,  8},
+        {  0x1ff8, 14}
+    },
+    /* run = 13 */
+    {
+        {    0x82,  8},
+        {  0x3dfd, 15}
+    }
+
+};
+
+static const VLCtable coeff_RVLCtab13[32] =
+{
+    /* run = 14 -> 44 */
+    {    0x83,  8},
+    {    0xf4,  9},
+    {    0xf5,  9},
+    {    0xf8,  9},
+    {    0xf9,  9},
+    {   0x102,  9},
+    {   0x103,  9},
+    {   0x1f5, 10},
+    {   0x1f8, 10},
+    {   0x1f9, 10},
+    {   0x202, 10},
+    {   0x203, 10},
+    {   0x3f9, 11},
+    {   0x402, 11},
+    {   0x403, 11},
+    {   0x7ed, 12},
+    {   0x7f4, 12},
+    {   0x7f5, 12},
+    {   0x7f8, 12},
+    {   0x7f9, 12},
+    {   0x802, 12},
+    {   0x803, 12},
+    {  0x1002, 13},
+    {  0x1003, 13},
+    {  0x1ff9, 14},
+    {  0x2002, 14},
+    {  0x2003, 14},
+    {  0x3efc, 15},
+    {  0x3efd, 15},
+    {  0x3f7c, 15},
+    {  0x3f7d, 15}
+};
+
+
+
+/* Coeffs for last = 0, run = 0. Indexed by [level-1] */
+
+static const VLCtable coeff_RVLCtab14[19] =
+{
+    /* run = 0 */
+    {     0x6,  3},
+    {     0x1,  4},
+    {     0x4,  5},
+    {    0x1c,  7},
+    {    0x3c,  8},
+    {    0x3d,  8},
+    {    0x7c,  9},
+    {    0xfc, 10},
+    {    0xfd, 10},
+    {   0x1fc, 11},
+    {   0x1fd, 11},
+    {   0x3fc, 12},
+    {   0x7fc, 13},
+    {   0x7fd, 13},
+    {   0xbfc, 13},
+    {   0xbfd, 13},
+    {   0xffc, 14},
+    {   0xffd, 14},
+    {  0x1ffc, 15}
+};
+
+static const VLCtable coeff_RVLCtab15[10] =
+{
+    /* run = 1 */
+    {     0x7,  3},
+    {     0xc,  6},
+    {    0x5c,  8},
+    {    0x7d,  9},
+    {   0x17c, 10},
+    {   0x2fc, 11},
+    {   0x3fd, 12},
+    {   0xdfc, 13},
+    {  0x17fc, 14},
+    {  0x17fd, 14}
+};
+
+static const VLCtable coeff_RVLCtab16[2][7] =
+{
+    /* run = 2 */
+    {
+        {     0xa,  4},
+        {    0x1d,  7},
+        {    0xbc,  9},
+        {   0x2fd, 11},
+        {   0x5fc, 12},
+        {  0x1bfc, 14},
+        {  0x1bfd, 14}
+    },
+    /* run = 3 */
+    {
+        {     0x5,  5},
+        {    0x5d,  8},
+        {   0x17d, 10},
+        {   0x5fd, 12},
+        {   0xdfd, 13},
+        {  0x1dfc, 14},
+        {  0x1ffd, 15}
+    }
+};
+
+static const VLCtable coeff_RVLCtab17[5] =
+{
+    /* run = 4 */
+    {     0x8,  5},
+    {    0x6c,  8},
+    {   0x37c, 11},
+    {   0xefc, 13},
+    {  0x2ffc, 15}
+};
+
+static const VLCtable coeff_RVLCtab18[3][4] =
+{
+    /* run = 5 */
+    {
+        {     0x9,  5},
+        {    0xbd,  9},
+        {   0x37d, 11},
+        {   0xefd, 13}
+    },
+    /* run = 6 */
+    {
+        {     0xd,  6},
+        {   0x1bc, 10},
+        {   0x6fc, 12},
+        {  0x1dfd, 14}
+    },
+    /* run = 7 */
+    {
+        {    0x14,  6},
+        {   0x1bd, 10},
+        {   0x6fd, 12},
+        {  0x2ffd, 15}
+    }
+};
+
+static const VLCtable coeff_RVLCtab19[2][3] =
+{
+    /* run = 8 */
+    {
+        {    0x15,  6},
+        {   0x1dc, 10},
+        {   0xf7c, 13}
+    },
+    /* run = 9 */
+    {
+        {    0x2c,  7},
+        {   0x1dd, 10},
+        {  0x1efc, 14}
+    }
+};
+
+static const VLCtable coeff_RVLCtab20[8][2] =
+{
+    /* run = 10 */
+    {
+        {    0x2d,  7},
+        {   0x3bc, 11}
+    },
+    /* run = 11 */
+    {
+        {    0x34,  7},
+        {   0x77c, 12}
+    },
+    /* run = 12 */
+    {
+        {    0x6d,  8},
+        {   0xf7d, 13}
+    },
+    /* run = 13 */
+    {
+        {    0x74,  8},
+        {  0x1efd, 14}
+    },
+    /* run = 14 */
+    {
+        {    0x75,  8},
+        {  0x1f7c, 14}
+    },
+    /* run = 15 */
+    {
+        {    0xdc,  9},
+        {  0x1f7d, 14}
+    },
+    /* run = 16 */
+    {
+        {    0xdd,  9},
+        {  0x1fbc, 14}
+    },
+    /* run = 17 */
+    {
+        {    0xec,  9},
+        {  0x37fc, 15}
+    }
+};
+
+static const VLCtable coeff_RVLCtab21[21] =
+{
+    /* run = 18 -> 38 */
+    {   0x1ec, 10},
+    {   0x1ed, 10},
+    {   0x1f4, 10},
+    {   0x3bd, 11},
+    {   0x3dc, 11},
+    {   0x3dd, 11},
+    {   0x3ec, 11},
+    {   0x3ed, 11},
+    {   0x3f4, 11},
+    {   0x77d, 12},
+    {   0x7bc, 12},
+    {   0x7bd, 12},
+    {   0xfbc, 13},
+    {   0xfbd, 13},
+    {   0xfdc, 13},
+    {   0xfdd, 13},
+    {  0x1fbd, 14},
+    {  0x1fdc, 14},
+    {  0x1fdd, 14},
+    {  0x37fd, 15},
+    {  0x3bfc, 15}
+};
+
+
+/* first coeffs of last = 1. indexing by [run][level-1] */
+
+static const VLCtable coeff_RVLCtab22[2][5] =
+{
+    /* run = 0 */
+    {
+        {     0xb,  4},
+        {    0x78,  8},
+        {   0x3f5, 11},
+        {   0xfec, 13},
+        {  0x1fec, 14}
+    },
+    /* run = 1 */
+    {
+        {    0x12,  5},
+        {    0xed,  9},
+        {   0x7dc, 12},
+        {  0x1fed, 14},
+        {  0x3bfd, 15}
+    }
+
+};
+
+static const VLCtable coeff_RVLCtab23[3] =
+{
+    /* run = 2 */
+    {    0x13,  5},
+    {   0x3f8, 11},
+    {  0x3dfc, 15}
+
+};
+
+static const VLCtable coeff_RVLCtab24[11][2] =
+{
+    /* run = 3 */
+    {
+        {    0x18,  6},
+        {   0x7dd, 12}
+    },
+    /* run = 4 */
+    {
+        {    0x19,  6},
+        {   0x7ec, 12}
+    },
+    /* run = 5 */
+    {
+        {    0x22,  6},
+        {   0xfed, 13}
+    },
+    /* run = 6 */
+    {
+        {    0x23,  6},
+        {   0xff4, 13}
+    },
+    /* run = 7 */
+    {
+        {    0x35,  7},
+        {   0xff5, 13}
+    },
+    /* run = 8 */
+    {
+        {    0x38,  7},
+        {   0xff8, 13}
+    },
+    /* run = 9 */
+    {
+        {    0x39,  7},
+        {   0xff9, 13}
+    },
+    /* run = 10 */
+    {
+        {    0x42,  7},
+        {  0x1ff4, 14}
+    },
+    /* run = 11 */
+    {
+        {    0x43,  7},
+        {  0x1ff5, 14}
+    },
+    /* run = 12 */
+    {
+        {    0x79,  8},
+        {  0x1ff8, 14}
+    },
+    /* run = 13 */
+    {
+        {    0x82,  8},
+        {  0x3dfd, 15}
+    }
+
+};
+
+static const VLCtable coeff_RVLCtab25[32] =
+{
+    /* run = 14 -> 44 */
+    {    0x83,  8},
+    {    0xf4,  9},
+    {    0xf5,  9},
+    {    0xf8,  9},
+    {    0xf9,  9},
+    {   0x102,  9},
+    {   0x103,  9},
+    {   0x1f5, 10},
+    {   0x1f8, 10},
+    {   0x1f9, 10},
+    {   0x202, 10},
+    {   0x203, 10},
+    {   0x3f9, 11},
+    {   0x402, 11},
+    {   0x403, 11},
+    {   0x7ed, 12},
+    {   0x7f4, 12},
+    {   0x7f5, 12},
+    {   0x7f8, 12},
+    {   0x7f9, 12},
+    {   0x802, 12},
+    {   0x803, 12},
+    {  0x1002, 13},
+    {  0x1003, 13},
+    {  0x1ff9, 14},
+    {  0x2002, 14},
+    {  0x2003, 14},
+    {  0x3efc, 15},
+    {  0x3efd, 15},
+    {  0x3f7c, 15},
+    {  0x3f7d, 15}
+};
+
+#endif /* NO_RVLC */
+
+#endif /* _VLC_ENC_TAB_H_ */
+
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/vlc_encode.cpp b/media/libstagefright/codecs/m4v_h263/enc/src/vlc_encode.cpp
new file mode 100644
index 0000000..7ea5dc4
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/vlc_encode.cpp
@@ -0,0 +1,2799 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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.
+ * -------------------------------------------------------------------
+ */
+/******************************************************************************
+*
+* This software module was originally developed by
+*
+* Robert Danielsen (Telenor / ACTS-MoMuSys).
+*
+* and edited by
+*
+* Luis Ducla-Soares (IST / ACTS-MoMuSys).
+* Cor Quist (KPN / ACTS-MoMuSys).
+*
+* in the course of development of the MPEG-4 Video (ISO/IEC 14496-2) standard.
+* This software module is an implementation of a part of one or more MPEG-4
+* Video (ISO/IEC 14496-2) tools as specified by the MPEG-4 Video (ISO/IEC
+* 14496-2) standard.
+*
+* ISO/IEC gives users of the MPEG-4 Video (ISO/IEC 14496-2) standard free
+* license to this software module or modifications thereof for use in hardware
+* or software products claiming conformance to the MPEG-4 Video (ISO/IEC
+* 14496-2) standard.
+*
+* Those intending to use this software module in hardware or software products
+* are advised that its use may infringe existing patents. The original
+* developer of this software module and his/her company, the subsequent
+* editors and their companies, and ISO/IEC have no liability for use of this
+* software module or modifications thereof in an implementation. Copyright is
+* not released for non MPEG-4 Video (ISO/IEC 14496-2) standard conforming
+* products.
+*
+* ACTS-MoMuSys partners retain full right to use the code for his/her own
+* purpose, assign or donate the code to a third party and to inhibit third
+* parties from using the code for non MPEG-4 Video (ISO/IEC 14496-2) standard
+* conforming products. This copyright notice must be included in all copies or
+* derivative works.
+*
+* Copyright (c) 1997
+*
+*****************************************************************************/
+
+/***********************************************************HeaderBegin*******
+*
+* File: putvlc.c
+*
+* Author:   Robert Danielsen, Telenor R&D
+* Created:  07.07.96
+*
+* Description: Functions for writing to bitstream
+*
+* Notes:    Same kind of tables as in the MPEG-2 software simulation
+*       group software.
+*
+* Modified:
+*   28.10.96 Robert Danielsen: Added PutCoeff_Intra(), renamed
+*           PutCoeff() to PutCoeff_Inter().
+*   06.11.96 Robert Danielsen: Added PutMCBPC_sep()
+*      01.05.97 Luis Ducla-Soares: added PutCoeff_Intra_RVLC() and
+*                                  PutCoeff_Inter_RVLC().
+*
+***********************************************************HeaderEnd*********/
+
+/************************    INCLUDE FILES    ********************************/
+
+
+#include "mp4lib_int.h"
+#include "mp4enc_lib.h"
+#include "vlc_enc_tab.h"
+#include "bitstream_io.h"
+#include "m4venc_oscl.h"
+#include "vlc_encode_inline.h"
+
+typedef void (*BlockCodeCoeffPtr)(RunLevelBlock*, BitstreamEncVideo*, Int, Int, UChar) ;
+
+const static Int mode_MBtype[] =
+{
+    3,
+    0,
+    4,
+    1,
+    2,
+};
+
+const static Int zigzag_inv[NCOEFF_BLOCK] =
+{
+    0,  1,  8, 16,  9,  2,  3, 10,
+    17, 24, 32, 25, 18, 11,  4,  5,
+    12, 19, 26, 33, 40, 48, 41, 34,
+    27, 20, 13,  6,  7, 14, 21, 28,
+    35, 42, 49, 56, 57, 50, 43, 36,
+    29, 22, 15, 23, 30, 37, 44, 51,
+    58, 59, 52, 45, 38, 31, 39, 46,
+    53, 60, 61, 54, 47, 55, 62, 63
+};
+
+/* Horizontal zigzag inverse */
+const static Int zigzag_h_inv[NCOEFF_BLOCK] =
+{
+    0, 1, 2, 3, 8, 9, 16, 17,
+    10, 11, 4, 5, 6, 7, 15, 14,
+    13, 12, 19, 18, 24, 25, 32, 33,
+    26, 27, 20, 21, 22, 23, 28, 29,
+    30, 31, 34, 35, 40, 41, 48, 49,
+    42, 43, 36, 37, 38, 39, 44, 45,
+    46, 47, 50, 51, 56, 57, 58, 59,
+    52, 53, 54, 55, 60, 61, 62, 63
+};
+
+/* Vertical zigzag inverse */
+const static Int zigzag_v_inv[NCOEFF_BLOCK] =
+{
+    0, 8, 16, 24, 1, 9, 2, 10,
+    17, 25, 32, 40, 48, 56, 57, 49,
+    41, 33, 26, 18, 3, 11, 4, 12,
+    19, 27, 34, 42, 50, 58, 35, 43,
+    51, 59, 20, 28, 5, 13, 6, 14,
+    21, 29, 36, 44, 52, 60, 37, 45,
+    53, 61, 22, 30, 7, 15, 23, 31,
+    38, 46, 54, 62, 39, 47, 55, 63
+};
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    Int PutCoeff_Inter(Int run, Int level, BitstreamEncVideo *bitstream);
+    Int PutCoeff_Inter_Last(Int run, Int level, BitstreamEncVideo *bitstream);
+    Int PutCoeff_Intra(Int run, Int level, BitstreamEncVideo *bitstream);
+    Int PutCoeff_Intra_Last(Int run, Int level, BitstreamEncVideo *bitstream);
+    Int PutCBPY(Int cbpy, Char intra, BitstreamEncVideo *bitstream);
+    Int PutMCBPC_Inter(Int cbpc, Int mode, BitstreamEncVideo *bitstream);
+    Int PutMCBPC_Intra(Int cbpc, Int mode, BitstreamEncVideo *bitstream);
+    Int PutMV(Int mvint, BitstreamEncVideo *bitstream);
+    Int PutDCsize_chrom(Int size, BitstreamEncVideo *bitstream);
+    Int PutDCsize_lum(Int size, BitstreamEncVideo *bitstream);
+    Int PutDCsize_lum(Int size, BitstreamEncVideo *bitstream);
+#ifndef NO_RVLC
+    Int PutCoeff_Inter_RVLC(Int run, Int level, BitstreamEncVideo *bitstream);
+    Int PutCoeff_Inter_RVLC_Last(Int run, Int level, BitstreamEncVideo *bitstream);
+    Int PutCoeff_Intra_RVLC(Int run, Int level, BitstreamEncVideo *bitstream);
+    Int PutCoeff_Intra_RVLC_Last(Int run, Int level, BitstreamEncVideo *bitstream);
+#endif
+    Int PutRunCoeff_Inter(Int run, Int level, BitstreamEncVideo *bitstream);
+    Int PutRunCoeff_Inter_Last(Int run, Int level, BitstreamEncVideo *bitstream);
+    Int PutRunCoeff_Intra(Int run, Int level, BitstreamEncVideo *bitstream);
+    Int PutRunCoeff_Intra_Last(Int run, Int level, BitstreamEncVideo *bitstream);
+    Int PutLevelCoeff_Inter(Int run, Int level, BitstreamEncVideo *bitstream);
+    Int PutLevelCoeff_Inter_Last(Int run, Int level, BitstreamEncVideo *bitstream);
+    Int PutLevelCoeff_Intra(Int run, Int level, BitstreamEncVideo *bitstream);
+    Int PutLevelCoeff_Intra_Last(Int run, Int level, BitstreamEncVideo *bitstream);
+
+    void RunLevel(VideoEncData *video, Int intra, Int intraDC_decision, Int ncoefblck[]);
+    Int IntraDC_dpcm(Int val, Int lum, BitstreamEncVideo *bitstream);
+    Void DCACPred(VideoEncData *video, UChar Mode, Int *intraDC_decision, Int intraDCVlcQP);
+    Void find_pmvs(VideoEncData *video, Int block, Int *mvx, Int *mvy);
+    Void  WriteMVcomponent(Int f_code, Int dmv, BitstreamEncVideo *bs);
+    static Bool IntraDCSwitch_Decision(Int Mode, Int intra_dc_vlc_threshold, Int intraDCVlcQP);
+
+    Void ScaleMVD(Int  f_code, Int  diff_vector, Int  *residual, Int  *vlc_code_mag);
+
+#ifdef __cplusplus
+}
+#endif
+
+Int
+PutDCsize_lum(Int size, BitstreamEncVideo *bitstream)
+{
+    Int length;
+
+    if (!(size >= 0 && size < 13))
+        return -1;
+
+    length = DCtab_lum[size].len;
+    if (length)
+        BitstreamPutBits(bitstream, length, DCtab_lum[size].code);
+
+    return length;
+}
+
+Int
+PutDCsize_chrom(Int size, BitstreamEncVideo *bitstream)
+{
+    Int length;
+
+    if (!(size >= 0 && size < 13))
+        return -1;
+    length = DCtab_chrom[size].len;
+    if (length)
+        BitstreamPutBits(bitstream, length, DCtab_chrom[size].code);
+
+    return length;
+}
+
+Int
+PutMV(Int mvint, BitstreamEncVideo *bitstream)
+{
+    Int sign = 0;
+    Int absmv;
+    Int length;
+
+    if (mvint > 32)
+    {
+        absmv = -mvint + 65;
+        sign = 1;
+    }
+    else
+        absmv = mvint;
+
+    length = mvtab[absmv].len;
+    if (length)
+        BitstreamPutBits(bitstream, length, mvtab[absmv].code);
+
+    if (mvint != 0)
+    {
+        BitstreamPut1Bits(bitstream, sign);
+        return (length + 1);
+    }
+    else
+        return length;
+}
+
+Int
+PutMCBPC_Intra(Int cbp, Int mode, BitstreamEncVideo *bitstream)
+{
+    Int ind;
+    Int length;
+
+    ind = ((mode_MBtype[mode] >> 1) & 3) | ((cbp & 3) << 2);
+
+    length = mcbpc_intra_tab[ind].len;
+    if (length)
+        BitstreamPutBits(bitstream, length, mcbpc_intra_tab[ind].code);
+
+    return length;
+}
+
+Int
+PutMCBPC_Inter(Int cbp, Int mode, BitstreamEncVideo *bitstream)
+{
+    Int ind;
+    Int length;
+
+    ind = (mode_MBtype[mode] & 7) | ((cbp & 3) << 3);
+
+    length = mcbpc_inter_tab[ind].len;
+    if (length)
+        BitstreamPutBits(bitstream, length, mcbpc_inter_tab[ind].code);
+
+    return length;
+}
+
+Int
+PutCBPY(Int cbpy, Char intra, BitstreamEncVideo *bitstream)
+{
+    Int ind;
+    Int length;
+
+    if ((intra == 0))
+        cbpy = 15 - cbpy;
+
+    ind = cbpy;
+
+    length = cbpy_tab[ind].len;
+    if (length)
+        BitstreamPutBits(bitstream, length, (UInt)cbpy_tab[ind].code);
+
+    return length;
+}
+
+/* 5/16/01, break up function for last and not-last coefficient */
+/* Note:::: I checked the ARM assembly for if( run > x && run < y) type
+    of code, they do a really good job compiling it to if( (UInt)(run-x) < y-x).
+    No need to hand-code it!!!!!, 6/1/2001 */
+
+Int PutCoeff_Inter(Int run, Int level, BitstreamEncVideo *bitstream)
+{
+    Int length = 0;
+
+    if (run < 2 && level < 13)
+    {
+        length = coeff_tab0[run][level-1].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab0[run][level-1].code);
+    }
+    else if (run > 1 && run < 27 && level < 5)
+    {
+        length = coeff_tab1[run-2][level-1].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab1[run-2][level-1].code);
+    }
+
+    return length;
+}
+
+Int PutCoeff_Inter_Last(Int run, Int level, BitstreamEncVideo *bitstream)
+{
+    Int length = 0;
+
+    if (run < 2 && level < 4)
+    {
+        length = coeff_tab2[run][level-1].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab2[run][level-1].code);
+    }
+    else if (run > 1 && run < 42 && level == 1)
+    {
+        length = coeff_tab3[run-2].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab3[run-2].code);
+    }
+
+    return length;
+}
+
+/* 5/16/01, break up function for last and not-last coefficient */
+
+Int PutCoeff_Intra(Int run, Int level, BitstreamEncVideo *bitstream)
+{
+    Int length = 0;
+
+    if (run == 0 && level < 28)
+    {
+        length = coeff_tab4[level-1].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab4[level-1].code);
+    }
+    else if (run == 1 && level < 11)
+    {
+        length = coeff_tab5[level-1].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab5[level-1].code);
+    }
+    else if (run > 1 && run < 10 && level < 6)
+    {
+        length = coeff_tab6[run-2][level-1].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab6[run-2][level-1].code);
+    }
+    else if (run > 9 && run < 15 && level == 1)
+    {
+        length = coeff_tab7[run-10].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab7[run-10].code);
+    }
+
+    return length;
+}
+
+Int PutCoeff_Intra_Last(Int run, Int level, BitstreamEncVideo *bitstream)
+{
+    Int length = 0;
+
+    if (run == 0 && level < 9)
+    {
+        length = coeff_tab8[level-1].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab8[level-1].code);
+    }
+    else if (run > 0 && run < 7 && level < 4)
+    {
+        length = coeff_tab9[run-1][level-1].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab9[run-1][level-1].code);
+    }
+    else if (run > 6 && run < 21 && level == 1)
+    {
+        length = coeff_tab10[run-7].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab10[run-7].code);
+    }
+
+    return length;
+}
+
+/* 5/16/01, break up function for last and not-last coefficient */
+#ifndef NO_RVLC
+Int PutCoeff_Inter_RVLC(Int run, Int level, BitstreamEncVideo *bitstream)
+{
+    Int length = 0;
+
+    if (run == 0 && level < 20)
+    {
+        length =  coeff_RVLCtab14[level-1].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab14[level-1].code);
+    }
+    else if (run == 1 && level < 11)
+    {
+        length = coeff_RVLCtab15[level-1].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab15[level-1].code);
+    }
+    else if (run > 1 && run < 4 && level < 8)
+    {
+        length = coeff_RVLCtab16[run-2][level-1].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab16[run-2][level-1].code);
+    }
+    else if (run == 4 && level < 6)
+    {
+        length = coeff_RVLCtab17[level-1].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab17[level-1].code);
+    }
+    else if (run > 4 && run < 8 && level < 5)
+    {
+        length = coeff_RVLCtab18[run-5][level-1].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab18[run-5][level-1].code);
+    }
+    else if (run > 7 && run < 10 && level < 4)
+    {
+        length = coeff_RVLCtab19[run-8][level-1].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab19[run-8][level-1].code);
+    }
+    else if (run > 9 && run < 18 && level < 3)
+    {
+        length = coeff_RVLCtab20[run-10][level-1].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab20[run-10][level-1].code);
+    }
+    else if (run > 17 && run < 39 && level == 1)
+    {
+        length = coeff_RVLCtab21[run-18].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab21[run-18].code);
+    }
+
+    return length;
+}
+
+Int PutCoeff_Inter_RVLC_Last(Int run, Int level, BitstreamEncVideo *bitstream)
+{
+    Int length = 0;
+
+    if (run >= 0 && run < 2 && level < 6)
+    {
+        length = coeff_RVLCtab22[run][level-1].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab22[run][level-1].code);
+    }
+    else if (run == 2 && level < 4)
+    {
+        length = coeff_RVLCtab23[level-1].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab23[level-1].code);
+    }
+    else if (run > 2 && run < 14 && level < 3)
+    {
+        length = coeff_RVLCtab24[run-3][level-1].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab24[run-3][level-1].code);
+    }
+    else if (run > 13 && run < 45 && level == 1)
+    {
+        length = coeff_RVLCtab25[run-14].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab25[run-14].code);
+    }
+
+    return length;
+}
+
+/* 5/16/01, break up function for last and not-last coefficient */
+
+Int PutCoeff_Intra_RVLC(Int run, Int level, BitstreamEncVideo *bitstream)
+{
+    Int length = 0;
+
+    if (run == 0 && level < 28)
+    {
+        length = coeff_RVLCtab1[level-1].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab1[level-1].code);
+    }
+    else if (run == 1 && level < 14)
+    {
+        length = coeff_RVLCtab2[level-1].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab2[level-1].code);
+    }
+    else if (run == 2 && level < 12)
+    {
+        length = coeff_RVLCtab3[level-1].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab3[level-1].code);
+    }
+    else if (run == 3 && level < 10)
+    {
+        length = coeff_RVLCtab4[level-1].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab4[level-1].code);
+    }
+    else if (run > 3 && run < 6 && level < 7)
+    {
+        length = coeff_RVLCtab5[run-4][level-1].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab5[run-4][level-1].code);
+    }
+    else if (run > 5 && run < 8 && level < 6)
+    {
+        length = coeff_RVLCtab6[run-6][level-1].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab6[run-6][level-1].code);
+    }
+    else if (run > 7 && run < 10 && level < 5)
+    {
+        length = coeff_RVLCtab7[run-8][level-1].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab7[run-8][level-1].code);
+
+    }
+    else if (run > 9 && run < 13 && level < 3)
+    {
+        length = coeff_RVLCtab8[run-10][level-1].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab8[run-10][level-1].code);
+    }
+    else if (run > 12 && run < 20 && level == 1)
+    {
+        length = coeff_RVLCtab9[run-13].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab9[run-13].code);
+    }
+    return length;
+}
+
+Int PutCoeff_Intra_RVLC_Last(Int run, Int level, BitstreamEncVideo *bitstream)
+{
+    Int length = 0;
+
+    if (run >= 0 && run < 2 && level < 6)
+    {
+        length = coeff_RVLCtab10[run][level-1].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab10[run][level-1].code);
+    }
+    else if (run == 2 && level < 4)
+    {
+        length = coeff_RVLCtab11[level-1].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab11[level-1].code);
+    }
+    else if (run > 2 && run < 14 && level < 3)
+    {
+        length = coeff_RVLCtab12[run-3][level-1].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab12[run-3][level-1].code);
+    }
+    else if (run > 13 && run < 45 && level == 1)
+    {
+        length = coeff_RVLCtab13[run-14].len;
+        if (length)
+            BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab13[run-14].code);
+    }
+    return length;
+}
+#endif
+
+/* The following is for 3-mode VLC */
+
+Int
+PutRunCoeff_Inter(Int run, Int level, BitstreamEncVideo *bitstream)
+{
+    Int length = 0;
+
+    if (run < 2 && level < 13)
+    {
+        length = coeff_tab0[run][level-1].len;
+        if (length)
+        {
+            BitstreamPutGT8Bits(bitstream, 7 + 2, 14/*3*/);
+            //BitstreamPutBits(bitstream, 2, 2);
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab0[run][level-1].code);
+            length += 9;
+        }
+    }
+    else if (run > 1 && run < 27 && level < 5)
+    {
+        length = coeff_tab1[run-2][level-1].len;
+        if (length)
+        {
+            BitstreamPutGT8Bits(bitstream, 7 + 2, 14/*3*/);
+            //BitstreamPutBits(bitstream, 2, 2);
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab1[run-2][level-1].code);
+            length += 9;
+        }
+    }
+    return length;
+}
+
+Int PutRunCoeff_Inter_Last(Int run, Int level, BitstreamEncVideo *bitstream)
+{
+    Int length = 0;
+
+    if (run < 2 && level < 4)
+    {
+        length = coeff_tab2[run][level-1].len;
+        if (length)
+        {
+            BitstreamPutGT8Bits(bitstream, 7 + 2, 14/*3*/);
+            //BitstreamPutBits(bitstream, 2, 2);
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab2[run][level-1].code);
+            length += 9;
+        }
+    }
+    else if (run > 1 && run < 42 && level == 1)
+    {
+        length = coeff_tab3[run-2].len;
+        if (length)
+        {
+            BitstreamPutGT8Bits(bitstream, 7 + 2, 14/*3*/);
+            //BitstreamPutBits(bitstream, 2, 2);
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab3[run-2].code);
+            length += 9;
+        }
+    }
+    return length;
+}
+
+Int PutRunCoeff_Intra(Int run, Int level, BitstreamEncVideo *bitstream)
+{
+    Int length = 0;
+
+    if (run == 0 && level < 28)
+    {
+        length = coeff_tab4[level-1].len;
+        if (length)
+        {
+            BitstreamPutGT8Bits(bitstream, 7 + 2, 14/*3*/);
+            //BitstreamPutBits(bitstream, 2, 2);
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab4[level-1].code);
+            length += 9;
+        }
+    }
+    else if (run == 1 && level < 11)
+    {
+        length = coeff_tab5[level-1].len;
+        if (length)
+        {
+            BitstreamPutGT8Bits(bitstream, 7 + 2, 14/*3*/);
+            //BitstreamPutBits(bitstream, 2, 2);
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab5[level-1].code);
+            length += 9;
+        }
+    }
+    else if (run > 1 && run < 10 && level < 6)
+    {
+        length = coeff_tab6[run-2][level-1].len;
+        if (length)
+        {
+            BitstreamPutGT8Bits(bitstream, 7 + 2, 14/*3*/);
+            //BitstreamPutBits(bitstream, 2, 2);
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab6[run-2][level-1].code);
+            length += 9;
+        }
+    }
+    else if (run > 9 && run < 15 && level == 1)
+    {
+        length = coeff_tab7[run-10].len;
+        if (length)
+        {
+            BitstreamPutGT8Bits(bitstream, 7 + 2, 14/*3*/);
+            //BitstreamPutBits(bitstream, 2, 2);
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab7[run-10].code);
+            length += 9;
+        }
+    }
+    return length;
+}
+Int PutRunCoeff_Intra_Last(Int run, Int level, BitstreamEncVideo *bitstream)
+{
+    Int length = 0;
+
+    if (run == 0 && level < 9)
+    {
+        length = coeff_tab8[level-1].len;
+        if (length)
+        {
+            BitstreamPutGT8Bits(bitstream, 7 + 2, 14/*3*/);
+            //BitstreamPutBits(bitstream, 2, 2);
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab8[level-1].code);
+            length += 9;
+        }
+    }
+    else if (run > 0 && run < 7 && level < 4)
+    {
+        length = coeff_tab9[run-1][level-1].len;
+        if (length)
+        {
+            BitstreamPutGT8Bits(bitstream, 7 + 2, 14/*3*/);
+            //BitstreamPutBits(bitstream, 2, 2);
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab9[run-1][level-1].code);
+            length += 9;
+        }
+    }
+    else if (run > 6 && run < 21 && level == 1)
+    {
+        length = coeff_tab10[run-7].len;
+        if (length)
+        {
+            BitstreamPutGT8Bits(bitstream, 7 + 2, 14/*3*/);
+            //BitstreamPutBits(bitstream, 2, 2);
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab10[run-7].code);
+            length += 9;
+        }
+    }
+    return length;
+}
+
+Int
+PutLevelCoeff_Inter(Int run, Int level, BitstreamEncVideo *bitstream)
+{
+    Int length = 0;
+
+    if (run < 2 && level < 13)
+    {
+        length = coeff_tab0[run][level-1].len;
+        if (length)
+        {
+            BitstreamPutBits(bitstream, 7 + 1, 6/*3*/);
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab0[run][level-1].code);
+            length += 8;
+        }
+    }
+    else if (run > 1 && run < 27 && level < 5)
+    {
+        length = coeff_tab1[run-2][level-1].len;
+        if (length)
+        {
+            BitstreamPutBits(bitstream, 7 + 1, 6/*3*/);
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab1[run-2][level-1].code);
+            length += 8;
+        }
+    }
+    return length;
+}
+
+Int PutLevelCoeff_Inter_Last(Int run, Int level, BitstreamEncVideo *bitstream)
+{
+    Int length = 0;
+
+    if (run < 2 && level < 4)
+    {
+        length = coeff_tab2[run][level-1].len;
+        if (length)
+        {
+            BitstreamPutBits(bitstream, 7 + 1, 6/*3*/);
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab2[run][level-1].code);
+            length += 8;
+        }
+    }
+    else if (run > 1 && run < 42 && level == 1)
+    {
+        length = coeff_tab3[run-2].len;
+        if (length)
+        {
+            BitstreamPutBits(bitstream, 7 + 1, 6/*3*/);
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab3[run-2].code);
+            length += 8;
+        }
+    }
+    return length;
+}
+
+Int PutLevelCoeff_Intra(Int run, Int level, BitstreamEncVideo *bitstream)
+{
+    Int length = 0;
+
+    if (run == 0 && level < 28)
+    {
+        length = coeff_tab4[level-1].len;
+        if (length)
+        {
+            BitstreamPutBits(bitstream, 7 + 1, 6/*3*/);
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab4[level-1].code);
+            length += 8;
+        }
+    }
+    else if (run == 1 && level < 11)
+    {
+        length = coeff_tab5[level-1].len;
+        if (length)
+        {
+            BitstreamPutBits(bitstream, 7 + 1, 6/*3*/);
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab5[level-1].code);
+            length += 8;
+        }
+    }
+    else if (run > 1 && run < 10 && level < 6)
+    {
+        length = coeff_tab6[run-2][level-1].len;
+        if (length)
+        {
+            BitstreamPutBits(bitstream, 7 + 1, 6/*3*/);
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab6[run-2][level-1].code);
+            length += 8;
+        }
+    }
+    else if (run > 9 && run < 15 && level == 1)
+    {
+        length = coeff_tab7[run-10].len;
+        if (length)
+        {
+            BitstreamPutBits(bitstream, 7 + 1, 6/*3*/);
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab7[run-10].code);
+            length += 8;
+        }
+    }
+    return length;
+}
+Int PutLevelCoeff_Intra_Last(Int run, Int level, BitstreamEncVideo *bitstream)
+{
+    Int length = 0;
+
+    if (run == 0 && level < 9)
+    {
+        length = coeff_tab8[level-1].len;
+        if (length)
+        {
+            BitstreamPutBits(bitstream, 7 + 1, 6/*3*/);
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab8[level-1].code);
+            length += 8;
+        }
+    }
+    else if (run > 0 && run < 7 && level < 4)
+    {
+        length = coeff_tab9[run-1][level-1].len;
+        if (length)
+        {
+            BitstreamPutBits(bitstream, 7 + 1, 6/*3*/);
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab9[run-1][level-1].code);
+            length += 8;
+        }
+    }
+    else if (run > 6 && run < 21 && level == 1)
+    {
+        length = coeff_tab10[run-7].len;
+        if (length)
+        {
+            BitstreamPutBits(bitstream, 7 + 1, 6/*3*/);
+            BitstreamPutBits(bitstream, length, (UInt)coeff_tab10[run-7].code);
+            length += 8;
+        }
+    }
+    return length;
+}
+
+
+
+/* ======================================================================== */
+/*  Function : MBVlcEncode()                                                */
+/*  Date     : 09/10/2000                                                   */
+/*  Purpose  : Encode GOV Header                                            */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified : 5/21/01, break up into smaller functions                     */
+/* ======================================================================== */
+#ifndef H263_ONLY
+/**************************************/
+/* Data Partitioning I-VOP Encoding   */
+/**************************************/
+
+void MBVlcEncodeDataPar_I_VOP(
+    VideoEncData *video,
+    Int ncoefblck[],
+    void *blkCodePtr)
+{
+
+    BitstreamEncVideo *bs1 = video->bitstream1;
+    BitstreamEncVideo *bs2 = video->bitstream2;
+    BitstreamEncVideo *bs3 = video->bitstream3;
+    int i;
+    UChar Mode = video->headerInfo.Mode[video->mbnum];
+    UChar CBP;
+//  MacroBlock *MB=video->outputMB;
+    Int mbnum = video->mbnum;
+    Int intraDC_decision, DC;
+//  int temp;
+    Int dquant; /* 3/15/01 */
+    RunLevelBlock *RLB = video->RLB;
+    BlockCodeCoeffPtr BlockCodeCoeff = (BlockCodeCoeffPtr) blkCodePtr;
+
+    /* DC and AC Prediction, 5/28/01, compute CBP, intraDC_decision*/
+    DCACPred(video, Mode, &intraDC_decision, video->QP_prev);
+
+    /* CBP, Run, Level, and Sign */
+    RunLevel(video, 1, intraDC_decision, ncoefblck);
+    CBP = video->headerInfo.CBP[mbnum];
+
+    /* Compute DQuant */
+    dquant = video->QPMB[mbnum] - video->QP_prev; /* 3/15/01, QP_prev may not equal QPMB[mbnum-1] if mbnum-1 is skipped*/
+
+    video->QP_prev = video->QPMB[mbnum];
+
+    if (dquant && Mode == MODE_INTRA)
+    {
+        Mode = MODE_INTRA_Q;
+    }
+
+    if (dquant >= 0)
+        dquant = (PV_ABS(dquant) + 1);
+    else
+        dquant = (PV_ABS(dquant) - 1);
+
+    /* FIRST PART: ALL TO BS1 */
+
+    PutMCBPC_Intra(CBP, Mode, bs1); /* MCBPC */
+
+    if (Mode == MODE_INTRA_Q)
+        /*  MAY NEED TO CHANGE DQUANT HERE  */
+        BitstreamPutBits(bs1, 2, dquant);  /* dquant*/
+
+
+    if (intraDC_decision == 0)
+    {
+        for (i = 0; i < 6; i++)
+        {
+            DC = video->RLB[i].level[0];
+            if (video->RLB[i].s[0])
+                DC = -DC;
+            if (i < 4)
+                /*temp =*/ IntraDC_dpcm(DC, 1, bs1);        /* dct_dc_size_luminance, */
+            else                                    /* dct_dc_differential, and */
+                /*temp =*/ IntraDC_dpcm(DC, 0, bs1);        /* marker bit */
+        }
+    }
+
+    /* SECOND PART: ALL TO BS2*/
+
+    BitstreamPut1Bits(bs2, video->acPredFlag[video->mbnum]);    /* ac_pred_flag */
+
+    /*temp=*/
+    PutCBPY(CBP >> 2, (Char)(1), bs2); /* cbpy */
+
+
+    /* THIRD PART:  ALL TO BS3*/
+    /* MB_CodeCoeff(video,bs3); */ /* 5/22/01, replaced with below */
+    for (i = 0; i < 6; i++)
+    {
+        if (CBP&(1 << (5 - i)))
+            (*BlockCodeCoeff)(&(RLB[i]), bs3, 1 - intraDC_decision, ncoefblck[i], Mode);/* Code Intra AC*/
+    }
+
+    return ;
+}
+
+/************************************/
+/* Data Partitioning P-VOP Encoding */
+/************************************/
+
+void MBVlcEncodeDataPar_P_VOP(
+    VideoEncData *video,
+    Int ncoefblck[],
+    void *blkCodePtr)
+{
+
+    BitstreamEncVideo *bs1 = video->bitstream1;
+    BitstreamEncVideo *bs2 = video->bitstream2;
+    BitstreamEncVideo *bs3 = video->bitstream3;
+    int i;
+    Int mbnum = video->mbnum;
+    UChar Mode = video->headerInfo.Mode[mbnum];
+    Int QP_tmp = video->QPMB[mbnum];
+    UChar CBP;
+//  MacroBlock *MB=video->outputMB;
+    Int intra, intraDC_decision, DC;
+    Int pmvx, pmvy;
+//  int temp;
+    Int dquant; /* 3/15/01 */
+    RunLevelBlock *RLB = video->RLB;
+    BlockCodeCoeffPtr BlockCodeCoeff = (BlockCodeCoeffPtr) blkCodePtr;
+
+    intra = (Mode == MODE_INTRA || Mode == MODE_INTRA_Q);
+
+    /* DC and AC Prediction, 5/28/01, compute CBP, intraDC_decision*/
+
+    if (intra)
+    {
+        if (video->usePrevQP)
+        {
+            QP_tmp = video->QPMB[mbnum-1];
+        }
+
+        DCACPred(video, Mode, &intraDC_decision, QP_tmp);
+    }
+    else
+        intraDC_decision = 0; /* used in RunLevel */
+
+    /* CBP, Run, Level, and Sign */
+    RunLevel(video, intra, intraDC_decision, ncoefblck);
+    CBP = video->headerInfo.CBP[mbnum];
+
+    /* Compute DQuant */
+    dquant = video->QPMB[mbnum] - video->QP_prev; /* 3/15/01, QP_prev may not equal QPMB[mbnum-1] if mbnum-1 is skipped*/
+
+    if (dquant && (Mode == MODE_INTRA || Mode == MODE_INTER))
+    {
+        Mode += 2;  /* make it MODE_INTRA_Q and MODE_INTER_Q */
+    }
+
+    if (dquant >= 0)
+        dquant = (PV_ABS(dquant) + 1);
+    else
+        dquant = (PV_ABS(dquant) - 1);
+
+    /* FIRST PART: ALL TO BS1 */
+
+    if (CBP == 0 && intra == 0)  /* Determine if Skipped MB */
+    {
+        if ((Mode == MODE_INTER) && (video->mot[mbnum][0].x == 0) && (video->mot[mbnum][0].y == 0))
+            Mode = video->headerInfo.Mode[video->mbnum] = MODE_SKIPPED;
+        else if ((Mode == MODE_INTER4V) && (video->mot[mbnum][1].x == 0) && (video->mot[mbnum][1].y == 0)
+                 && (video->mot[mbnum][2].x == 0) && (video->mot[mbnum][2].y == 0)
+                 && (video->mot[mbnum][3].x == 0) && (video->mot[mbnum][3].y == 0)
+                 && (video->mot[mbnum][4].x == 0) && (video->mot[mbnum][4].y == 0))
+            Mode = video->headerInfo.Mode[video->mbnum] = MODE_SKIPPED;
+    }
+
+
+    if (Mode == MODE_SKIPPED)
+    {
+        BitstreamPut1Bits(bs1, 1); /* not_coded = 1 */
+        return;
+    }
+    else
+        BitstreamPut1Bits(bs1, 0); /* not_coded =0 */
+
+    video->QP_prev = video->QPMB[mbnum];
+    video->usePrevQP = 1;
+
+    PutMCBPC_Inter(CBP, Mode, bs1); /* MCBPC */
+
+    video->header_bits -= BitstreamGetPos(bs1); /* Header Bits */
+
+    if (Mode == MODE_INTER || Mode == MODE_INTER_Q)
+    {
+        find_pmvs(video, 0, &pmvx, &pmvy); /* Get predicted motion vectors */
+        WriteMVcomponent(video->currVop->fcodeForward, video->mot[mbnum][0].x - pmvx, bs1); /* Write x to bitstream */
+        WriteMVcomponent(video->currVop->fcodeForward, video->mot[mbnum][0].y - pmvy, bs1);     /* Write y to bitstream */
+    }
+    else if (Mode == MODE_INTER4V)
+    {
+        for (i = 1; i < 5; i++)
+        {
+            find_pmvs(video, i, &pmvx, &pmvy);
+            WriteMVcomponent(video->currVop->fcodeForward, video->mot[mbnum][i].x - pmvx, bs1);
+            WriteMVcomponent(video->currVop->fcodeForward, video->mot[mbnum][i].y - pmvy, bs1);
+        }
+    }
+    video->header_bits += BitstreamGetPos(bs1); /* Header Bits */
+
+    /* SECOND PART: ALL TO BS2 */
+
+
+    if (intra)
+    {
+        BitstreamPut1Bits(bs2, video->acPredFlag[video->mbnum]);    /* ac_pred_flag */
+        /*temp=*/
+        PutCBPY(CBP >> 2, (Char)(Mode == MODE_INTRA || Mode == MODE_INTRA_Q), bs2); /* cbpy */
+
+        if (Mode == MODE_INTRA_Q)
+            BitstreamPutBits(bs2, 2, dquant);  /* dquant, 3/15/01*/
+
+        if (intraDC_decision == 0)
+        {
+            for (i = 0; i < 6; i++)
+            {
+                DC = video->RLB[i].level[0];
+                if (video->RLB[i].s[0])
+                    DC = -DC;
+                if (i < 4)
+                    /*temp =*/ IntraDC_dpcm(DC, 1, bs2);        /* dct_dc_size_luminance, */
+                else                                    /* dct_dc_differential, and */
+                    /*temp =*/ IntraDC_dpcm(DC, 0, bs2);        /* marker bit */
+            }
+        }
+
+        /****************************/  /* THIRD PART: ALL TO BS3 */
+        for (i = 0; i < 6; i++)
+        {
+            if (CBP&(1 << (5 - i)))
+                (*BlockCodeCoeff)(&(RLB[i]), bs3, 1 - intraDC_decision, ncoefblck[i], Mode);/* Code Intra AC*/
+        }
+    }
+    else
+    {
+        /*temp=*/
+        PutCBPY(CBP >> 2, (Char)(Mode == MODE_INTRA || Mode == MODE_INTRA_Q), bs2); /* cbpy */
+        if (Mode == MODE_INTER_Q)
+            /*  MAY NEED TO CHANGE DQUANT HERE  */
+            BitstreamPutBits(bs2, 2, dquant);  /* dquant, 3/15/01*/
+
+        /****************************/  /* THIRD PART: ALL TO BS3 */
+        for (i = 0; i < 6; i++)
+        {
+            if (CBP&(1 << (5 - i)))
+                (*BlockCodeCoeff)(&(RLB[i]), bs3, 0, ncoefblck[i], Mode);/* Code Intra AC*/
+        }
+    }
+
+    return ;
+}
+#endif /* H263_ONLY */
+/****************************************************************************************/
+/* Short Header/Combined Mode with or without Error Resilience I-VOP and P-VOP Encoding */
+/* 5/21/01, B-VOP is not implemented yet!!!!                                            */
+/****************************************************************************************/
+
+void MBVlcEncodeCombined_I_VOP(
+    VideoEncData *video,
+    Int ncoefblck[],
+    void *blkCodePtr)
+{
+
+    BitstreamEncVideo *bs1 = video->bitstream1;
+//  BitstreamEncVideo *bs2 = video->bitstream2;
+//  BitstreamEncVideo *bs3 = video->bitstream3;
+    int i;
+    UChar Mode = video->headerInfo.Mode[video->mbnum];
+    UChar CBP = video->headerInfo.CBP[video->mbnum];
+//  MacroBlock *MB=video->outputMB;
+    Int mbnum = video->mbnum;
+    Int intraDC_decision;
+//  int temp;
+    Int dquant; /* 3/15/01 */
+    RunLevelBlock *RLB = video->RLB;
+    Int DC;
+    Int shortVideoHeader = video->vol[video->currLayer]->shortVideoHeader;
+    BlockCodeCoeffPtr BlockCodeCoeff = (BlockCodeCoeffPtr) blkCodePtr;
+
+    /* DC and AC Prediction, 5/28/01, compute CBP, intraDC_decision*/
+
+#ifndef H263_ONLY
+    if (!shortVideoHeader)
+        DCACPred(video, Mode, &intraDC_decision, video->QP_prev);
+    else
+#endif
+    {
+        intraDC_decision = 0;
+    }
+
+    /* CBP, Run, Level, and Sign */
+
+    RunLevel(video, 1, intraDC_decision, ncoefblck);
+    CBP = video->headerInfo.CBP[mbnum];
+
+    /* Compute DQuant */
+    dquant = video->QPMB[mbnum] - video->QP_prev; /* 3/15/01, QP_prev may not equal QPMB[mbnum-1] if mbnum-1 is skipped*/
+
+    video->QP_prev = video->QPMB[mbnum];
+
+    if (dquant && Mode == MODE_INTRA)
+    {
+        Mode = MODE_INTRA_Q;
+    }
+
+    if (dquant >= 0)
+        dquant = (PV_ABS(dquant) + 1);
+    else
+        dquant = (PV_ABS(dquant) - 1);
+
+    PutMCBPC_Intra(CBP, Mode, bs1); /* mcbpc I_VOP */
+
+    if (!video->vol[video->currLayer]->shortVideoHeader)
+    {
+        BitstreamPut1Bits(bs1, video->acPredFlag[video->mbnum]);    /* ac_pred_flag */
+    }
+
+    /*temp=*/
+    PutCBPY(CBP >> 2, (Char)(1), bs1); /* cbpy */
+
+    if (Mode == MODE_INTRA_Q)
+        /*  MAY NEED TO CHANGE DQUANT HERE */
+        BitstreamPutBits(bs1, 2, dquant);  /* dquant, 3/15/01*/
+
+    /*MB_CodeCoeff(video,bs1); 5/21/01, replaced by below */
+    /*******************/
+#ifndef H263_ONLY
+    if (shortVideoHeader) /* Short Header DC coefficients */
+    {
+#endif
+        for (i = 0; i < 6; i++)
+        {
+            DC = RLB[i].level[0];
+            if (RLB[i].s[0])
+                DC = -DC;
+            if (DC != 128)
+                BitstreamPutBits(bs1, 8, DC);   /* intra_dc_size_luminance */
+            else
+                BitstreamPutBits(bs1, 8, 255);          /* intra_dc_size_luminance */
+            if (CBP&(1 << (5 - i)))
+                (*BlockCodeCoeff)(&(RLB[i]), bs1, 1, ncoefblck[i], Mode); /* Code short header Intra AC*/
+        }
+#ifndef H263_ONLY
+    }
+    else if (intraDC_decision == 0)   /* Combined Intra Mode DC and AC coefficients */
+    {
+        for (i = 0; i < 6; i++)
+        {
+            DC = RLB[i].level[0];
+            if (RLB[i].s[0])
+                DC = -DC;
+
+            if (i < 4)
+                /*temp =*/ IntraDC_dpcm(DC, 1, bs1);        /* dct_dc_size_luminance, */
+            else                                                /* dct_dc_differential, and */
+                /*temp =*/ IntraDC_dpcm(DC, 0, bs1);        /* marker bit */
+            if (CBP&(1 << (5 - i)))
+                (*BlockCodeCoeff)(&(RLB[i]), bs1, 1, ncoefblck[i], Mode);/* Code Intra AC */
+        }
+    }
+    else   /* Combined Mode Intra DC/AC coefficients */
+    {
+        for (i = 0; i < 6; i++)
+        {
+            if (CBP&(1 << (5 - i)))
+                (*BlockCodeCoeff)(&(RLB[i]), bs1, 0, ncoefblck[i], Mode);/* Code Intra AC */
+        }
+    }
+#endif
+    /*******************/
+    return ;
+}
+
+void MBVlcEncodeCombined_P_VOP(
+    VideoEncData *video,
+    Int ncoefblck[],
+    void *blkCodePtr)
+{
+
+    BitstreamEncVideo *bs1 = video->bitstream1;
+//  BitstreamEncVideo *bs2 = video->bitstream2;
+//  BitstreamEncVideo *bs3 = video->bitstream3;
+    int i;
+    Int mbnum = video->mbnum;
+    UChar Mode = video->headerInfo.Mode[mbnum];
+    Int QP_tmp = video->QPMB[mbnum];
+    UChar CBP ;
+//  MacroBlock *MB=video->outputMB;
+    Int intra, intraDC_decision;
+    Int pmvx, pmvy;
+//  int temp;
+    Int dquant; /* 3/15/01 */
+    RunLevelBlock *RLB = video->RLB;
+    Int DC;
+    Int shortVideoHeader = video->vol[video->currLayer]->shortVideoHeader;
+    BlockCodeCoeffPtr BlockCodeCoeff = (BlockCodeCoeffPtr) blkCodePtr;
+
+    intra = (Mode == MODE_INTRA || Mode == MODE_INTRA_Q);
+
+    /* DC and AC Prediction, 5/28/01, compute intraDC_decision*/
+#ifndef H263_ONLY
+    if (!shortVideoHeader && intra)
+    {
+        if (video->usePrevQP)
+        {
+            QP_tmp = video->QPMB[mbnum-1];
+        }
+        DCACPred(video, Mode, &intraDC_decision, QP_tmp);
+    }
+    else
+#endif
+        intraDC_decision = 0;
+
+    /* CBP, Run, Level, and Sign */
+
+    RunLevel(video, intra, intraDC_decision, ncoefblck);
+    CBP = video->headerInfo.CBP[mbnum];
+
+    /* Compute DQuant */
+    dquant = video->QPMB[mbnum] - video->QP_prev; /* 3/15/01, QP_prev may not equal QPMB[mbnum-1] if mbnum-1 is skipped*/
+    if (dquant && (Mode == MODE_INTRA || Mode == MODE_INTER))
+    {
+        Mode += 2;  /* make it MODE_INTRA_Q and MODE_INTER_Q */
+    }
+
+    if (dquant >= 0)
+        dquant = (PV_ABS(dquant) + 1);
+    else
+        dquant = (PV_ABS(dquant) - 1);
+
+    if (CBP == 0 && intra == 0)  /* Determine if Skipped MB */
+    {
+        if ((Mode == MODE_INTER) && (video->mot[mbnum][0].x == 0) && (video->mot[mbnum][0].y == 0))
+            Mode = video->headerInfo.Mode[video->mbnum] = MODE_SKIPPED;
+        else if ((Mode == MODE_INTER4V) && (video->mot[mbnum][1].x == 0) && (video->mot[mbnum][1].y == 0)
+                 && (video->mot[mbnum][2].x == 0) && (video->mot[mbnum][2].y == 0)
+                 && (video->mot[mbnum][3].x == 0) && (video->mot[mbnum][3].y == 0)
+                 && (video->mot[mbnum][4].x == 0) && (video->mot[mbnum][4].y == 0))
+            Mode = video->headerInfo.Mode[video->mbnum] = MODE_SKIPPED;
+    }
+
+    if (Mode == MODE_SKIPPED)
+    {
+        BitstreamPut1Bits(bs1, 1); /* not_coded = 1 */
+        return;
+    }
+    else
+        BitstreamPut1Bits(bs1, 0); /* not_coded =0 */
+
+    video->QP_prev = video->QPMB[mbnum];
+    video->usePrevQP = 1;
+
+    PutMCBPC_Inter(CBP, Mode, bs1); /* mcbpc P_VOP */
+
+    if (!video->vol[video->currLayer]->shortVideoHeader && intra)
+    {
+        BitstreamPut1Bits(bs1, video->acPredFlag[video->mbnum]);    /* ac_pred_flag */
+    }
+
+    /*temp=*/
+    PutCBPY(CBP >> 2, (Char)(intra), bs1); /* cbpy */
+
+    if (Mode == MODE_INTRA_Q || Mode == MODE_INTER_Q)
+        /*  MAY NEED TO CHANGE DQUANT HERE  */
+        BitstreamPutBits(bs1, 2, dquant);  /* dquant, 3/15/01*/
+
+    video->header_bits -= BitstreamGetPos(bs1); /* Header Bits */
+
+    if (!((video->vol[video->currLayer]->scalability) && (video->currVop->refSelectCode == 3)))
+    {
+        if (Mode == MODE_INTER || Mode == MODE_INTER_Q)
+        {
+            find_pmvs(video, 0, &pmvx, &pmvy); /* Get predicted motion vectors */
+            WriteMVcomponent(video->currVop->fcodeForward, video->mot[mbnum][0].x - pmvx, bs1); /* Write x to bitstream */
+            WriteMVcomponent(video->currVop->fcodeForward, video->mot[mbnum][0].y - pmvy, bs1);     /* Write y to bitstream */
+        }
+        else if (Mode == MODE_INTER4V)
+        {
+            for (i = 1; i < 5; i++)
+            {
+                find_pmvs(video, i, &pmvx, &pmvy);
+                WriteMVcomponent(video->currVop->fcodeForward, video->mot[mbnum][i].x - pmvx, bs1);
+                WriteMVcomponent(video->currVop->fcodeForward, video->mot[mbnum][i].y - pmvy, bs1);
+            }
+        }
+    }
+    video->header_bits += BitstreamGetPos(bs1); /* Header Bits */
+
+    /* MB_CodeCoeff(video,bs1); */ /* 5/22/01, replaced with below */
+    /****************************/
+    if (intra)
+    {
+#ifndef H263_ONLY
+        if (shortVideoHeader) /* Short Header DC coefficients */
+        {
+#endif
+            for (i = 0; i < 6; i++)
+            {
+                DC = RLB[i].level[0];
+                if (RLB[i].s[0])
+                    DC = -DC;
+                if (DC != 128)
+                    BitstreamPutBits(bs1, 8, DC);   /* intra_dc_size_luminance */
+                else
+                    BitstreamPutBits(bs1, 8, 255);          /* intra_dc_size_luminance */
+                if (CBP&(1 << (5 - i)))
+                    (*BlockCodeCoeff)(&(RLB[i]), bs1, 1, ncoefblck[i], Mode); /* Code short header Intra AC*/
+            }
+#ifndef H263_ONLY
+        }
+        else if (intraDC_decision == 0)   /* Combined Intra Mode DC and AC coefficients */
+        {
+            for (i = 0; i < 6; i++)
+            {
+                DC = RLB[i].level[0];
+                if (RLB[i].s[0])
+                    DC = -DC;
+
+                if (i < 4)
+                    /*temp =*/ IntraDC_dpcm(DC, 1, bs1);        /* dct_dc_size_luminance, */
+                else                                                /* dct_dc_differential, and */
+                    /*temp =*/ IntraDC_dpcm(DC, 0, bs1);        /* marker bit */
+                if (CBP&(1 << (5 - i)))
+                    (*BlockCodeCoeff)(&(RLB[i]), bs1, 1, ncoefblck[i], Mode);/* Code Intra AC */
+            }
+        }
+        else   /* Combined Mode Intra DC/AC coefficients */
+        {
+            for (i = 0; i < 6; i++)
+            {
+                if (CBP&(1 << (5 - i)))
+                    (*BlockCodeCoeff)(&(RLB[i]), bs1, 0, ncoefblck[i], Mode);/* Code Intra AC */
+            }
+        }
+#endif
+    }
+    else   /* Shortheader or Combined INTER Mode AC coefficients */
+    {
+        for (i = 0; i < 6; i++)
+        {
+            if (CBP&(1 << (5 - i)))
+                (*BlockCodeCoeff)(&(RLB[i]), bs1, 0, ncoefblck[i], Mode);/* Code Inter AC*/
+        }
+    }
+    /****************************/
+
+    return ;
+}
+
+/* ======================================================================== */
+/*  Function : BlockCodeCoeff()                                         */
+/*  Date     : 09/18/2000                                                   */
+/*  Purpose  : VLC Encode  AC/DC coeffs                                     */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :  5/16/01  grouping BitstreamPutBits calls                    */
+/*              5/22/01  break up function                              */
+/* ======================================================================== */
+#ifndef NO_RVLC
+/*****************/
+/* RVLC ENCODING */
+/*****************/
+Void BlockCodeCoeff_RVLC(RunLevelBlock *RLB, BitstreamEncVideo *bs, Int j_start, Int j_stop, UChar Mode)
+{
+    int length = 0;
+    int i;
+    Int level;
+    Int run;
+    Int intra = (Mode == MODE_INTRA || Mode == MODE_INTRA_Q);
+
+    /* Not Last Coefficient */
+    for (i = j_start; i < j_stop - 1; i++)
+    {
+        run = RLB->run[i];
+        level = RLB->level[i];
+        //if(i==63||RLB->run[i+1] == -1)    /* Don't Code Last Coefficient Here */
+        //  break;
+        /*ENCODE RUN LENGTH */
+        if (level < 28 && run < 39)
+        {
+            if (intra)
+                length = PutCoeff_Intra_RVLC(run, level, bs);
+            else
+                length = PutCoeff_Inter_RVLC(run, level, bs);
+        }
+        else
+            length = 0;
+        /* ESCAPE CODING */
+        if (length == 0)
+        {
+            BitstreamPutBits(bs, 5 + 1, 2); /* ESCAPE + Not Last Coefficient */
+            //BitstreamPutBits(bs,1,0); /* Not Last Coefficient */
+            BitstreamPutBits(bs, 6 + 1, (run << 1) | 1); /* RUN + MARKER BIT*/
+            //BitstreamPutBits(bs,1,1);  /* MARKER BIT */
+            BitstreamPutGT8Bits(bs, 11, level); /* LEVEL */
+            BitstreamPutBits(bs, 1 + 4, 16); /* MARKER BIT */
+            //BitstreamPutBits(bs,4,0);  /* RVLC TRAILING ESCAPE */
+        }
+        BitstreamPutBits(bs, 1, RLB->s[i]); /* SIGN BIT */
+    }
+    /* Last Coefficient!!! */
+    run = RLB->run[i];
+    level = RLB->level[i];
+
+    /*ENCODE RUN LENGTH */
+    if (level < 6 && run < 45)
+    {
+        if (intra)
+            length = PutCoeff_Intra_RVLC_Last(run, level, bs);
+        else
+            length = PutCoeff_Inter_RVLC_Last(run, level, bs);
+    }
+    else
+        length = 0;
+    /* ESCAPE CODING */
+    if (length == 0)
+    {
+        BitstreamPutBits(bs, 5 + 1, 3); /* ESCAPE CODE + Last Coefficient*/
+        //BitstreamPutBits(bs,1,1); /* Last Coefficient !*/
+        BitstreamPutBits(bs, 6 + 1, (run << 1) | 1); /* RUN + MARKER BIT*/
+        //BitstreamPutBits(bs,1,1);  /* MARKER BIT */
+        BitstreamPutGT8Bits(bs, 11, level); /* LEVEL */
+        BitstreamPutBits(bs, 1 + 4, 16); /* MARKER BIT + RVLC TRAILING ESCAPE */
+        //BitstreamPutBits(bs,4,0);  /* */
+    }
+    BitstreamPut1Bits(bs, RLB->s[i]); /* SIGN BIT */
+
+    return ;
+}
+#endif
+/*******************************/
+/* SHORT VIDEO HEADER ENCODING */
+/*******************************/
+
+Void BlockCodeCoeff_ShortHeader(RunLevelBlock *RLB, BitstreamEncVideo *bs, Int j_start, Int j_stop, UChar Mode)
+{
+    int length = 0;
+    int i;
+//  int temp;
+    Int level;
+    Int run;
+
+    OSCL_UNUSED_ARG(Mode);
+
+    /* Not Last Coefficient */
+    for (i = j_start; i < j_stop - 1; i++)
+    {
+        run = RLB->run[i];
+        level = RLB->level[i];
+//      if(i==63 ||RLB->run[i+1] == -1) /* Don't Code Last Coefficient Here */
+//          break;
+        /*ENCODE RUN LENGTH */
+        if (level < 13)
+        {
+            length = PutCoeff_Inter(run, level, bs);
+            if (length != 0)
+                /*temp =*/ BitstreamPut1Bits(bs, RLB->s[i]); /* Sign Bit */
+        }
+        else
+            length = 0;
+        /* ESCAPE CODING */
+        if (length == 0)
+        {
+            if (RLB->s[i])
+                level = -level;
+            BitstreamPutBits(bs, 7 + 1, 6); /* ESCAPE CODE + Not Last Coefficient */
+            //BitstreamPutBits(bs,1,0); /* Not Last Coefficient */
+            BitstreamPutBits(bs, 6, run); /* RUN */
+            BitstreamPutBits(bs, 8, level&0xFF); /* LEVEL, mask to make sure length 8 */
+        }
+    }
+    /* Last Coefficient!!! */
+    run = RLB->run[i];
+    level = RLB->level[i];
+
+    /*ENCODE RUN LENGTH */
+    if (level < 13)
+    {
+        length = PutCoeff_Inter_Last(run, level, bs);
+        if (length != 0)
+            /*temp =*/ BitstreamPut1Bits(bs, RLB->s[i]); /* Sign Bit */
+    }
+    else
+        length = 0;
+    /* ESCAPE CODING */
+    if (length == 0)
+    {
+        if (RLB->s[i])
+            level = -level;
+        BitstreamPutBits(bs, 7 + 1, 7); /* ESCAPE CODE + Last Coefficient */
+        //BitstreamPutBits(bs,1,1); /* Last Coefficient !!!*/
+        BitstreamPutBits(bs, 6, run); /* RUN */
+        BitstreamPutBits(bs, 8, level&0xFF); /* LEVEL, mask to make sure length 8  */
+    }
+
+    return ;
+
+}
+
+#ifndef H263_ONLY
+/****************/
+/* VLC ENCODING */
+/****************/
+Void BlockCodeCoeff_Normal(RunLevelBlock *RLB, BitstreamEncVideo *bs, Int j_start, Int j_stop, UChar Mode)
+{
+    int length = 0;
+    int i;
+    //int temp;
+    Int level;
+    Int run;
+    Int intra = (Mode == MODE_INTRA || Mode == MODE_INTRA_Q);
+    Int level_minus_max;
+    Int run_minus_max;
+    Int(*PutCoeff)(Int, Int, BitstreamEncVideo *); /* pointer to functions, 5/28/01 */
+
+    /* Not Last Coefficient!!! */
+
+    if (intra)
+        PutCoeff = &PutCoeff_Intra;
+    else
+        PutCoeff = &PutCoeff_Inter;
+
+    for (i = j_start; i < j_stop - 1; i++)
+    {
+        run = RLB->run[i];
+        level = RLB->level[i];
+
+        /* Encode Run Length */
+        if (level < 28)
+        {
+            length = (*PutCoeff)(run, level, bs); /* 5/28/01 replaces above */
+        }
+        else
+        {
+            length = 0;
+        }
+
+        /* First escape mode: LEVEL OFFSET */
+        if (length == 0)
+        {
+            if (intra)
+            {
+                level_minus_max = level - intra_max_level[0][run];
+                if (level_minus_max < 28)
+                    length = PutLevelCoeff_Intra(run, level_minus_max, bs);
+                else
+                    length = 0;
+            }
+            else
+            {
+                level_minus_max = level - inter_max_level[0][run];
+                if (level_minus_max < 13)
+                    length = PutLevelCoeff_Inter(run, level_minus_max, bs);
+                else
+                    length = 0;
+            }
+
+            /* Second escape mode: RUN OFFSET */
+            if (length == 0)
+            {
+                if (level < 28)
+                {
+                    if (intra)
+                    {
+                        run_minus_max = run - (intra_max_run0[level] + 1);
+                        length = PutRunCoeff_Intra(run_minus_max, level, bs);
+                    }
+                    else if (level < 13)
+                    {
+                        run_minus_max = run - (inter_max_run0[level] + 1);
+                        length = PutRunCoeff_Inter(run_minus_max, level, bs);
+                    }
+                    else
+                    {
+                        length = 0;
+                    }
+                }
+                else
+                {
+                    length = 0;
+                }
+
+                /* Third escape mode: FIXED LENGTH CODE */
+                if (length == 0)
+                {
+                    if (RLB->s[i])
+                        level = -level;
+                    /*temp =*/
+                    BitstreamPutBits(bs, 7 + 2 + 1, 30); /* ESCAPE CODE + Followed by 11 + Not Last Coefficient*/
+                    //temp = BitstreamPutBits(bs,2,3); /* Followed by 11 */
+                    //temp = BitstreamPutBits(bs, 1, 0); /* Not Last Coefficient*/
+                    /*temp =*/
+                    BitstreamPutBits(bs, 6 + 1, (run << 1) | 1); /* Encode Run + Marker Bit */
+                    //temp = BitstreamPutBits(bs,1,1); /* Marker Bit */
+                    /*temp =*/
+                    BitstreamPutGT8Bits(bs, 12 + 1, ((level << 1) | 1)&0x1FFF); /* Encode Level, mask to make sure length 12  */
+                    //temp = BitstreamPutBits(bs,1,1); /* Marker Bit */
+                }
+            }
+        }
+
+        /* Encode Sign Bit */
+        if (length != 0)
+            /*temp =*/ BitstreamPut1Bits(bs, RLB->s[i]); /* Sign Bit */
+
+    }
+    /* Last Coefficient */
+    run = RLB->run[i];
+    level = RLB->level[i];
+
+    /* Encode Run Length */
+    if (level < 9)
+    {
+        if (intra)
+        {
+            length = PutCoeff_Intra_Last(run, level, bs);
+        }
+        else if (level < 4)
+        {
+            length = PutCoeff_Inter_Last(run, level, bs);
+        }
+        else
+        {
+            length = 0;
+        }
+    }
+    else
+    {
+        length = 0;
+    }
+
+    /* First escape mode: LEVEL OFFSET */
+    if (length == 0)
+    {
+        if (intra)
+        {
+            level_minus_max = level - intra_max_level[1][run];
+            if (level_minus_max < 9)
+                length = PutLevelCoeff_Intra_Last(run, level_minus_max, bs);
+            else
+                length = 0;
+        }
+        else
+        {
+            level_minus_max = level - inter_max_level[1][run];
+            if (level_minus_max < 4)
+                length = PutLevelCoeff_Inter_Last(run, level_minus_max, bs);
+            else
+                length = 0;
+        }
+        /* Second escape mode: RUN OFFSET */
+        if (length == 0)
+        {
+            if (level < 9)
+            {
+                if (intra)
+                {
+                    run_minus_max = run - (intra_max_run1[level] + 1);
+                    length = PutRunCoeff_Intra_Last(run_minus_max, level, bs);
+                }
+                else if (level < 4)
+                {
+                    run_minus_max = run - (inter_max_run1[level] + 1);
+                    length = PutRunCoeff_Inter_Last(run_minus_max, level, bs);
+                }
+                else
+                {
+                    length = 0;
+                }
+            }
+            else
+            {
+                length = 0;
+            }
+            /* Third escape mode: FIXED LENGTH CODE */
+            if (length == 0)
+            {
+                if (RLB->s[i])
+                    level = -level;
+                /*temp =*/
+                BitstreamPutGT8Bits(bs, 7 + 2 + 1, 31); /* ESCAPE CODE + Followed by 11 + Last Coefficient*/
+                //temp = BitstreamPutBits(bs,2,3); /* Followed by 11 */
+                //temp = BitstreamPutBits(bs, 1, 1); /* Last Coefficient!!!*/
+                /*temp =*/
+                BitstreamPutBits(bs, 6 + 1, (run << 1) | 1); /* Encode Run + Marker Bit */
+                //temp = BitstreamPutBits(bs,1,1); /* Marker Bit */
+                /*temp =*/
+                BitstreamPutGT8Bits(bs, 12 + 1, ((level << 1) | 1)&0x1FFF); /* Encode Level, mask to make sure length 8 */
+                //temp = BitstreamPutBits(bs,1,1); /* Marker Bit */
+            }
+        }
+    }
+
+    /* Encode Sign Bit */
+    if (length != 0)
+        /*temp =*/ BitstreamPut1Bits(bs, RLB->s[i]);
+
+
+    return ;
+}
+
+#endif /* H263_ONLY */
+/* ======================================================================== */
+/*  Function : RUNLevel                                                     */
+/*  Date     : 09/20/2000                                                   */
+/*  Purpose  : Get the Coded Block Pattern for each block                   */
+/*  In/out   :                                                              */
+/*      Int* qcoeff     Quantized DCT coefficients
+        Int Mode        Coding Mode
+        Int ncoeffs     Number of coefficients                              */
+/*  Return   :                                                              */
+/*      Int CBP         Coded Block Pattern                                 */
+/*  Modified :                                                              */
+/* ======================================================================== */
+
+void RunLevel(VideoEncData *video, Int intra, Int intraDC_decision, Int ncoefblck[])
+{
+    Int i, j;
+    Int CBP = video->headerInfo.CBP[video->mbnum];
+    Int ShortNacNintra = (!(video->vol[video->currLayer]->shortVideoHeader) && video->acPredFlag[video->mbnum] && intra);
+    MacroBlock *MB = video->outputMB;
+    Short *dataBlock;
+    Int level;
+    RunLevelBlock *RLB;
+    Int run, idx;
+    Int *zz, nc, zzorder;
+    UChar imask[6] = {0x1F, 0x2F, 0x37, 0x3B, 0x3D, 0x3E};
+    UInt *bitmapzz;
+
+    /* Set Run, Level and CBP for this Macroblock */
+    /* ZZ scan is done here.  */
+
+    if (intra)
+    {
+
+        if (intraDC_decision != 0)
+            intra = 0;              /* DC/AC in Run/Level */
+
+        for (i = 0; i < 6 ; i++)
+        {
+
+            zz = (Int *) zigzag_inv;
+
+            RLB = video->RLB + i;
+
+            dataBlock = MB->block[i];
+
+            if (intra)
+            {
+                RLB->run[0] = 0;
+                level = dataBlock[0];
+                dataBlock[0] = 0; /* reset to zero */
+                if (level < 0)
+                {
+                    RLB->level[0] = -level;
+                    RLB->s[0] = 1;
+                }
+                else
+                {
+                    RLB->level[0] = level;
+                    RLB->s[0] = 0;
+                }
+            }
+
+            idx = intra;
+
+            if ((CBP >> (5 - i)) & 1)
+            {
+                if (ShortNacNintra)
+                {
+                    switch ((video->zz_direction >> (5 - i))&1)
+                    {
+                        case 0:
+                            zz = (Int *)zigzag_v_inv;
+                            break;
+                        case 1:
+                            zz = (Int *)zigzag_h_inv;
+                            break;
+                    }
+                }
+                run = 0;
+                nc = ncoefblck[i];
+                for (j = intra, zz += intra; j < nc; j++, zz++)
+                {
+                    zzorder = *zz;
+                    level = dataBlock[zzorder];
+                    if (level == 0)
+                        run++;
+                    else
+                    {
+                        dataBlock[zzorder] = 0; /* reset output */
+                        if (level < 0)
+                        {
+                            RLB->level[idx] = -level;
+                            RLB->s[idx] = 1;
+                            RLB->run[idx] = run;
+                            run = 0;
+                            idx++;
+                        }
+                        else
+                        {
+                            RLB->level[idx] = level;
+                            RLB->s[idx] = 0;
+                            RLB->run[idx] = run;
+                            run = 0;
+                            idx++;
+                        }
+                    }
+                }
+            }
+
+            ncoefblck[i] = idx; /* 5/22/01, reuse ncoefblck */
+
+            if (idx == intra) /* reset CBP, nothing to be coded */
+                CBP &= imask[i];
+        }
+
+        video->headerInfo.CBP[video->mbnum] = CBP;
+
+        return ;
+    }
+    else
+    {
+//      zz = (Int *) zigzag_inv;  no need to use it, default
+
+        if (CBP)
+        {
+            for (i = 0; i < 6 ; i++)
+            {
+                RLB = video->RLB + i;
+                idx = 0;
+
+                if ((CBP >> (5 - i)) & 1)
+                {   /* 7/30/01 */
+                    /* Use bitmapzz to find the Run,Level,Sign symbols */
+                    bitmapzz = video->bitmapzz[i];
+                    dataBlock = MB->block[i];
+                    nc  = ncoefblck[i];
+
+                    idx = zero_run_search(bitmapzz, dataBlock, RLB, nc);
+                }
+                ncoefblck[i] = idx; /* 5/22/01, reuse ncoefblck */
+                if (idx == 0) /* reset CBP, nothing to be coded */
+                    CBP &= imask[i];
+            }
+            video->headerInfo.CBP[video->mbnum] = CBP;
+        }
+        return ;
+    }
+}
+
+#ifndef H263_ONLY
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+    static Bool IntraDCSwitch_Decision(Int Mode, Int intra_dc_vlc_thr, Int intraDCVlcQP)
+    {
+        Bool switched = FALSE;
+
+        if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q)
+        {
+            if (intra_dc_vlc_thr != 0)
+            {
+                switched = (intra_dc_vlc_thr == 7 || intraDCVlcQP >= intra_dc_vlc_thr * 2 + 11);
+            }
+        }
+
+        return switched;
+    }
+#ifdef __cplusplus
+}
+#endif
+
+Int IntraDC_dpcm(Int val, Int lum, BitstreamEncVideo *bitstream)
+{
+    Int n_bits;
+    Int absval, size = 0;
+
+    absval = (val < 0) ? -val : val;    /* abs(val) */
+
+
+    /* compute dct_dc_size */
+
+    size = 0;
+    while (absval)
+    {
+        absval >>= 1;
+        size++;
+    }
+
+    if (lum)
+    {   /* luminance */
+        n_bits = PutDCsize_lum(size, bitstream);
+    }
+    else
+    {   /* chrominance */
+        n_bits = PutDCsize_chrom(size, bitstream);
+    }
+
+    if (size != 0)
+    {
+        if (val >= 0)
+        {
+            ;
+        }
+        else
+        {
+            absval = -val; /* set to "-val" MW 14-NOV-1996 */
+            val = absval ^((1 << size) - 1);
+        }
+        BitstreamPutBits(bitstream, (size), (UInt)(val));
+        n_bits += size;
+
+        if (size > 8)
+            BitstreamPut1Bits(bitstream, 1);
+    }
+
+    return n_bits;  /* # bits for intra_dc dpcm */
+
+}
+
+/* ======================================================================== */
+/*  Function : DC_AC_PRED                                                   */
+/*  Date     : 09/24/2000                                                   */
+/*  Purpose  : DC and AC encoding of Intra Blocks                           */
+/*  In/out   :                                                              */
+/*      VideoEncData    *video
+        UChar           Mode                                                */
+/*  Return   :                                                              */
+/*                                                                          */
+/* ======================================================================== */
+Int cal_dc_scalerENC(Int QP, Int type) ;
+
+
+#define PREDICT_AC  for (m = 0; m < 7; m++){ \
+                        tmp = DCAC[0]*QPtmp;\
+                        if(tmp<0)   tmp = (tmp-(QP/2))/QP;\
+                        else        tmp = (tmp+(QP/2))/QP;\
+                        pred[m] = tmp;\
+                        DCAC++;\
+                    }
+
+
+Void DCACPred(VideoEncData *video, UChar Mode, Int *intraDC_decision, Int intraDCVlcQP)
+{
+    MacroBlock *MB = video->outputMB;
+    Int mbnum = video->mbnum;
+    typeDCStore *DC_store = video->predDC + mbnum;
+    typeDCACStore *DCAC_row = video->predDCAC_row;
+    typeDCACStore *DCAC_col = video->predDCAC_col;
+    Short   *DCAC;
+    UChar Mode_top, Mode_left;
+
+    Vol *currVol = video->vol[video->currLayer];
+    Int nMBPerRow = currVol->nMBPerRow;
+    Int x_pos = video->outputMB->mb_x; /* 5/28/01 */
+    Int y_pos = video->outputMB->mb_y;
+    UChar QP = video->QPMB[mbnum];
+    UChar *QPMB = video->QPMB;
+    UChar *slice_nb = video->sliceNo;
+    Bool bACPredEnable = video->encParams->ACDCPrediction;
+    Int *ACpred_flag = video->acPredFlag;
+    Int mid_grey = 128 << 3;
+    Int m;
+    Int comp;
+    Int dc_scale = 8, tmp;
+
+    static const Int Xpos[6] = { -1, 0, -1, 0, -1, -1};
+    static const Int Ypos[6] = { -1, -1, 0, 0, -1, -1};
+    static const Int Xtab[6] = {1, 0, 3, 2, 4, 5};
+    static const Int Ytab[6] = {2, 3, 0, 1, 4, 5};
+    static const Int Ztab[6] = {3, 2, 1, 0, 4, 5};
+
+    /* I added these to speed up comparisons */
+    static const Int Pos0[6] = { 1, 1, 0, 0, 1, 1};
+    static const Int Pos1[6] = { 1, 0, 1, 0, 1, 1};
+    static const Int B_Xtab[6] = {0, 1, 0, 1, 2, 3};
+    static const Int B_Ytab[6] = {0, 0, 1, 1, 2, 3};
+
+    Int direction[6];       /* 0: HORIZONTAL, 1: VERTICAL */
+    Int block_A, block_B, block_C;
+    Int grad_hor, grad_ver, DC_pred;
+    Short pred[7], *predptr;
+    Short pcoeff[42];
+    Short *qcoeff;
+    Int S = 0, S1, S2;
+    Int diff, QPtmp;
+    Int newCBP[6];
+    UChar mask1[6] = {0x20, 0x10, 0x8, 0x4, 0x2, 0x1};
+//  UChar mask2[6] = {0x1f,0x2f,0x37,0x3b,0x3d,0x3e};
+
+    Int y_offset, x_offset, x_tab, y_tab, z_tab;    /* speedup coefficients */
+    Int b_xtab, b_ytab;
+
+    video->zz_direction = 0;
+
+    /* Standard MPEG-4 Headers do DC/AC prediction*/
+    /* check whether neighbors are INTER */
+    if (y_pos > 0)
+    {
+        Mode_top = video->headerInfo.Mode[mbnum-nMBPerRow];
+        if (!(Mode_top == MODE_INTRA || Mode_top == MODE_INTRA_Q))
+        {
+            DCAC = DC_store[-nMBPerRow];
+            *DCAC++ = mid_grey;
+            *DCAC++ = mid_grey;
+            *DCAC++ = mid_grey;
+            *DCAC++ = mid_grey;
+            *DCAC++ = mid_grey;
+            *DCAC++ = mid_grey;
+            /* set to 0 DCAC_row[x_pos][0..3] */
+            if (bACPredEnable == TRUE)
+            {
+                M4VENC_MEMSET(DCAC_row[x_pos][0], 0, sizeof(Short) << 5);
+            }
+        }
+    }
+    if (x_pos > 0)
+    {
+        Mode_left = video->headerInfo.Mode[mbnum-1];
+        if (!(Mode_left == MODE_INTRA || Mode_left == MODE_INTRA_Q))
+        {
+            DCAC = DC_store[-1];
+            *DCAC++ = mid_grey;
+            *DCAC++ = mid_grey;
+            *DCAC++ = mid_grey;
+            *DCAC++ = mid_grey;
+            *DCAC++ = mid_grey;
+            *DCAC++ = mid_grey;
+            /* set to 0 DCAC_col[x_pos][0..3] */
+            if (bACPredEnable == TRUE)
+            {
+                M4VENC_MEMSET(DCAC_col[0][0], 0, sizeof(Short) << 5);
+            }
+        }
+    }
+
+    S1 = 0;
+    S2 = 0;
+
+    for (comp = 0; comp < 6; comp++)
+    {
+
+        if (Ypos[comp] != 0)        y_offset = -nMBPerRow;
+        else                    y_offset = 0;
+        x_offset = Xpos[comp];
+        x_tab = Xtab[comp];
+        y_tab = Ytab[comp];
+        z_tab = Ztab[comp];
+
+        b_xtab = B_Xtab[comp];
+        b_ytab = B_Ytab[comp];
+
+        qcoeff = MB->block[comp];
+
+        /****************************/
+        /*  Store DC coefficients */
+        /****************************/
+        /* Store coeff values for Intra MB */
+        if (comp == 0) dc_scale = cal_dc_scalerENC(QP, 1) ;
+        if (comp == 4) dc_scale = cal_dc_scalerENC(QP, 2) ;
+
+        QPtmp = qcoeff[0] * dc_scale; /* DC value */
+
+        if (QPtmp > 2047)   /* 10/10/01, add clipping (bug fixed) */
+            DC_store[0][comp] = 2047;
+        else if (QPtmp < -2048)
+            DC_store[0][comp] = -2048;
+        else
+            DC_store[0][comp] = QPtmp;
+
+        /**************************************************************/
+        /* Find the direction of the prediction and the DC prediction */
+        /**************************************************************/
+
+        if ((x_pos == 0) && y_pos == 0)
+        {   /* top left corner */
+            block_A = (comp == 1 || comp == 3) ? DC_store[0][x_tab] : mid_grey;
+            block_B = (comp == 3) ? DC_store[x_offset][z_tab] : mid_grey;
+            block_C = (comp == 2 || comp == 3) ? DC_store[0][y_tab] : mid_grey;
+        }
+        else if (x_pos == 0)
+        {   /* left edge */
+            block_A = (comp == 1 || comp == 3) ? DC_store[0][x_tab] : mid_grey;
+            block_B = ((comp == 1 && (slice_nb[mbnum] == slice_nb[mbnum-nMBPerRow])) || comp == 3) ?
+                      DC_store[y_offset+x_offset][z_tab] : mid_grey;
+            block_C = (comp == 2 || comp == 3 ||
+                       (Pos0[comp] && (slice_nb[mbnum] == slice_nb[mbnum-nMBPerRow]))) ?
+                      DC_store[y_offset][y_tab] : mid_grey;
+        }
+        else if (y_pos == 0)
+        { /* top row */
+            block_A = (comp == 1 || comp == 3 || (Pos1[comp] && (slice_nb[mbnum] == slice_nb[mbnum-1]))) ?
+                      DC_store[x_offset][x_tab] : mid_grey;
+            block_B = ((comp == 2 && (slice_nb[mbnum] == slice_nb[mbnum-1])) || comp == 3) ?
+                      DC_store[y_offset + x_offset][z_tab] : mid_grey;
+            block_C = (comp == 2 || comp == 3) ?
+                      DC_store[y_offset][y_tab] : mid_grey;
+        }
+        else
+        {
+            block_A = (comp == 1 || comp == 3 || (Pos1[comp] && (slice_nb[mbnum] == slice_nb[mbnum-1]))) ?
+                      DC_store[x_offset][x_tab] : mid_grey;
+            block_B = (((comp == 0 || comp == 4 || comp == 5) &&
+                        (slice_nb[mbnum] == slice_nb[mbnum-1-nMBPerRow])) ||
+                       (comp == 1 && (slice_nb[mbnum] == slice_nb[mbnum-nMBPerRow])) ||
+                       (comp == 2 && (slice_nb[mbnum] == slice_nb[mbnum-1])) || (comp == 3)) ?
+                      (DC_store[y_offset + x_offset][z_tab]) : mid_grey;
+            block_C = (comp == 2 || comp == 3 || (Pos0[comp] && (slice_nb[mbnum] == slice_nb[mbnum-nMBPerRow]))) ?
+                      DC_store[y_offset][y_tab] : mid_grey;
+        }
+        grad_hor = block_B - block_C;
+        grad_ver = block_A - block_B;
+
+        if ((PV_ABS(grad_ver)) < (PV_ABS(grad_hor)))
+        {
+            DC_pred = block_C;
+            direction[comp] = 1;
+            video->zz_direction = (video->zz_direction) | mask1[comp];
+
+        }
+        else
+        {
+            DC_pred = block_A;
+            direction[comp] = 0;
+            //video->zz_direction=video->zz_direction<<1;
+        }
+
+        /* DC prediction */
+        QPtmp = dc_scale; /* 5/28/01 */
+        qcoeff[0] -= (DC_pred + QPtmp / 2) / QPtmp;
+
+
+        if (bACPredEnable)
+        {
+            /***********************/
+            /* Find AC prediction  */
+            /***********************/
+
+            if ((x_pos == 0) && y_pos == 0)     /* top left corner */
+            {
+                if (direction[comp] == 0)
+                {
+                    if (comp == 1 || comp == 3)
+                    {
+                        QPtmp = QPMB[mbnum+x_offset];
+                        DCAC = DCAC_col[0][b_ytab];
+                        if (QPtmp != QP)
+                        {
+                            predptr = pred;
+                            PREDICT_AC
+                        }
+                        else
+                        {
+                            predptr = DCAC;
+                        }
+                    }
+                    else
+                    {
+                        predptr = pred;
+                        pred[0] = pred[1] = pred[2] = pred[3] = pred[4] = pred[5] = pred[6] = 0;
+                    }
+                }
+                else
+                {
+                    if (comp == 2 || comp == 3)
+                    {
+                        QPtmp = QPMB[mbnum+ y_offset];
+                        DCAC = DCAC_row[x_pos][b_xtab];
+                        if (QPtmp != QP)
+                        {
+                            predptr = pred;
+                            PREDICT_AC
+                        }
+                        else
+                        {
+                            predptr = DCAC;
+                        }
+                    }
+                    else
+                    {
+                        predptr = pred;
+                        pred[0] = pred[1] = pred[2] = pred[3] = pred[4] = pred[5] = pred[6] = 0;
+                    }
+                }
+            }
+            else if (x_pos == 0)    /* left edge */
+            {
+                if (direction[comp] == 0)
+                {
+                    if (comp == 1 || comp == 3)
+                    {
+                        QPtmp = QPMB[mbnum+x_offset];
+                        DCAC = DCAC_col[0][b_ytab];
+                        if (QPtmp != QP)
+                        {
+                            predptr = pred;
+                            PREDICT_AC
+                        }
+                        else
+                        {
+                            predptr = DCAC;
+                        }
+                    }
+                    else
+                    {
+                        predptr = pred;
+                        pred[0] = pred[1] = pred[2] = pred[3] = pred[4] = pred[5] = pred[6] = 0;
+                    }
+                }
+                else
+                {
+
+                    if ((Pos0[comp] && (slice_nb[mbnum] == slice_nb[mbnum-nMBPerRow]))
+                            || comp == 2 || comp == 3)
+                    {
+                        QPtmp = QPMB[mbnum+y_offset];
+                        DCAC = DCAC_row[x_pos][b_xtab];
+                        if (QPtmp != QP)
+                        {
+                            predptr = pred;
+                            PREDICT_AC
+                        }
+                        else
+                        {
+                            predptr = DCAC;
+                        }
+                    }
+                    else
+                    {
+                        predptr = pred;
+                        pred[0] = pred[1] = pred[2] = pred[3] = pred[4] = pred[5] = pred[6] = 0;
+                    }
+                }
+            }
+            else if (y_pos == 0)  /* top row */
+            {
+                if (direction[comp] == 0)
+                {
+                    if ((Pos1[comp] && (slice_nb[mbnum] == slice_nb[mbnum-1]))
+                            || comp == 1 || comp == 3)
+                    {
+                        QPtmp = QPMB[mbnum+x_offset];
+                        DCAC = DCAC_col[0][b_ytab];
+                        if (QPtmp != QP)
+                        {
+                            predptr = pred;
+                            PREDICT_AC
+                        }
+                        else
+                        {
+                            predptr = DCAC;
+                        }
+                    }
+                    else
+                    {
+                        predptr = pred;
+                        pred[0] = pred[1] = pred[2] = pred[3] = pred[4] = pred[5] = pred[6] = 0;
+                    }
+                }
+                else
+                {
+                    if (comp == 2 || comp == 3)
+                    {
+                        QPtmp = QPMB[mbnum+y_offset];
+                        DCAC = DCAC_row[x_pos][b_xtab];
+                        if (QPtmp != QP)
+                        {
+                            predptr = pred;
+                            PREDICT_AC
+                        }
+                        else
+                        {
+                            predptr = DCAC;
+                        }
+                    }
+                    else
+                    {
+                        predptr = pred;
+                        pred[0] = pred[1] = pred[2] = pred[3] = pred[4] = pred[5] = pred[6] = 0;
+                    }
+                }
+            }
+            else
+            {
+                if (direction[comp] == 0)
+                {
+                    if ((Pos1[comp] && (slice_nb[mbnum] == slice_nb[mbnum-1]))
+                            || comp == 1 || comp == 3)
+                    {
+                        QPtmp = QPMB[mbnum+x_offset];
+                        DCAC = DCAC_col[0][b_ytab];
+                        if (QPtmp != QP)
+                        {
+                            predptr = pred;
+                            PREDICT_AC
+                        }
+                        else
+                        {
+                            predptr = DCAC;
+                        }
+                    }
+                    else
+                    {
+                        predptr = pred;
+                        pred[0] = pred[1] = pred[2] = pred[3] = pred[4] = pred[5] = pred[6] = 0;
+                    }
+                }
+                else
+                {
+                    if ((Pos0[comp] && (slice_nb[mbnum] == slice_nb[mbnum-nMBPerRow]))
+                            || comp  == 2 || comp == 3)
+                    {
+                        QPtmp = QPMB[mbnum+y_offset];
+                        DCAC = DCAC_row[x_pos][b_xtab];
+                        if (QPtmp != QP)
+                        {
+                            predptr = pred;
+                            PREDICT_AC
+                        }
+                        else
+                        {
+                            predptr = DCAC;
+                        }
+                    }
+                    else
+                    {
+                        predptr = pred;
+                        pred[0] = pred[1] = pred[2] = pred[3] = pred[4] = pred[5] = pred[6] = 0;
+                    }
+                }
+            }
+
+            /************************************/
+            /* Decide and Perform AC prediction */
+            /************************************/
+            newCBP[comp] = 0;
+
+            if (direction[comp] == 0)   /* Horizontal, left COLUMN of block A */
+            {
+                DCAC = pcoeff + comp * 7; /* re-use DCAC as local var */
+                qcoeff += 8;
+                for (m = 0; m < 7; m++)
+                {
+                    QPtmp = qcoeff[m<<3];
+                    if (QPtmp > 0)  S1 += QPtmp;
+                    else        S1 -= QPtmp;
+                    QPtmp -= predptr[m];
+                    DCAC[m] = QPtmp; /* save prediction residue to pcoeff*/
+                    if (QPtmp)  newCBP[comp] = 1;
+                    diff = PV_ABS(QPtmp);
+                    S2 += diff;
+                }
+            }
+            else            /* Vertical, top ROW of block C */
+            {
+                qcoeff++;
+                DCAC = pcoeff + comp * 7; /* re-use DCAC as local var */
+                for (m = 0; m < 7; m++)
+                {
+                    QPtmp = qcoeff[m];
+                    if (QPtmp > 0)  S1 += QPtmp;
+                    else        S1 -= QPtmp;
+                    QPtmp -= predptr[m];
+                    DCAC[m] = QPtmp; /* save prediction residue to pcoeff*/
+                    if (QPtmp)  newCBP[comp] = 1;
+                    diff = PV_ABS(QPtmp);
+                    S2 += diff;
+                }
+            }
+
+            /****************************/
+            /*  Store DCAC coefficients */
+            /****************************/
+            /* Store coeff values for Intra MB */
+            qcoeff = MB->block[comp];
+            DCAC = DCAC_row[x_pos][b_xtab];
+            DCAC[0] = qcoeff[1];
+            DCAC[1] = qcoeff[2];
+            DCAC[2] = qcoeff[3];
+            DCAC[3] = qcoeff[4];
+            DCAC[4] = qcoeff[5];
+            DCAC[5] = qcoeff[6];
+            DCAC[6] = qcoeff[7];
+
+            DCAC = DCAC_col[0][b_ytab];
+            DCAC[0] = qcoeff[8];
+            DCAC[1] = qcoeff[16];
+            DCAC[2] = qcoeff[24];
+            DCAC[3] = qcoeff[32];
+            DCAC[4] = qcoeff[40];
+            DCAC[5] = qcoeff[48];
+            DCAC[6] = qcoeff[56];
+
+
+        } /* bACPredEnable */
+
+    } /* END COMP FOR LOOP */
+
+    //if (diff > 2047)
+    //    break;
+    S += (S1 - S2);
+
+
+    if (S >= 0 && bACPredEnable == TRUE)
+    {
+        ACpred_flag[mbnum] = 1;
+        DCAC = pcoeff; /* prediction residue */
+        qcoeff = MB->block[0];
+
+        for (comp = 0; comp < 6; comp++)
+        {
+            if (direction[comp] == 0)
+            {
+                qcoeff[8] = DCAC[0];
+                qcoeff[16] = DCAC[1];
+                qcoeff[24] = DCAC[2];
+                qcoeff[32] = DCAC[3];
+                qcoeff[40] = DCAC[4];
+                qcoeff[48] = DCAC[5];
+                qcoeff[56] = DCAC[6];
+
+            }
+            else
+            {
+                qcoeff[1] = DCAC[0];
+                qcoeff[2] = DCAC[1];
+                qcoeff[3] = DCAC[2];
+                qcoeff[4] = DCAC[3];
+                qcoeff[5] = DCAC[4];
+                qcoeff[6] = DCAC[5];
+                qcoeff[7] = DCAC[6];
+            }
+            if (newCBP[comp]) /* 5/28/01, update CBP */
+                video->headerInfo.CBP[mbnum] |= mask1[comp];
+            DCAC += 7;
+            qcoeff += 64;
+        }
+    }
+    else  /* Only DC Prediction */
+    {
+        ACpred_flag[mbnum] = 0;
+    }
+
+    *intraDC_decision = IntraDCSwitch_Decision(Mode, video->currVop->intraDCVlcThr, intraDCVlcQP);
+    if (*intraDC_decision) /* code DC with AC , 5/28/01*/
+    {
+        qcoeff = MB->block[0];
+        for (comp = 0; comp < 6; comp++)
+        {
+            if (*qcoeff)
+                video->headerInfo.CBP[mbnum] |= mask1[comp];
+            qcoeff += 64;
+        }
+    }
+    return;
+}
+#endif /* H263_ONLY */
+
+
+
+Void find_pmvs(VideoEncData *video, Int block, Int *mvx, Int *mvy)
+{
+    Vol *currVol = video->vol[video->currLayer];
+//  UChar *Mode = video->headerInfo.Mode; /* modes for MBs */
+    UChar *slice_nb = video->sliceNo;
+    Int nMBPerRow = currVol->nMBPerRow;
+    Int mbnum = video->mbnum;
+
+    Int   p1x, p2x, p3x;
+    Int   p1y, p2y, p3y;
+    Int   xin1, xin2, xin3;
+    Int   yin1, yin2, yin3;
+    Int   vec1, vec2, vec3;
+    Int   rule1, rule2, rule3;
+    MOT   **motdata = video->mot;
+    Int   x = mbnum % nMBPerRow;
+    Int   y = mbnum / nMBPerRow;
+
+    /*
+        In a previous version, a MB vector (block = 0) was predicted the same way
+        as block 1, which is the most likely interpretation of the VM.
+
+        Therefore, if we have advanced pred. mode, and if all MBs around have
+        only one 16x16 vector each, we chose the appropiate block as if these
+        MBs have 4 vectors.
+
+        This different prediction affects only 16x16 vectors of MBs with
+        transparent blocks.
+
+        In the current version, we choose for the 16x16 mode the first
+        non-transparent block in the surrounding MBs
+    */
+
+    switch (block)
+    {
+        case 0:
+            vec1 = 2 ;
+            yin1 = y  ;
+            xin1 = x - 1;
+            vec2 = 3 ;
+            yin2 = y - 1;
+            xin2 = x;
+            vec3 = 3 ;
+            yin3 = y - 1;
+            xin3 = x + 1;
+            break;
+
+        case 1:
+            vec1 = 2 ;
+            yin1 = y  ;
+            xin1 = x - 1;
+            vec2 = 3 ;
+            yin2 = y - 1;
+            xin2 = x;
+            vec3 = 3 ;
+            yin3 = y - 1;
+            xin3 = x + 1;
+            break;
+
+        case 2:
+            vec1 = 1 ;
+            yin1 = y  ;
+            xin1 = x;
+            vec2 = 4 ;
+            yin2 = y - 1;
+            xin2 = x;
+            vec3 = 3 ;
+            yin3 = y - 1;
+            xin3 = x + 1;
+            break;
+
+        case 3:
+            vec1 = 4 ;
+            yin1 = y  ;
+            xin1 = x - 1;
+            vec2 = 1 ;
+            yin2 = y  ;
+            xin2 = x;
+            vec3 = 2 ;
+            yin3 = y  ;
+            xin3 = x;
+            break;
+
+        default: /* case 4 */
+            vec1 = 3 ;
+            yin1 = y  ;
+            xin1 = x;
+            vec2 = 1 ;
+            yin2 = y  ;
+            xin2 = x;
+            vec3 = 2 ;
+            yin3 = y  ;
+            xin3 = x;
+            break;
+    }
+
+    if (block == 0)
+    {
+        /* according to the motion encoding, we must choose a first non-transparent
+        block in the surrounding MBs (16-mode)
+            */
+
+        if (x > 0 && slice_nb[mbnum] == slice_nb[mbnum-1])
+            rule1 = 0;
+        else
+            rule1 = 1;
+
+        if (y > 0 && slice_nb[mbnum] == slice_nb[mbnum-nMBPerRow])
+            rule2 = 0;
+        else
+            rule2 = 1;
+
+        if ((x != nMBPerRow - 1) && (y > 0) && slice_nb[mbnum] == slice_nb[mbnum+1-nMBPerRow])
+            rule3 = 0;
+        else
+            rule3 = 1;
+    }
+    else
+    {
+        /* check borders for single blocks (advanced mode) */
+        /* rule 1 */
+        if (((block == 1 || block == 3) &&
+                (x == 0 || slice_nb[mbnum] != slice_nb[mbnum-1])))
+            rule1 = 1;
+        else
+            rule1 = 0;
+
+        /* rule 2 */
+        if (((block == 1 || block == 2) &&
+                (y == 0 || slice_nb[mbnum] != slice_nb[mbnum-nMBPerRow])))
+            rule2 = 1;
+        else
+            rule2 = 0;
+
+        /* rule 3 */
+        if (((block == 1 || block == 2) &&
+                (x == nMBPerRow - 1 || y == 0 || slice_nb[mbnum] != slice_nb[mbnum+1-nMBPerRow])))
+            rule3 = 1;
+        else
+            rule3 = 0;
+    }
+
+    if (rule1)
+    {
+        p1x = p1y = 0;
+    }
+    else
+    {
+
+        p1x = motdata[yin1*nMBPerRow+xin1][vec1].x;
+        p1y = motdata[yin1*nMBPerRow+xin1][vec1].y;
+        //p1x = motxdata[xin1*2+(vec1&0x1) + (yin1*2+(vec1>>1))*xB];
+        //p1y = motydata[xin1*2+(vec1&0x1) + (yin1*2+(vec1>>1))*xB];
+    }
+
+    if (rule2)
+    {
+        p2x = p2y = 0;
+    }
+    else
+    {
+        p2x = motdata[yin2*nMBPerRow+xin2][vec2].x;
+        p2y = motdata[yin2*nMBPerRow+xin2][vec2].y;
+        //p2x = motxdata[xin2*2+(vec2&0x1) + (yin2*2+(vec2>>1))*xB];
+        //p2y = motydata[xin2*2+(vec2&0x1) + (yin2*2+(vec2>>1))*xB];
+    }
+
+    if (rule3)
+    {
+        p3x = p3y = 0;
+    }
+    else
+    {
+        p3x = motdata[yin3*nMBPerRow+xin3][vec3].x;
+        p3y = motdata[yin3*nMBPerRow+xin3][vec3].y;
+        //p3x = motxdata[xin3*2+ (vec3&0x1) + (yin3*2+(vec3>>1))*xB];
+        //p3y = motydata[xin3*2+ (vec3&0x1) + (yin3*2+(vec3>>1))*xB];
+    }
+
+    if (rule1 && rule2 && rule3)
+    {
+        /* all MBs are outside the VOP */
+        *mvx = *mvy = 0;
+    }
+    else if (rule1 + rule2 + rule3 == 2)
+    {
+        /* two of three are zero */
+        *mvx = (p1x + p2x + p3x);
+        *mvy = (p1y + p2y + p3y);
+    }
+    else
+    {
+        *mvx = ((p1x + p2x + p3x - PV_MAX(p1x, PV_MAX(p2x, p3x)) - PV_MIN(p1x, PV_MIN(p2x, p3x))));
+        *mvy = ((p1y + p2y + p3y - PV_MAX(p1y, PV_MAX(p2y, p3y)) - PV_MIN(p1y, PV_MIN(p2y, p3y))));
+    }
+
+    return;
+}
+
+
+Void WriteMVcomponent(Int f_code, Int dmv, BitstreamEncVideo *bs)
+{
+    Int residual, vlc_code_mag, bits, entry;
+
+    ScaleMVD(f_code, dmv, &residual, &vlc_code_mag);
+
+    if (vlc_code_mag < 0)
+        entry = vlc_code_mag + 65;
+    else
+        entry = vlc_code_mag;
+
+    bits = PutMV(entry, bs);
+
+    if ((f_code != 1) && (vlc_code_mag != 0))
+    {
+        BitstreamPutBits(bs, f_code - 1, residual);
+        bits += f_code - 1;
+    }
+    return;
+}
+
+
+Void
+ScaleMVD(
+    Int  f_code,       /* <-- MV range in 1/2 units: 1=32,2=64,...,7=2048     */
+    Int  diff_vector,  /* <-- MV Difference commponent in 1/2 units           */
+    Int  *residual,    /* --> value to be FLC coded                           */
+    Int  *vlc_code_mag /* --> value to be VLC coded                           */
+)
+{
+    Int   range;
+    Int   scale_factor;
+    Int   r_size;
+    Int   low;
+    Int   high;
+    Int   aux;
+
+    r_size = f_code - 1;
+    scale_factor = 1 << r_size;
+    range = 32 * scale_factor;
+    low   = -range;
+    high  =  range - 1;
+
+    if (diff_vector < low)
+        diff_vector += 2 * range;
+    else if (diff_vector > high)
+        diff_vector -= 2 * range;
+
+    if (diff_vector == 0)
+    {
+        *vlc_code_mag = 0;
+        *residual = 0;
+    }
+    else if (scale_factor == 1)
+    {
+        *vlc_code_mag = diff_vector;
+        *residual = 0;
+    }
+    else
+    {
+        aux = PV_ABS(diff_vector) + scale_factor - 1;
+        *vlc_code_mag = aux >> r_size;
+
+        if (diff_vector < 0)
+            *vlc_code_mag = -*vlc_code_mag;
+        *residual = aux & (scale_factor - 1);
+    }
+}
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/vlc_encode.h b/media/libstagefright/codecs/m4v_h263/enc/src/vlc_encode.h
new file mode 100644
index 0000000..3721b6b
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/vlc_encode.h
@@ -0,0 +1,42 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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 _VLC_ENCODE_H_
+#define _VLC_ENCODE_H_
+
+#include "mp4def.h"
+#include "mp4enc_api.h"
+
+Int PutCoeff_Inter(Int run, Int level, Int last, BitstreamEncVideo *bitstream);
+Int PutCoeff_Intra(Int run, Int level, Int last, BitstreamEncVideo *bitstream);
+Int PutCBPY(Int cbpy, Char intra, BitstreamEncVideo *bitstream);
+Int PutMCBPC_Inter(Int cbpc, Int mode, BitstreamEncVideo *bitstream);
+Int PutMCBPC_Intra(Int cbpc, Int mode, BitstreamEncVideo *bitstream);
+Int PutMV(Int mvint, BitstreamEncVideo *bitstream);
+Int PutDCsize_chrom(Int size, BitstreamEncVideo *bitstream);
+Int PutDCsize_lum(Int size, BitstreamEncVideo *bitstream);
+Int PutDCsize_lum(Int size, BitstreamEncVideo *bitstream);
+Int PutCoeff_Inter_RVLC(Int run, Int level, Int last, BitstreamEncVideo *bitstream);
+Int PutCoeff_Intra_RVLC(Int run, Int level, Int last, BitstreamEncVideo *bitstream);
+Int PutRunCoeff_Inter(Int run, Int level, Int last, BitstreamEncVideo *bitstream);
+Int PutRunCoeff_Intra(Int run, Int level, Int last, BitstreamEncVideo *bitstream);
+Int PutLevelCoeff_Inter(Int run, Int level, Int last, BitstreamEncVideo *bitstream);
+Int PutLevelCoeff_Intra(Int run, Int level, Int last, BitstreamEncVideo *bitstream);
+
+Void MB_CodeCoeff(VideoEncData *video, BitstreamEncVideo *bs);
+Void BlockCodeCoeff(RunLevelBlock *RLB, BitstreamEncVideo *bs, Int j_start, UChar Mode, Int rvlc, Int shortVideoHeader);
+#endif /* _VLC_ENCODE_H_ */
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/vlc_encode_inline.h b/media/libstagefright/codecs/m4v_h263/enc/src/vlc_encode_inline.h
new file mode 100644
index 0000000..a2f4934
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/vlc_encode_inline.h
@@ -0,0 +1,316 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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 _VLC_ENCODE_INLINE_H_
+#define _VLC_ENCODE_INLINE_H_
+
+#if !defined(PV_ARM_GCC_V5) && !defined(PV_ARM_GCC_V4)
+
+__inline  Int zero_run_search(UInt *bitmapzz, Short *dataBlock, RunLevelBlock *RLB, Int nc)
+{
+    Int idx, run, level, j;
+    UInt end, match;
+
+    idx = 0;
+    j   = 0;
+    run = 0;
+    match = 1 << 31;
+    if (nc > 32)
+        end = 1;
+    else
+        end = 1 << (32 - nc);
+
+    while (match >= end)
+    {
+        if ((match&bitmapzz[0]) == 0)
+        {
+            run++;
+            j++;
+            match >>= 1;
+        }
+        else
+        {
+            match >>= 1;
+            level = dataBlock[j];
+            dataBlock[j] = 0; /* reset output */
+            j++;
+            if (level < 0)
+            {
+                RLB->level[idx] = -level;
+                RLB->s[idx] = 1;
+                RLB->run[idx] = run;
+                run = 0;
+                idx++;
+            }
+            else
+            {
+                RLB->level[idx] = level;
+                RLB->s[idx] = 0;
+                RLB->run[idx] = run;
+                run = 0;
+                idx++;
+            }
+        }
+    }
+    nc -= 32;
+    if (nc > 0)
+    {
+        match = 1 << 31;
+        end = 1 << (32 - nc);
+        while (match >= end)
+        {
+            if ((match&bitmapzz[1]) == 0)
+            {
+                run++;
+                j++;
+                match >>= 1;
+            }
+            else
+            {
+                match >>= 1;
+                level = dataBlock[j];
+                dataBlock[j] = 0; /* reset output */
+                j++;
+                if (level < 0)
+                {
+                    RLB->level[idx] = -level;
+                    RLB->s[idx] = 1;
+                    RLB->run[idx] = run;
+                    run = 0;
+                    idx++;
+                }
+                else
+                {
+                    RLB->level[idx] = level;
+                    RLB->s[idx] = 0;
+                    RLB->run[idx] = run;
+                    run = 0;
+                    idx++;
+                }
+            }
+        }
+    }
+
+    return idx;
+}
+
+#elif defined(__CC_ARM)  /* only work with arm v5 */
+
+__inline  Int zero_run_search(UInt *bitmapzz, Short *dataBlock, RunLevelBlock *RLB, Int nc)
+{
+    OSCL_UNUSED_ARG(nc);
+    Int idx, run, level, j;
+    UInt end, match;
+    Int  zzorder;
+
+    idx = 0;
+    run = 0;
+    j   = -1;
+    __asm
+    {
+        ldr match, [bitmapzz]
+        clz run, match
+    }
+
+    zzorder = 0;
+
+    while (run < 32)
+    {
+        __asm
+        {
+            mov end, #0x80000000
+            mov end, end, lsr run   /* mask*/
+            bic match, match, end       /* remove it from bitmap */
+            mov run, run, lsl #1  /* 05/09/02 */
+            ldrsh level, [dataBlock, run] /*  load data */
+            strh zzorder, [dataBlock, run] /* reset output */
+            add j, j, #1
+            rsb run, j, run, lsr #1 /* delta run */
+            add j, j, run           /* current position */
+        }
+        if (level < 0)
+        {
+            RLB->level[idx] = -level;
+            RLB->s[idx] = 1;
+            RLB->run[idx] = run;
+            run = 0;
+            idx++;
+        }
+        else
+        {
+            RLB->level[idx] = level;
+            RLB->s[idx] = 0;
+            RLB->run[idx] = run;
+            run = 0;
+            idx++;
+        }
+        __asm
+        {
+            clz run, match
+        }
+    }
+    __asm
+    {
+        ldr match, [bitmapzz, #4]
+        clz run, match
+    }
+
+    while (run < 32)
+    {
+        __asm
+        {
+            mov end, #0x80000000
+            mov end, end, lsr run   /* mask*/
+            bic match, match, end       /* remove it from bitmap */
+            add run, run, #32       /* current position */
+            mov run, run, lsl #1    /* 09/02/05 */
+            ldrsh level, [dataBlock, run] /*  load data */
+            strh  zzorder, [dataBlock, run] /* reset output */
+            add j, j, #1
+            rsb run, j, run, lsr #1     /* delta run */
+            add j, j, run           /* current position */
+        }
+        if (level < 0)
+        {
+            RLB->level[idx] = -level;
+            RLB->s[idx] = 1;
+            RLB->run[idx] = run;
+            run = 0;
+            idx++;
+        }
+        else
+        {
+            RLB->level[idx] = level;
+            RLB->s[idx] = 0;
+            RLB->run[idx] = run;
+            run = 0;
+            idx++;
+        }
+        __asm
+        {
+            clz run, match
+        }
+    }
+
+    return idx;
+}
+
+#elif ( defined(PV_ARM_GCC_V4) || defined(PV_ARM_GCC_V5) ) /* ARM GNU COMPILER  */
+
+__inline Int m4v_enc_clz(UInt temp)
+{
+    register Int rb;
+    register UInt ra = (UInt)temp;
+
+    asm volatile("clz   %0, %1"
+             : "=&r"(rb)
+                         : "r"(ra)
+                        );
+
+    return (rb);
+}
+
+__inline  Int zero_run_search(UInt *bitmapzz, Short *dataBlock, RunLevelBlock *RLB, Int nc)
+{
+    OSCL_UNUSED_ARG(nc);
+    Int idx, run, level = 0, j;
+    UInt end = 0, match;
+    Int  zzorder;
+
+    idx = 0;
+    run = 0;
+    j   = -1;
+    match = *bitmapzz;
+    run = m4v_enc_clz(match);
+
+    zzorder = 0;
+
+    while (run < 32)
+    {
+        asm volatile("mov   %0, #0x80000000\n\t"
+                     "mov   %0, %0, lsr %1\n\t"
+                     "bic   %2, %2, %0\n\t"
+                     "mov   %1, %1, lsl #1\n\t"
+                     "ldrsh %3, [%6, %1]\n\t"
+                     "strh  %5, [%6, %1]\n\t"
+                     "add   %4, %4, #1\n\t"
+                     "rsb   %1, %4, %1, lsr #1\n\t"
+                     "add   %4, %4, %1"
+             : "+r"(end), "+r"(run), "+r"(match), "=r"(level), "+r"(j)
+                             : "r"(zzorder), "r"(dataBlock));
+        if (level < 0)
+        {
+            RLB->level[idx] = -level;
+            RLB->s[idx] = 1;
+            RLB->run[idx] = run;
+            run = 0;
+            idx++;
+        }
+        else
+        {
+            RLB->level[idx] = level;
+            RLB->s[idx] = 0;
+            RLB->run[idx] = run;
+            run = 0;
+            idx++;
+        }
+        run = m4v_enc_clz(match);
+    }
+    match = bitmapzz[1];
+    run = m4v_enc_clz(match);
+
+    while (run < 32)
+    {
+        asm volatile("mov   %0, #0x80000000\n\t"
+                     "mov   %0, %0, lsr %1\n\t"
+                     "bic   %2, %2, %0\n\t"
+                     "add   %1, %1, #32\n\t"
+                     "mov   %1, %1, lsl #1\n\t"
+                     "ldrsh %3, [%6, %1]\n\t"
+                     "strh  %5, [%6, %1]\n\t"
+                     "add   %4, %4, #1\n\t"
+                     "rsb   %1, %4, %1, lsr #1\n\t"
+                     "add   %4, %4, %1"
+             : "+r"(end), "+r"(run), "+r"(match), "+r"(level), "+r"(j)
+                             : "r"(zzorder), "r"(dataBlock));
+        if (level < 0)
+        {
+            RLB->level[idx] = -level;
+            RLB->s[idx] = 1;
+            RLB->run[idx] = run;
+            run = 0;
+            idx++;
+        }
+        else
+        {
+            RLB->level[idx] = level;
+            RLB->s[idx] = 0;
+            RLB->run[idx] = run;
+            run = 0;
+            idx++;
+        }
+        run = m4v_enc_clz(match);
+    }
+
+    return idx;
+}
+
+#endif
+
+#endif // _VLC_ENCODE_INLINE_H_
+
+
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/vop.cpp b/media/libstagefright/codecs/m4v_h263/enc/src/vop.cpp
new file mode 100644
index 0000000..47076c3
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/enc/src/vop.cpp
@@ -0,0 +1,581 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * 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 "mp4def.h"
+#include "mp4lib_int.h"
+#include "mp4enc_lib.h"
+#include "bitstream_io.h"
+#include "m4venc_oscl.h"
+
+PV_STATUS EncodeShortHeader(BitstreamEncVideo *stream, Vop *currVop);
+PV_STATUS EncodeVOPHeader(BitstreamEncVideo *stream, Vol *currVol, Vop *currVop);
+PV_STATUS EncodeGOVHeader(BitstreamEncVideo *stream, UInt seconds);
+
+PV_STATUS EncodeVop_BXRC(VideoEncData *video);
+PV_STATUS EncodeVop_NoME(VideoEncData *video);
+
+/* ======================================================================== */
+/*  Function : DecodeVop()                                                  */
+/*  Date     : 08/23/2000                                                   */
+/*  Purpose  : Encode VOP Header                                            */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+PV_STATUS EncodeVop(VideoEncData *video)
+{
+
+    PV_STATUS status;
+    Int currLayer = video->currLayer;
+    Vol *currVol = video->vol[currLayer];
+    Vop *currVop = video->currVop;
+//  BitstreamEncVideo *stream=video->bitstream1;
+    UChar *Mode = video->headerInfo.Mode;
+    rateControl **rc = video->rc;
+//  UInt time=0;
+
+    /*******************/
+    /* Initialize mode */
+    /*******************/
+
+    switch (currVop->predictionType)
+    {
+        case I_VOP:
+            M4VENC_MEMSET(Mode, MODE_INTRA, sizeof(UChar)*currVol->nTotalMB);
+            break;
+        case P_VOP:
+            M4VENC_MEMSET(Mode, MODE_INTER, sizeof(UChar)*currVol->nTotalMB);
+            break;
+        case B_VOP:
+            /*M4VENC_MEMSET(Mode, MODE_INTER_B,sizeof(UChar)*nTotalMB);*/
+            return PV_FAIL;
+        default:
+            return PV_FAIL;
+    }
+
+    /*********************/
+    /* Motion Estimation */
+    /* compute MVs, scene change detection, edge padding, */
+    /* intra refresh, compute block activity */
+    /*********************/
+    MotionEstimation(video);    /* do ME for the whole frame */
+
+    /***************************/
+    /* rate Control (assign QP) */
+    /* 4/11/01, clean-up, and put into a separate function */
+    /***************************/
+    status = RC_VopQPSetting(video, rc);
+    if (status == PV_FAIL)
+        return PV_FAIL;
+
+    /**********************/
+    /*     Encode VOP     */
+    /**********************/
+    if (video->slice_coding) /* end here */
+    {
+        /* initialize state variable for slice-based APIs */
+        video->totalSAD = 0;
+        video->mbnum = 0;
+        video->sliceNo[0] = 0;
+        video->numIntra = 0;
+        video->offset = 0;
+        video->end_of_buf = 0;
+        video->hp_guess = -1;
+        return status;
+    }
+
+    status = EncodeVop_NoME(video);
+
+    /******************************/
+    /* rate control (update stat) */
+    /* 6/2/01 separate function */
+    /******************************/
+
+    RC_VopUpdateStat(video, rc[currLayer]);
+
+    return status;
+}
+
+/* ======================================================================== */
+/*  Function : EncodeVop_NoME()                                             */
+/*  Date     : 08/28/2001                                                   */
+/*  History  :                                                              */
+/*  Purpose  : EncodeVop without motion est.                                */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/*                                                                          */
+/* ======================================================================== */
+
+PV_STATUS EncodeVop_NoME(VideoEncData *video)
+{
+    Vop *currVop = video->currVop;
+    Vol *currVol = video->vol[video->currLayer];
+    BitstreamEncVideo *stream = video->bitstream1;
+    Int time = 0;   /* follows EncodeVop value */
+    PV_STATUS status = PV_SUCCESS;
+
+    if (currVol->shortVideoHeader) /* Short Video Header = 1 */
+    {
+
+        status = EncodeShortHeader(stream, currVop); /* Encode Short Header */
+
+        video->header_bits = BitstreamGetPos(stream); /* Header Bits */
+
+        status = EncodeFrameCombinedMode(video);
+
+    }
+#ifndef H263_ONLY
+    else    /* Short Video Header = 0 */
+    {
+
+        if (currVol->GOVStart && currVop->predictionType == I_VOP)
+            status = EncodeGOVHeader(stream, time); /* Encode GOV Header */
+
+        status = EncodeVOPHeader(stream, currVol, currVop);  /* Encode VOP Header */
+
+        video->header_bits = BitstreamGetPos(stream); /* Header Bits */
+
+        if (currVop->vopCoded)
+        {
+            if (!currVol->scalability)
+            {
+                if (currVol->dataPartitioning)
+                {
+                    status = EncodeFrameDataPartMode(video); /* Encode Data Partitioning Mode VOP */
+                }
+                else
+                {
+                    status = EncodeFrameCombinedMode(video); /* Encode Combined Mode VOP */
+                }
+            }
+            else
+                status = EncodeFrameCombinedMode(video); /* Encode Combined Mode VOP */
+        }
+        else  /* Vop Not coded */
+        {
+
+            return status;
+        }
+    }
+#endif /* H263_ONLY */
+    return status;
+
+}
+
+#ifndef NO_SLICE_ENCODE
+/* ======================================================================== */
+/*  Function : EncodeSlice()                                                */
+/*  Date     : 04/19/2002                                                   */
+/*  History  :                                                              */
+/*  Purpose  : Encode one slice.                                            */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/*                                                                          */
+/* ======================================================================== */
+
+PV_STATUS EncodeSlice(VideoEncData *video)
+{
+    Vop *currVop = video->currVop;
+    Int currLayer = video->currLayer;
+    Vol *currVol = video->vol[currLayer];
+    BitstreamEncVideo *stream = video->bitstream1; /* different from frame-based */
+    Int time = 0;   /* follows EncodeVop value */
+    PV_STATUS status = PV_SUCCESS;
+    rateControl **rc = video->rc;
+
+    if (currVol->shortVideoHeader) /* Short Video Header = 1 */
+    {
+
+        if (video->mbnum == 0)
+        {
+            status = EncodeShortHeader(stream, currVop); /* Encode Short Header */
+
+            video->header_bits = BitstreamGetPos(stream); /* Header Bits */
+        }
+
+        status = EncodeSliceCombinedMode(video);
+
+    }
+#ifndef H263_ONLY
+    else    /* Short Video Header = 0 */
+    {
+
+        if (video->mbnum == 0)
+        {
+            if (currVol->GOVStart)
+                status = EncodeGOVHeader(stream, time); /* Encode GOV Header */
+
+            status = EncodeVOPHeader(stream, currVol, currVop);  /* Encode VOP Header */
+
+            video->header_bits = BitstreamGetPos(stream); /* Header Bits */
+        }
+
+        if (currVop->vopCoded)
+        {
+            if (!currVol->scalability)
+            {
+                if (currVol->dataPartitioning)
+                {
+                    status = EncodeSliceDataPartMode(video); /* Encode Data Partitioning Mode VOP */
+                }
+                else
+                {
+                    status = EncodeSliceCombinedMode(video); /* Encode Combined Mode VOP */
+                }
+            }
+            else
+                status = EncodeSliceCombinedMode(video); /* Encode Combined Mode VOP */
+        }
+        else  /* Vop Not coded */
+        {
+
+            return status;
+        }
+    }
+#endif /* H263_ONLY */
+    if (video->mbnum >= currVol->nTotalMB && status != PV_END_OF_BUF) /* end of Vop */
+    {
+        /******************************/
+        /* rate control (update stat) */
+        /* 6/2/01 separate function */
+        /******************************/
+
+        status = RC_VopUpdateStat(video, rc[currLayer]);
+    }
+
+    return status;
+
+}
+#endif /* NO_SLICE_ENCODE */
+
+#ifndef H263_ONLY
+/* ======================================================================== */
+/*  Function : EncodeGOVHeader()                                            */
+/*  Date     : 08/23/2000                                                   */
+/*  Purpose  : Encode GOV Header                                            */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+PV_STATUS EncodeGOVHeader(BitstreamEncVideo *stream, UInt seconds)
+{
+    PV_STATUS status;
+//  int temp;
+    UInt tmpvar;
+
+    /********************************/
+    /* Group_of_VideoObjectPlane()  */
+    /********************************/
+
+    status = BitstreamPutGT16Bits(stream, 32, GROUP_START_CODE);
+    /* time_code */
+    tmpvar = seconds / 3600;
+    status = BitstreamPutBits(stream, 5, tmpvar); /* Hours*/
+
+    tmpvar = (seconds - tmpvar * 3600) / 60;
+    status = BitstreamPutBits(stream, 6, tmpvar); /* Minutes*/
+
+    status = BitstreamPut1Bits(stream, 1); /* Marker*/
+
+    tmpvar = seconds % 60;
+    status = BitstreamPutBits(stream, 6, tmpvar); /* Seconds*/
+
+    status = BitstreamPut1Bits(stream, 1); /* closed_gov */
+    status = BitstreamPut1Bits(stream, 0); /* broken_link */
+    /*temp =*/
+    BitstreamMpeg4ByteAlignStuffing(stream); /* Byte align GOV Header */
+
+    return status;
+}
+
+#ifdef ALLOW_VOP_NOT_CODED
+
+PV_STATUS EncodeVopNotCoded(VideoEncData *video, UChar *bstream, Int *size, ULong modTime)
+{
+    PV_STATUS status;
+    Vol *currVol = video->vol[0];
+    Vop *currVop = video->currVop;
+    BitstreamEncVideo *stream = currVol->stream;
+    UInt frameTick;
+    Int timeInc;
+
+    stream->bitstreamBuffer = bstream;
+    stream->bufferSize = *size;
+    BitstreamEncReset(stream);
+
+    status = BitstreamPutGT16Bits(stream, 32, VOP_START_CODE); /*Start Code for VOP*/
+    status = BitstreamPutBits(stream, 2, P_VOP);/* VOP Coding Type*/
+
+    frameTick = (Int)(((double)(modTime - video->modTimeRef) * currVol->timeIncrementResolution + 500) / 1000);
+    timeInc = frameTick - video->refTick[0];
+    while (timeInc >= currVol->timeIncrementResolution)
+    {
+        timeInc -= currVol->timeIncrementResolution;
+        status = BitstreamPut1Bits(stream, 1);
+        /* do not update refTick and modTimeRef yet, do it after encoding!! */
+    }
+    status = BitstreamPut1Bits(stream, 0);
+    status = BitstreamPut1Bits(stream, 1); /* marker bit */
+    status = BitstreamPutBits(stream, currVol->nbitsTimeIncRes, timeInc); /* vop_time_increment */
+    status = BitstreamPut1Bits(stream, 1); /* marker bit */
+    status = BitstreamPut1Bits(stream, 0); /* vop_coded bit */
+    BitstreamMpeg4ByteAlignStuffing(stream);
+
+    return status;
+}
+#endif
+
+/* ======================================================================== */
+/*  Function : EncodeVOPHeader()                                            */
+/*  Date     : 08/23/2000                                                   */
+/*  Purpose  : Encode VOP Header                                            */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+
+PV_STATUS EncodeVOPHeader(BitstreamEncVideo *stream, Vol *currVol, Vop *currVop)
+{
+    PV_STATUS status;
+    //int temp;
+
+    int MTB = currVol->moduloTimeBase;
+    /************************/
+    /* VideoObjectPlane()   */
+    /************************/
+
+    status = BitstreamPutGT16Bits(stream, 32, VOP_START_CODE); /*Start Code for VOP*/
+    status = BitstreamPutBits(stream, 2, currVop->predictionType);/* VOP Coding Type*/
+
+    currVol->prevModuloTimeBase = currVol->moduloTimeBase;
+
+    while (MTB)
+    {
+        status = BitstreamPut1Bits(stream, 1);
+        MTB--;
+    }
+    status = BitstreamPut1Bits(stream, 0);
+
+    status = BitstreamPut1Bits(stream, 1); /* marker bit */
+    status = BitstreamPutBits(stream, currVol->nbitsTimeIncRes, currVop->timeInc); /* vop_time_increment */
+    status = BitstreamPut1Bits(stream, 1); /* marker bit */
+    status = BitstreamPut1Bits(stream, currVop->vopCoded); /* vop_coded bit */
+    if (currVop->vopCoded == 0)
+    {
+        /*temp =*/
+        BitstreamMpeg4ByteAlignStuffing(stream); /* Byte align VOP Header */
+        return status;
+    }
+    if (currVop->predictionType == P_VOP)
+        status = BitstreamPut1Bits(stream, currVop->roundingType); /* vop_rounding_type */
+
+    status = BitstreamPutBits(stream, 3, currVop->intraDCVlcThr); /* intra_dc_vlc_thr */
+    status = BitstreamPutBits(stream, 5, currVop->quantizer);   /* vop_quant */
+
+    if (currVop->predictionType != I_VOP)
+        status = BitstreamPutBits(stream, 3, currVop->fcodeForward); /* vop_fcode_forward */
+    if (currVop->predictionType == B_VOP)
+        status = BitstreamPutBits(stream, 3, currVop->fcodeBackward);/* vop_fcode_backward */
+
+    if (currVol->scalability)
+        /* enhancement_type = 0 */
+        status = BitstreamPutBits(stream, 2, currVop->refSelectCode); /* ref_select_code */
+
+    return status;
+}
+#endif /* H263_ONLY */
+/* ======================================================================== */
+/*  Function : EncodeShortHeader()                                          */
+/*  Date     : 08/23/2000                                                   */
+/*  Purpose  : Encode VOP Header                                            */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+
+PV_STATUS EncodeShortHeader(BitstreamEncVideo *stream, Vop *currVop)
+{
+
+    PV_STATUS status;
+
+    status = BitstreamPutGT16Bits(stream, 22, SHORT_VIDEO_START_MARKER); /* Short_video_start_marker */
+    status = BitstreamPutBits(stream, 8, currVop->temporalRef); /* temporal_reference */
+    status = BitstreamPut1Bits(stream, 1); /* marker bit */
+    status = BitstreamPut1Bits(stream, 0); /* zero bit */
+    status = BitstreamPut1Bits(stream, 0); /* split_screen_indicator=0*/
+    status = BitstreamPut1Bits(stream, 0); /* document_camera_indicator=0*/
+    status = BitstreamPut1Bits(stream, 0); /* full_picture_freeze_release=0*/
+
+    switch (currVop->width)
+    {
+        case 128:
+            if (currVop->height == 96)
+                status = BitstreamPutBits(stream, 3, 1); /* source_format = 1 */
+            else
+            {
+                status = PV_FAIL;
+                return status;
+            }
+            break;
+
+        case 176:
+            if (currVop->height == 144)
+                status = BitstreamPutBits(stream, 3, 2); /* source_format = 2 */
+            else
+            {
+                status = PV_FAIL;
+                return status;
+            }
+            break;
+
+        case 352:
+            if (currVop->height == 288)
+                status = BitstreamPutBits(stream, 3, 3); /* source_format = 3 */
+            else
+            {
+                status = PV_FAIL;
+                return status;
+            }
+            break;
+
+        case 704:
+            if (currVop->height == 576)
+                status = BitstreamPutBits(stream, 3, 4); /* source_format = 4 */
+            else
+            {
+                status = PV_FAIL;
+                return status;
+            }
+            break;
+
+        case 1408:
+            if (currVop->height == 1152)
+                status = BitstreamPutBits(stream, 3, 5); /* source_format = 5 */
+            else
+            {
+                status = PV_FAIL;
+                return status;
+            }
+            break;
+
+        default:
+            status = PV_FAIL;
+            return status;
+    }
+
+
+    status = BitstreamPut1Bits(stream, currVop->predictionType); /* picture_coding type */
+    status = BitstreamPutBits(stream, 4, 0); /* four_reserved_zero_bits */
+    status = BitstreamPutBits(stream, 5, currVop->quantizer); /* vop_quant*/
+    status = BitstreamPut1Bits(stream, 0); /* zero_bit*/
+    status = BitstreamPut1Bits(stream, 0); /* pei=0 */
+
+    return status;
+}
+
+#ifndef H263_ONLY
+/* ======================================================================== */
+/*  Function : EncodeVideoPacketHeader()                                    */
+/*  Date     : 09/05/2000                                                   */
+/*  History  :                                                              */
+/*  Purpose  : Encode a frame of MPEG4 bitstream in Combined mode.          */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified : 04/25/2002                               */
+/*             Add bitstream structure as input argument                    */
+/*                                                                          */
+/* ======================================================================== */
+PV_STATUS EncodeVideoPacketHeader(VideoEncData *video, int MB_number,
+                                  int quant_scale, Int insert)
+{
+//  PV_STATUS status=PV_SUCCESS;
+    int fcode;
+    Vop *currVop = video->currVop;
+    Vol *currVol = video->vol[video->currLayer];
+    BitstreamEncVideo *bs, tmp;
+    UChar buffer[30];
+
+    if (insert) /* insert packet header to the beginning of bs1 */
+    {
+        tmp.bitstreamBuffer = buffer; /* use temporary buffer */
+        tmp.bufferSize = 30;
+        BitstreamEncReset(&tmp);
+        bs = &tmp;
+    }
+    else
+        bs = video->bitstream1;
+
+
+    if (currVop->predictionType == I_VOP)
+        BitstreamPutGT16Bits(bs, 17, 1);    /* resync_marker I_VOP */
+    else if (currVop->predictionType == P_VOP)
+    {
+        fcode = currVop->fcodeForward;
+        BitstreamPutGT16Bits(bs, 16 + fcode, 1);    /* resync_marker P_VOP */
+
+    }
+    else
+    {
+        fcode = currVop->fcodeForward;
+        if (currVop->fcodeBackward > fcode)
+            fcode = currVop->fcodeBackward;
+        BitstreamPutGT16Bits(bs, 16 + fcode, 1);    /* resync_marker B_VOP */
+    }
+
+    BitstreamPutBits(bs, currVol->nBitsForMBID, MB_number); /* resync_marker */
+    BitstreamPutBits(bs, 5, quant_scale); /* quant_scale */
+    BitstreamPut1Bits(bs, 0); /* header_extension_code = 0 */
+
+    if (0) /* header_extension_code = 1 */
+    {
+        /* NEED modulo_time_base code here ... default 0x01  belo*/
+        /*status =*/
+        BitstreamPut1Bits(bs, 1);
+        /*status = */
+        BitstreamPut1Bits(bs, 0);
+
+        /*status = */
+        BitstreamPut1Bits(bs, 1); /* marker bit */
+        /*status = */
+        BitstreamPutBits(bs, currVol->nbitsTimeIncRes, currVop->timeInc); /* vop_time_increment */
+        /*status = */
+        BitstreamPut1Bits(bs, 1); /* marker bit */
+
+        /*status = */
+        BitstreamPutBits(bs, 2, currVop->predictionType);/* VOP Coding Type*/
+
+        /*status = */
+        BitstreamPutBits(bs, 3, currVop->intraDCVlcThr); /* intra_dc_vlc_thr */
+
+        if (currVop->predictionType != I_VOP)
+            /*status = */ BitstreamPutBits(bs, 3, currVop->fcodeForward);
+        if (currVop->predictionType == B_VOP)
+            /*status = */ BitstreamPutBits(bs, 3, currVop->fcodeBackward);
+    }
+#ifndef NO_SLICE_ENCODE
+    if (insert)
+        BitstreamPrependPacket(video->bitstream1, bs);
+#endif
+    return PV_SUCCESS;
+}
+
+#endif /* H263_ONLY */
+
+
+
diff --git a/media/libstagefright/include/M4vH263Encoder.h b/media/libstagefright/include/M4vH263Encoder.h
new file mode 100644
index 0000000..dd146f4
--- /dev/null
+++ b/media/libstagefright/include/M4vH263Encoder.h
@@ -0,0 +1,80 @@
+/*
+ * 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.
+ */
+
+#ifndef M4V_H263_ENCODER_H_
+
+#define M4V_H263_ENCODER_H_
+
+#include <media/stagefright/MediaBuffer.h>
+#include <media/stagefright/MediaSource.h>
+
+struct tagvideoEncControls;
+struct tagvideoEncOptions;
+
+namespace android {
+
+struct MediaBuffer;
+struct MediaBufferGroup;
+
+struct M4vH263Encoder : public MediaSource,
+                    public MediaBufferObserver {
+    M4vH263Encoder(const sp<MediaSource> &source,
+            const sp<MetaData>& meta);
+
+    virtual status_t start(MetaData *params);
+    virtual status_t stop();
+
+    virtual sp<MetaData> getFormat();
+
+    virtual status_t read(
+            MediaBuffer **buffer, const ReadOptions *options);
+
+    virtual void signalBufferReturned(MediaBuffer *buffer);
+
+protected:
+    virtual ~M4vH263Encoder();
+
+private:
+    sp<MediaSource> mSource;
+    sp<MetaData>    mFormat;
+    sp<MetaData>    mMeta;
+
+    int32_t  mVideoWidth;
+    int32_t  mVideoHeight;
+    int32_t  mVideoFrameRate;
+    int32_t  mVideoBitRate;
+    int32_t  mVideoColorFormat;
+    int64_t  mNumInputFrames;
+    int64_t  mNextModTimeUs;
+    status_t mInitCheck;
+    bool     mStarted;
+
+    tagvideoEncControls   *mHandle;
+    tagvideoEncOptions    *mEncParams;
+    MediaBuffer           *mInputBuffer;
+    uint8_t               *mInputFrameData;
+    MediaBufferGroup      *mGroup;
+
+    status_t initCheck(const sp<MetaData>& meta);
+    void releaseOutputBuffers();
+
+    M4vH263Encoder(const M4vH263Encoder &);
+    M4vH263Encoder &operator=(const M4vH263Encoder &);
+};
+
+}  // namespace android
+
+#endif  // M4V_H263_ENCODER_H_