diff --git a/CleanSpec.mk b/CleanSpec.mk
index 34d040e..46a95c5 100644
--- a/CleanSpec.mk
+++ b/CleanSpec.mk
@@ -65,6 +65,8 @@
 $(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/SHARED_LIBRARIES/liboboe*)
 $(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj_arm/STATIC_LIBRARIES/liboboe*)
 $(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj_arm/SHARED_LIBRARIES/liboboe*)
+$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/bin/mediacodec)
+$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/etc/init/mediacodec.rc)
 
 # ************************************************
 # NEWER CLEAN STEPS MUST BE AT THE END OF THE LIST
diff --git a/camera/CameraBase.cpp b/camera/CameraBase.cpp
index 60effe2..c53e6c3 100644
--- a/camera/CameraBase.cpp
+++ b/camera/CameraBase.cpp
@@ -56,17 +56,19 @@
 }
 
 status_t CameraStatus::writeToParcel(android::Parcel* parcel) const {
-    status_t res;
-    res = parcel->writeString8(cameraId);
+    auto res = parcel->writeString16(String16(cameraId));
     if (res != OK) return res;
+
     res = parcel->writeInt32(status);
     return res;
 }
 
 status_t CameraStatus::readFromParcel(const android::Parcel* parcel) {
-    status_t res;
-    res = parcel->readString8(&cameraId);
+    String16 tempCameraId;
+    auto res = parcel->readString16(&tempCameraId);
     if (res != OK) return res;
+    cameraId = String8(tempCameraId);
+
     res = parcel->readInt32(&status);
     return res;
 }
diff --git a/drm/libmediadrm/CryptoHal.cpp b/drm/libmediadrm/CryptoHal.cpp
index e77a8ea..1466222 100644
--- a/drm/libmediadrm/CryptoHal.cpp
+++ b/drm/libmediadrm/CryptoHal.cpp
@@ -68,6 +68,8 @@
         return ERROR_DRM_SESSION_NOT_OPENED;
     case Status::ERROR_DRM_CANNOT_HANDLE:
         return ERROR_DRM_CANNOT_HANDLE;
+    case Status::ERROR_DRM_DECRYPT:
+        return ERROR_DRM_DECRYPT;
     default:
         return UNKNOWN_ERROR;
     }
diff --git a/drm/mediacas/plugins/clearkey/Android.mk b/drm/mediacas/plugins/clearkey/Android.mk
new file mode 100644
index 0000000..0c2b357
--- /dev/null
+++ b/drm/mediacas/plugins/clearkey/Android.mk
@@ -0,0 +1,68 @@
+#
+# Copyright (C) 2017 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= \
+    ClearKeyCasPlugin.cpp \
+    ClearKeyFetcher.cpp \
+    ClearKeyLicenseFetcher.cpp \
+    ClearKeySessionLibrary.cpp \
+    ecm.cpp \
+    ecm_generator.cpp \
+    JsonAssetLoader.cpp \
+    protos/license_protos.proto \
+
+LOCAL_MODULE := libclearkeycasplugin
+
+LOCAL_PROPRIETARY_MODULE := true
+LOCAL_MODULE_RELATIVE_PATH := mediacas
+
+LOCAL_SHARED_LIBRARIES := \
+    libutils \
+    liblog \
+    libcrypto \
+    libstagefright_foundation \
+    libprotobuf-cpp-lite \
+
+LOCAL_STATIC_LIBRARIES := \
+    libjsmn \
+
+LOCAL_MODULE_CLASS := SHARED_LIBRARIES
+
+LOCAL_PROTOC_OPTIMIZE_TYPE := full
+
+define proto_includes
+$(call local-generated-sources-dir)/proto/$(LOCAL_PATH)
+endef
+
+LOCAL_C_INCLUDES += \
+    external/jsmn \
+    frameworks/av/include \
+    frameworks/native/include/media \
+    $(call proto_includes)
+
+LOCAL_EXPORT_C_INCLUDE_DIRS := \
+    $(call proto_includes)
+
+LOCAL_MODULE_TAGS := optional
+
+include $(BUILD_SHARED_LIBRARY)
+
+#########################################################################
+# Build unit tests
+
+include $(LOCAL_PATH)/tests/Android.mk
diff --git a/drm/mediacas/plugins/clearkey/ClearKeyCasPlugin.cpp b/drm/mediacas/plugins/clearkey/ClearKeyCasPlugin.cpp
new file mode 100644
index 0000000..221b74b
--- /dev/null
+++ b/drm/mediacas/plugins/clearkey/ClearKeyCasPlugin.cpp
@@ -0,0 +1,494 @@
+/*
+ * Copyright (C) 2017 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 "ClearKeyCasPlugin"
+
+#include "ClearKeyFetcher.h"
+#include "ecm.h"
+#include "ClearKeyLicenseFetcher.h"
+#include "ClearKeyCasPlugin.h"
+#include "ClearKeySessionLibrary.h"
+#include <media/stagefright/foundation/ABuffer.h>
+#include <media/stagefright/foundation/ADebug.h>
+#include <media/stagefright/foundation/hexdump.h>
+#include <media/stagefright/MediaErrors.h>
+#include <utils/Log.h>
+
+android::CasFactory* createCasFactory() {
+    return new android::clearkeycas::ClearKeyCasFactory();
+}
+
+android::DescramblerFactory *createDescramblerFactory()
+{
+    return new android::clearkeycas::ClearKeyDescramblerFactory();
+}
+
+namespace android {
+namespace clearkeycas {
+
+static const int32_t sClearKeySystemId = 0xF6D8;
+
+bool ClearKeyCasFactory::isSystemIdSupported(int32_t CA_system_id) const {
+    return CA_system_id == sClearKeySystemId;
+}
+
+status_t ClearKeyCasFactory::queryPlugins(
+        std::vector<CasPluginDescriptor> *descriptors) const {
+    descriptors->clear();
+    descriptors->push_back({sClearKeySystemId, String8("Clear Key CAS")});
+    return OK;
+}
+
+status_t ClearKeyCasFactory::createPlugin(
+        int32_t CA_system_id,
+        uint64_t appData,
+        CasPluginCallback callback,
+        CasPlugin **plugin) {
+    if (!isSystemIdSupported(CA_system_id)) {
+        return BAD_VALUE;
+    }
+
+    *plugin = new ClearKeyCasPlugin(appData, callback);
+    return OK;
+}
+///////////////////////////////////////////////////////////////////////////////
+bool ClearKeyDescramblerFactory::isSystemIdSupported(
+        int32_t CA_system_id) const {
+    return CA_system_id == sClearKeySystemId;
+}
+
+status_t ClearKeyDescramblerFactory::createPlugin(
+        int32_t CA_system_id, DescramblerPlugin** plugin) {
+    if (!isSystemIdSupported(CA_system_id)) {
+        return BAD_VALUE;
+    }
+
+    *plugin = new ClearKeyDescramblerPlugin();
+    return OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+ClearKeyCasPlugin::ClearKeyCasPlugin(
+        uint64_t appData, CasPluginCallback callback)
+    : mAppData(appData), mCallback(callback) {
+    ALOGV("CTOR");
+}
+
+ClearKeyCasPlugin::~ClearKeyCasPlugin() {
+    ALOGV("DTOR");
+    ClearKeySessionLibrary::get()->destroyPlugin(this);
+}
+
+status_t ClearKeyCasPlugin::setPrivateData(const CasData &data) {
+    ALOGV("setPrivateData");
+
+    return OK;
+}
+
+static String8 sessionIdToString(const std::vector<uint8_t> &array) {
+    String8 result;
+    for (size_t i = 0; i < array.size(); i++) {
+        result.appendFormat("%02x ", array[i]);
+    }
+    if (result.isEmpty()) {
+        result.append("(null)");
+    }
+    return result;
+}
+
+status_t ClearKeyCasPlugin::openSession(
+        uint16_t program_number, CasSessionId* sessionId) {
+    ALOGV("openSession: program_number=%u", program_number);
+
+    return ClearKeySessionLibrary::get()->addSession(
+            this, program_number, 0, sessionId);
+}
+
+status_t ClearKeyCasPlugin::openSession(
+        uint16_t program_number,
+        uint16_t elementary_PID,
+        CasSessionId *sessionId) {
+    ALOGV("openSession: program_number=%u, elementary_PID=%u",
+            program_number, elementary_PID);
+
+    return ClearKeySessionLibrary::get()->addSession(
+            this, program_number, elementary_PID, sessionId);
+}
+
+status_t ClearKeyCasPlugin::closeSession(const CasSessionId &sessionId) {
+    ALOGV("closeSession: sessionId=%s", sessionIdToString(sessionId).string());
+    sp<ClearKeyCasSession> session =
+            ClearKeySessionLibrary::get()->findSession(sessionId);
+    if (session == NULL) {
+        return ERROR_DRM_SESSION_NOT_OPENED;
+    }
+
+    ClearKeySessionLibrary::get()->destroySession(sessionId);
+    return OK;
+}
+
+status_t ClearKeyCasPlugin::setSessionPrivateData(
+        const CasSessionId &sessionId, const CasData &data) {
+    ALOGV("setSessionPrivateData: sessionId=%s",
+            sessionIdToString(sessionId).string());
+    sp<ClearKeyCasSession> session =
+            ClearKeySessionLibrary::get()->findSession(sessionId);
+    if (session == NULL) {
+        return ERROR_DRM_SESSION_NOT_OPENED;
+    }
+    return OK;
+}
+
+status_t ClearKeyCasPlugin::processEcm(
+        const CasSessionId &sessionId, const CasEcm& ecm) {
+    ALOGV("processEcm: sessionId=%s", sessionIdToString(sessionId).string());
+    sp<ClearKeyCasSession> session =
+            ClearKeySessionLibrary::get()->findSession(sessionId);
+    if (session == NULL) {
+        return ERROR_DRM_SESSION_NOT_OPENED;
+    }
+
+    Mutex::Autolock lock(mKeyFetcherLock);
+
+    return session->updateECM(mKeyFetcher.get(), (void*)ecm.data(), ecm.size());
+}
+
+status_t ClearKeyCasPlugin::processEmm(const CasEmm& emm) {
+    ALOGV("processEmm");
+    Mutex::Autolock lock(mKeyFetcherLock);
+
+    return OK;
+}
+
+status_t ClearKeyCasPlugin::sendEvent(
+        int32_t event, int32_t arg, const CasData &eventData) {
+    ALOGV("sendEvent: event=%d, arg=%d", event, arg);
+    // Echo the received event to the callback.
+    // Clear key plugin doesn't use any event, echo'ing for testing only.
+    if (mCallback != NULL) {
+        mCallback((void*)mAppData, event, arg, (uint8_t*)eventData.data(), eventData.size());
+    }
+    return OK;
+}
+
+status_t ClearKeyCasPlugin::provision(const String8 &str) {
+    ALOGV("provision: provisionString=%s", str.string());
+    Mutex::Autolock lock(mKeyFetcherLock);
+
+    std::unique_ptr<ClearKeyLicenseFetcher> license_fetcher;
+    license_fetcher.reset(new ClearKeyLicenseFetcher());
+    status_t err = license_fetcher->Init(str.string());
+    if (err != OK) {
+        ALOGE("provision: failed to init ClearKeyLicenseFetcher (err=%d)", err);
+        return err;
+    }
+
+    std::unique_ptr<ClearKeyFetcher> key_fetcher;
+    key_fetcher.reset(new ClearKeyFetcher(std::move(license_fetcher)));
+    err = key_fetcher->Init();
+    if (err != OK) {
+        ALOGE("provision: failed to init ClearKeyFetcher (err=%d)", err);
+        return err;
+    }
+
+    ALOGV("provision: using ClearKeyFetcher");
+    mKeyFetcher = std::move(key_fetcher);
+
+    return OK;
+}
+
+status_t ClearKeyCasPlugin::refreshEntitlements(
+        int32_t refreshType, const CasData &refreshData) {
+    ALOGV("refreshEntitlements");
+    Mutex::Autolock lock(mKeyFetcherLock);
+
+    return OK;
+}
+
+///////////////////////////////////////////////////////////////////////
+
+// AES-128 CBC-CTS decrypt optimized for Transport Packets. |key| is the AES
+// key (odd key or even key), |length| is the data size, and |buffer| is the
+// ciphertext to be decrypted in place.
+status_t TpBlockCtsDecrypt(const AES_KEY& key, size_t length, char* buffer) {
+    CHECK(buffer);
+
+    // Invariant: Packet must be at least 16 bytes.
+    CHECK(length >= AES_BLOCK_SIZE);
+
+    // OpenSSL uses unsigned char.
+    unsigned char* data = reinterpret_cast<unsigned char*>(buffer);
+
+    // Start with zero-filled initialization vector.
+    unsigned char iv[AES_BLOCK_SIZE];
+    memset(iv, 0, AES_BLOCK_SIZE);
+
+    // Size of partial last block handled via CTS.
+    int cts_byte_count = length % AES_BLOCK_SIZE;
+
+    // If there no is no partial last block, then process using normal CBC.
+    if (cts_byte_count == 0) {
+        AES_cbc_encrypt(data, data, length, &key, iv, 0);
+        return OK;
+    }
+
+    // Cipher text stealing (CTS) - Schneier Figure 9.5 p 196.
+    // In CTS mode, the last two blocks have been swapped. Block[n-1] is really
+    // the original block[n] combined with the low-order bytes of the original
+    // block[n-1], while block[n] is the high-order bytes of the original
+    // block[n-1] padded with zeros.
+
+    // Block[0] - block[n-2] are handled with normal CBC.
+    int cbc_byte_count = length - cts_byte_count - AES_BLOCK_SIZE;
+    if (cbc_byte_count > 0) {
+        AES_cbc_encrypt(data, data, cbc_byte_count, &key, iv, 0);
+        // |data| points to block[n-1].
+        data += cbc_byte_count;
+    }
+
+    // Save block[n] to use as IV when decrypting block[n-1].
+    unsigned char block_n[AES_BLOCK_SIZE];
+    memset(block_n, 0, AES_BLOCK_SIZE);
+    memcpy(block_n, data + AES_BLOCK_SIZE, cts_byte_count);
+
+    // Decrypt block[n-1] using block[n] as IV, consistent with the original
+    // block order.
+    AES_cbc_encrypt(data, data, AES_BLOCK_SIZE, &key, block_n, 0);
+
+    // Return the stolen ciphertext: swap the high-order bytes of block[n]
+    // and block[n-1].
+    for (int i = 0; i < cts_byte_count; i++) {
+        unsigned char temp = *(data + i);
+        *(data + i) = *(data + AES_BLOCK_SIZE + i);
+        *(data + AES_BLOCK_SIZE + i) = temp;
+    }
+
+    // Decrypt block[n-1] using previous IV.
+    AES_cbc_encrypt(data, data, AES_BLOCK_SIZE, &key, iv, 0);
+    return OK;
+}
+
+// PES header and ECM stream header layout
+//
+// processECM() receives the data_byte portion from the transport packet.
+// Below is the layout of the first 16 bytes of the ECM PES packet. Here
+// we don't parse them, we skip them and go to the ECM container directly.
+// The layout is included here only for reference.
+//
+// 0-2:   0x00 00 01 = start code prefix.
+// 3:     0xf0 = stream type (90 = ECM).
+// 4-5:   0x00 00 = PES length (filled in later, this is the length of the
+//                  PES header (16) plus the length of the ECM container).
+// 6-7:   0x00 00 = ECM major version.
+// 8-9:   0x00 01 = ECM minor version.
+// 10-11: 0x00 00 = Crypto period ID (filled in later).
+// 12-13: 0x00 00 = ECM container length (filled in later, either 84 or
+// 166).
+// 14-15: 0x00 00 = offset = 0.
+
+const static size_t kEcmHeaderLength = 16;
+const static size_t kUserKeyLength = 16;
+
+status_t ClearKeyCasSession::updateECM(
+        KeyFetcher *keyFetcher, void *ecm, size_t size) {
+    if (keyFetcher == nullptr) {
+        return ERROR_DRM_NOT_PROVISIONED;
+    }
+
+    if (size < kEcmHeaderLength) {
+        ALOGE("updateECM: invalid ecm size %zu", size);
+        return BAD_VALUE;
+    }
+
+    Mutex::Autolock _lock(mKeyLock);
+
+    if (mEcmBuffer != NULL && mEcmBuffer->capacity() == size
+            && !memcmp(mEcmBuffer->base(), ecm, size)) {
+        return OK;
+    }
+
+    mEcmBuffer = ABuffer::CreateAsCopy(ecm, size);
+    mEcmBuffer->setRange(kEcmHeaderLength, size - kEcmHeaderLength);
+
+    uint64_t asset_id;
+    std::vector<KeyFetcher::KeyInfo> keys;
+    status_t err = keyFetcher->ObtainKey(mEcmBuffer, &asset_id, &keys);
+    if (err != OK) {
+        ALOGE("updateECM: failed to obtain key (err=%d)", err);
+        return err;
+    }
+
+    ALOGV("updateECM: %zu key(s) found", keys.size());
+    for (size_t keyIndex = 0; keyIndex < keys.size(); keyIndex++) {
+        String8 str;
+
+        const sp<ABuffer>& keyBytes = keys[keyIndex].key_bytes;
+        CHECK(keyBytes->size() == kUserKeyLength);
+
+        int result = AES_set_decrypt_key(
+                reinterpret_cast<const uint8_t*>(keyBytes->data()),
+                AES_BLOCK_SIZE * 8, &mKeyInfo[keyIndex].contentKey);
+        mKeyInfo[keyIndex].valid = (result == 0);
+        if (!mKeyInfo[keyIndex].valid) {
+            ALOGE("updateECM: failed to set key %d, key_id=%d",
+                    keyIndex, keys[keyIndex].key_id);
+        }
+    }
+    return OK;
+}
+
+// Decryption of a set of sub-samples
+ssize_t ClearKeyCasSession::decrypt(
+        bool secure, DescramblerPlugin::ScramblingControl scramblingControl,
+        size_t numSubSamples, const DescramblerPlugin::SubSample *subSamples,
+        const void *srcPtr, void *dstPtr, AString * /* errorDetailMsg */) {
+    AES_KEY contentKey;
+
+    if (scramblingControl != DescramblerPlugin::kScrambling_Unscrambled) {
+        // Hold lock to get the key only to avoid contention for decryption
+        Mutex::Autolock _lock(mKeyLock);
+
+        int32_t keyIndex = (scramblingControl & 1);
+        if (!mKeyInfo[keyIndex].valid) {
+            ALOGE("decrypt: key %d is invalid", keyIndex);
+            return ERROR_DRM_DECRYPT;
+        }
+        contentKey = mKeyInfo[keyIndex].contentKey;
+    }
+
+    uint8_t *src = (uint8_t*)srcPtr;
+    uint8_t *dst = (uint8_t*)dstPtr;
+
+    for (size_t i = 0; i < numSubSamples; i++) {
+        size_t numBytesinSubSample = subSamples[i].mNumBytesOfClearData
+                + subSamples[i].mNumBytesOfEncryptedData;
+        if (src != dst) {
+            memcpy(dst, src, numBytesinSubSample);
+        }
+        status_t err = OK;
+        // Don't decrypt if len < AES_BLOCK_SIZE.
+        // The last chunk shorter than AES_BLOCK_SIZE is not encrypted.
+        if (scramblingControl != DescramblerPlugin::kScrambling_Unscrambled
+                && subSamples[i].mNumBytesOfEncryptedData >= AES_BLOCK_SIZE) {
+            err = decryptPayload(
+                    contentKey,
+                    numBytesinSubSample,
+                    subSamples[i].mNumBytesOfClearData,
+                    (char *)dst);
+        }
+
+        dst += numBytesinSubSample;
+        src += numBytesinSubSample;
+    }
+    return dst - (uint8_t *)dstPtr;
+}
+
+// Decryption of a TS payload
+status_t ClearKeyCasSession::decryptPayload(
+        const AES_KEY& key, size_t length, size_t offset, char* buffer) const {
+    CHECK(buffer);
+
+    // Invariant: only call decryptPayload with TS packets with at least 16
+    // bytes of payload (AES_BLOCK_SIZE).
+
+    CHECK(length >= offset + AES_BLOCK_SIZE);
+
+    return TpBlockCtsDecrypt(key, length - offset, buffer + offset);
+}
+
+///////////////////////////////////////////////////////////////////////////
+#undef LOG_TAG
+#define LOG_TAG "ClearKeyDescramblerPlugin"
+
+bool ClearKeyDescramblerPlugin::requiresSecureDecoderComponent(
+        const char *mime) const {
+    ALOGV("requiresSecureDecoderComponent: mime=%s", mime);
+    return false;
+}
+
+status_t ClearKeyDescramblerPlugin::setMediaCasSession(
+        const CasSessionId &sessionId) {
+    ALOGV("setMediaCasSession: sessionId=%s", sessionIdToString(sessionId).string());
+
+    sp<ClearKeyCasSession> session =
+            ClearKeySessionLibrary::get()->findSession(sessionId);
+
+    if (session == NULL) {
+        ALOGE("ClearKeyDescramblerPlugin: session not found");
+        return ERROR_DRM_SESSION_NOT_OPENED;
+    }
+
+    mCASSession = session;
+    return OK;
+}
+
+ssize_t ClearKeyDescramblerPlugin::descramble(
+        bool secure,
+        ScramblingControl scramblingControl,
+        size_t numSubSamples,
+        const SubSample *subSamples,
+        const void *srcPtr,
+        int32_t srcOffset,
+        void *dstPtr,
+        int32_t dstOffset,
+        AString *errorDetailMsg) {
+
+    ALOGV("descramble: secure=%d, sctrl=%d, subSamples=%s, "
+            "srcPtr=%p, dstPtr=%p, srcOffset=%d, dstOffset=%d",
+          (int)secure, (int)scramblingControl,
+          subSamplesToString(subSamples, numSubSamples).string(),
+          srcPtr, dstPtr, srcOffset, dstOffset);
+
+    if (mCASSession == NULL) {
+        ALOGE("Uninitialized CAS session!");
+        return ERROR_DRM_DECRYPT_UNIT_NOT_INITIALIZED;
+    }
+
+    return mCASSession->decrypt(
+            secure, scramblingControl,
+            numSubSamples, subSamples,
+            (uint8_t*)srcPtr + srcOffset,
+            dstPtr == NULL ? NULL : ((uint8_t*)dstPtr + dstOffset),
+            errorDetailMsg);
+}
+
+// Conversion utilities
+String8 ClearKeyDescramblerPlugin::arrayToString(
+        uint8_t const *array, size_t len) const
+{
+    String8 result("{ ");
+    for (size_t i = 0; i < len; i++) {
+        result.appendFormat("0x%02x ", array[i]);
+    }
+    result += "}";
+    return result;
+}
+
+String8 ClearKeyDescramblerPlugin::subSamplesToString(
+        SubSample const *subSamples, size_t numSubSamples) const
+{
+    String8 result;
+    for (size_t i = 0; i < numSubSamples; i++) {
+        result.appendFormat("[%zu] {clear:%u, encrypted:%u} ", i,
+                            subSamples[i].mNumBytesOfClearData,
+                            subSamples[i].mNumBytesOfEncryptedData);
+    }
+    return result;
+}
+
+} // namespace clearkeycas
+} // namespace android
diff --git a/drm/mediacas/plugins/clearkey/ClearKeyCasPlugin.h b/drm/mediacas/plugins/clearkey/ClearKeyCasPlugin.h
new file mode 100644
index 0000000..8cf9b90
--- /dev/null
+++ b/drm/mediacas/plugins/clearkey/ClearKeyCasPlugin.h
@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 2017 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 CLEARKEY_CAS_PLUGIN_H_
+#define CLEARKEY_CAS_PLUGIN_H_
+
+#include <media/cas/CasAPI.h>
+#include <media/cas/DescramblerAPI.h>
+#include <utils/Mutex.h>
+#include <utils/StrongPointer.h>
+
+extern "C" {
+      android::CasFactory *createCasFactory();
+      android::DescramblerFactory *createDescramblerFactory();
+}
+
+namespace android {
+namespace clearkeycas {
+
+class KeyFetcher;
+class ClearKeyCasSession;
+
+class ClearKeyCasFactory : public CasFactory {
+public:
+    ClearKeyCasFactory() {}
+    virtual ~ClearKeyCasFactory() {}
+
+    virtual bool isSystemIdSupported(
+            int32_t CA_system_id) const override;
+    virtual status_t queryPlugins(
+            std::vector<CasPluginDescriptor> *descriptors) const override;
+    virtual status_t createPlugin(
+            int32_t CA_system_id,
+            uint64_t appData,
+            CasPluginCallback callback,
+            CasPlugin **plugin) override;
+};
+
+class ClearKeyDescramblerFactory : public DescramblerFactory {
+public:
+    ClearKeyDescramblerFactory() {}
+    virtual ~ClearKeyDescramblerFactory() {}
+
+    virtual bool isSystemIdSupported(
+            int32_t CA_system_id) const override;
+    virtual status_t createPlugin(
+            int32_t CA_system_id, DescramblerPlugin **plugin) override;
+};
+
+class ClearKeyCasPlugin : public CasPlugin {
+public:
+    ClearKeyCasPlugin(uint64_t appData, CasPluginCallback callback);
+    virtual ~ClearKeyCasPlugin();
+
+    virtual status_t setPrivateData(
+            const CasData &data) override;
+
+    virtual status_t openSession(
+            uint16_t program_number, CasSessionId *sessionId) override;
+
+    virtual status_t openSession(
+            uint16_t program_number,
+            uint16_t elementary_PID,
+            CasSessionId *sessionId) override;
+
+    virtual status_t closeSession(
+            const CasSessionId &sessionId) override;
+
+    virtual status_t setSessionPrivateData(
+            const CasSessionId &sessionId,
+            const CasData &data) override;
+
+    virtual status_t processEcm(
+            const CasSessionId &sessionId, const CasEcm &ecm) override;
+
+    virtual status_t processEmm(const CasEmm &emm) override;
+
+    virtual status_t sendEvent(
+            int32_t event, int32_t arg, const CasData &eventData) override;
+
+    virtual status_t provision(const String8 &str) override;
+
+    virtual status_t refreshEntitlements(
+            int32_t refreshType, const CasData &refreshData) override;
+
+private:
+    Mutex mKeyFetcherLock;
+    std::unique_ptr<KeyFetcher> mKeyFetcher;
+    CasPluginCallback mCallback;
+    uint64_t mAppData;
+};
+
+class ClearKeyDescramblerPlugin : public DescramblerPlugin {
+public:
+    ClearKeyDescramblerPlugin() {}
+    virtual ~ClearKeyDescramblerPlugin() {};
+
+    virtual bool requiresSecureDecoderComponent(
+            const char *mime) const override;
+
+    virtual status_t setMediaCasSession(
+            const CasSessionId &sessionId) override;
+
+    virtual ssize_t descramble(
+            bool secure,
+            ScramblingControl scramblingControl,
+            size_t numSubSamples,
+            const SubSample *subSamples,
+            const void *srcPtr,
+            int32_t srcOffset,
+            void *dstPtr,
+            int32_t dstOffset,
+            AString *errorDetailMsg) override;
+
+private:
+    sp<ClearKeyCasSession> mCASSession;
+
+    String8 subSamplesToString(
+            SubSample const *subSamples,
+            size_t numSubSamples) const;
+    String8 arrayToString(uint8_t const *array, size_t len) const;
+};
+
+} // namespace clearkeycas
+} // namespace android
+
+#endif // CLEARKEY_CAS_PLUGIN_H_
diff --git a/drm/mediacas/plugins/clearkey/ClearKeyFetcher.cpp b/drm/mediacas/plugins/clearkey/ClearKeyFetcher.cpp
new file mode 100644
index 0000000..210bab3
--- /dev/null
+++ b/drm/mediacas/plugins/clearkey/ClearKeyFetcher.cpp
@@ -0,0 +1,126 @@
+/*
+ * Copyright (C) 2017 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 "ClearKeyFetcher"
+
+#include <algorithm>
+#include <string>
+
+#include "ClearKeyFetcher.h"
+#include "ecm.h"
+#include "LicenseFetcher.h"
+
+#include <media/stagefright/foundation/ADebug.h>
+#include <utils/Log.h>
+
+namespace android {
+namespace clearkeycas {
+
+ClearKeyFetcher::ClearKeyFetcher(
+        std::unique_ptr<LicenseFetcher> license_fetcher) :
+    initialized_(false),
+    license_fetcher_(std::move(license_fetcher)) {
+    CHECK(license_fetcher_);
+}
+
+ClearKeyFetcher::~ClearKeyFetcher() {}
+
+// This is a no-op but other KeyFetcher subclasses require initialization
+// so this is necessary to preserve the contract.
+status_t ClearKeyFetcher::Init() {
+    initialized_ = true;
+    return OK;
+}
+
+status_t ClearKeyFetcher::ObtainKey(const sp<ABuffer>& buffer,
+        uint64_t* asset_id, std::vector<KeyInfo>* keys) {
+    CHECK(asset_id);
+    CHECK(keys);
+    CHECK(initialized_);
+    *asset_id = 0;
+    keys->clear();
+
+    EcmContainer container;
+    status_t status = container.Parse(buffer);
+    if (status != OK) {
+        return status;
+    }
+    ALOGV("descriptor_size=%zu", container.descriptor_size());
+
+    // Sanity check to verify that the BroadcastEncryptor is sending a properly
+    // formed EcmContainer. If it contains two Ecms, the ids should have different
+    // parity (one odd, one even). This does not necessarily affect decryption
+    // but indicates a problem with Ecm generation.
+    if (container.descriptor_size() == 2) {
+        // XOR the least significant bits to verify different parity.
+        bool same_parity = (((container.descriptor(0).id() & 0x01) ^
+                (container.descriptor(1).id() & 0x01)) == 0);
+        if (same_parity) {
+            ALOGW("asset_id=%llu: malformed Ecm, "
+                    "content keys have same parity, id0=%d, id1=%d",
+                    container.descriptor(0).ecm().asset_id(),
+                    container.descriptor(0).id(),
+                    container.descriptor(1).id());
+        }
+    }
+
+    *asset_id = container.descriptor(0).ecm().asset_id();
+
+    // Detect asset_id change. This could be caused by a configuration change
+    // in the BroadcastEncryptor. This is unusual so log it in case it is an
+    // operational mistake. This invalidates the current asset_key causing a
+    // new license to be fetched.
+    // TODO(rkint): test against BroadcastEncryptor to verify what BE sends on
+    // asset_id change. If it sends an EcmContainer with 2 Ecms with different
+    // asset_ids (old and new) then it might be best to prefetch the Emm.
+    if ((asset_.id() != 0) && (*asset_id != asset_.id())) {
+        ALOGW("Asset_id change from %llu to %llu", asset_.id(), *asset_id);
+        asset_.Clear();
+    }
+
+    // Fetch license to get asset_id
+    if (!asset_.has_id()) {
+        status = license_fetcher_->FetchLicense(*asset_id, &asset_);
+        if (status != OK) {
+            *asset_id = 0;
+            return status;
+        }
+        ALOGV("FetchLicense succeeded, has_id=%d", asset_.has_id());
+    }
+    keys->resize(container.descriptor_size());
+
+    for (size_t i = 0; i < container.descriptor_size(); ++i) {
+        status = container.mutable_descriptor(i)->mutable_ecm()->Decrypt(
+                container.descriptor(i).ecm().buffer(), asset_);
+        if (status != OK) {
+            *asset_id = 0;
+            keys->clear();
+            return status;
+        }
+        // TODO: if 2 Ecms have same parity, key from Ecm with higher id
+        // should be keys[1].
+        KeyInfo key;
+        key.key_id = container.descriptor(i).id();
+        key.key_bytes = container.descriptor(i).ecm().content_key();
+
+        keys->at(key.key_id & 1) = key;
+    }
+    return OK;
+}
+
+}  // namespace clearkeycas
+}  // namespace android
diff --git a/drm/mediacas/plugins/clearkey/ClearKeyFetcher.h b/drm/mediacas/plugins/clearkey/ClearKeyFetcher.h
new file mode 100644
index 0000000..d58b9df
--- /dev/null
+++ b/drm/mediacas/plugins/clearkey/ClearKeyFetcher.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2017 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 CLEAR_KEY_FETCHER_H_
+#define CLEAR_KEY_FETCHER_H_
+
+#include <vector>
+
+#include "protos/license_protos.pb.h"
+
+#include <media/stagefright/foundation/ABase.h>
+#include "KeyFetcher.h"
+
+namespace android {
+namespace clearkeycas {
+
+class LicenseFetcher;
+
+class ClearKeyFetcher : public KeyFetcher {
+public:
+    // ClearKeyFetcher takes ownership of |license_fetcher|.
+    explicit ClearKeyFetcher(
+            std::unique_ptr<LicenseFetcher> license_fetcher);
+
+    virtual ~ClearKeyFetcher();
+
+    // Initializes the fetcher. Must be called before ObtainKey.
+    status_t Init() override;
+
+    // Obtains the |asset_id| and |keys| from the Ecm contained in |ecm|.
+    // Returns
+    // - errors returned by EcmContainer::Parse.
+    // - errors returned by ClassicLicenseFetcher::FetchLicense.
+    // - errors returned by Ecm::Decrypt.
+    // |asset_id| and |keys| are owned by the caller and cannot be null.
+    // Init() must have been called.
+    status_t ObtainKey(const sp<ABuffer>& ecm, uint64_t* asset_id,
+            std::vector<KeyInfo>* keys) override;
+
+private:
+    clearkeycas::Asset asset_;
+    bool initialized_;
+    std::unique_ptr<LicenseFetcher> license_fetcher_;
+
+    DISALLOW_EVIL_CONSTRUCTORS(ClearKeyFetcher);
+};
+
+} // namespace clearkeycas
+} // namespace android
+
+#endif  // CLEAR_KEY_FETCHER_H_
diff --git a/drm/mediacas/plugins/clearkey/ClearKeyLicenseFetcher.cpp b/drm/mediacas/plugins/clearkey/ClearKeyLicenseFetcher.cpp
new file mode 100644
index 0000000..603337d
--- /dev/null
+++ b/drm/mediacas/plugins/clearkey/ClearKeyLicenseFetcher.cpp
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2017 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 "ClearKeyLicenseFetcher"
+
+#include "ClearKeyLicenseFetcher.h"
+#include "protos/license_protos.pb.h"
+
+#include <utils/Log.h>
+#include <utils/String8.h>
+#include "JsonAssetLoader.h"
+
+namespace android {
+namespace clearkeycas {
+
+status_t ClearKeyLicenseFetcher::Init(const char *input) {
+    JsonAssetLoader *extractor = new JsonAssetLoader();
+    return extractor->extractAssetFromString(String8(input), &asset_);
+}
+
+status_t ClearKeyLicenseFetcher::FetchLicense(
+        uint64_t /* asset_id */, Asset* asset) {
+    *asset = asset_;
+    return OK;
+}
+
+}  // namespace clearkeycas
+}  // namespace android
diff --git a/drm/mediacas/plugins/clearkey/ClearKeyLicenseFetcher.h b/drm/mediacas/plugins/clearkey/ClearKeyLicenseFetcher.h
new file mode 100644
index 0000000..ebbcbeb
--- /dev/null
+++ b/drm/mediacas/plugins/clearkey/ClearKeyLicenseFetcher.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2017 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 CLEAR_KEY_LICENSE_FETCHER_H_
+#define CLEAR_KEY_LICENSE_FETCHER_H_
+
+#include "KeyFetcher.h"
+#include "LicenseFetcher.h"
+
+namespace android {
+namespace clearkeycas {
+
+class ClearKeyLicenseFetcher : public LicenseFetcher {
+public:
+    ClearKeyLicenseFetcher() {}
+    virtual ~ClearKeyLicenseFetcher() {}
+
+    virtual status_t Init(const char *input);
+
+    virtual status_t FetchLicense(uint64_t asset_id, Asset* asset);
+
+private:
+    Asset asset_;
+};
+
+} // namespace clearkeycas
+} // namespace android
+
+#endif  // CLEAR_KEY_LICENSE_FETCHER_H_
diff --git a/drm/mediacas/plugins/clearkey/ClearKeySessionLibrary.cpp b/drm/mediacas/plugins/clearkey/ClearKeySessionLibrary.cpp
new file mode 100644
index 0000000..4e5f479
--- /dev/null
+++ b/drm/mediacas/plugins/clearkey/ClearKeySessionLibrary.cpp
@@ -0,0 +1,138 @@
+/*
+ * Copyright (C) 2017 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 "ClearKeySessionLibrary"
+#include <utils/Log.h>
+
+#include <media/stagefright/foundation/ABuffer.h>
+#include <media/stagefright/foundation/ADebug.h>
+
+#include "ClearKeySessionLibrary.h"
+
+namespace android {
+namespace clearkeycas {
+
+Mutex ClearKeySessionLibrary::sSingletonLock;
+ClearKeySessionLibrary* ClearKeySessionLibrary::sSingleton = NULL;
+
+inline bool operator < (
+        const SessionInfo& lhs, const SessionInfo& rhs) {
+    if (lhs.plugin < rhs.plugin) return true;
+    else if (lhs.plugin > rhs.plugin) return false;
+
+    if (lhs.program_number < rhs.program_number) return true;
+    else if (lhs.program_number > rhs.program_number) return false;
+
+    return lhs.elementary_PID < rhs.elementary_PID;
+}
+
+ClearKeyCasSession::ClearKeyCasSession(const SessionInfo &info)
+    : mSessionInfo(info) {
+    mKeyInfo[0].valid = mKeyInfo[1].valid = false;
+}
+
+ClearKeyCasSession::~ClearKeyCasSession() {
+}
+
+const SessionInfo& ClearKeyCasSession::getSessionInfo() const {
+    return mSessionInfo;
+}
+
+ClearKeySessionLibrary* ClearKeySessionLibrary::get() {
+    Mutex::Autolock lock(sSingletonLock);
+
+    if (sSingleton == NULL) {
+        ALOGV("Instantiating Session Library Singleton.");
+        sSingleton = new ClearKeySessionLibrary();
+    }
+
+    return sSingleton;
+}
+
+ClearKeySessionLibrary::ClearKeySessionLibrary() : mNextSessionId(1) {}
+
+status_t ClearKeySessionLibrary::addSession(
+        CasPlugin *plugin,
+        uint16_t program_number,
+        uint16_t elementary_PID,
+        CasSessionId *sessionId) {
+    CHECK(sessionId);
+
+    Mutex::Autolock lock(mSessionsLock);
+
+    SessionInfo info = {plugin, program_number, elementary_PID};
+    ssize_t index = mSessionInfoToIDMap.indexOfKey(info);
+    if (index >= 0) {
+        ALOGW("Session already exists: program_number=%u, elementary_PID=%u",
+                program_number, elementary_PID);
+        *sessionId = mSessionInfoToIDMap[index];
+        return OK;
+    }
+
+    sp<ClearKeyCasSession> session = new ClearKeyCasSession(info);
+
+    uint8_t *byteArray = (uint8_t *) &mNextSessionId;
+    sessionId->push_back(byteArray[3]);
+    sessionId->push_back(byteArray[2]);
+    sessionId->push_back(byteArray[1]);
+    sessionId->push_back(byteArray[0]);
+    mNextSessionId++;
+
+    mSessionInfoToIDMap.add(info, *sessionId);
+    mIDToSessionMap.add(*sessionId, session);
+    return OK;
+}
+
+sp<ClearKeyCasSession> ClearKeySessionLibrary::findSession(
+        const CasSessionId& sessionId) {
+    Mutex::Autolock lock(mSessionsLock);
+
+    ssize_t index = mIDToSessionMap.indexOfKey(sessionId);
+    if (index < 0) {
+        return NULL;
+    }
+    return mIDToSessionMap.valueFor(sessionId);
+}
+
+void ClearKeySessionLibrary::destroySession(const CasSessionId& sessionId) {
+    Mutex::Autolock lock(mSessionsLock);
+
+    ssize_t index = mIDToSessionMap.indexOfKey(sessionId);
+    if (index < 0) {
+        return;
+    }
+
+    sp<ClearKeyCasSession> session = mIDToSessionMap.valueAt(index);
+    mSessionInfoToIDMap.removeItem(session->getSessionInfo());
+    mIDToSessionMap.removeItemsAt(index);
+}
+
+void ClearKeySessionLibrary::destroyPlugin(CasPlugin *plugin) {
+    Mutex::Autolock lock(mSessionsLock);
+
+    for (ssize_t index = mSessionInfoToIDMap.size() - 1; index >= 0; index--) {
+        const SessionInfo &info = mSessionInfoToIDMap.keyAt(index);
+        if (info.plugin == plugin) {
+            const CasSessionId &id = mSessionInfoToIDMap.valueAt(index);
+            mIDToSessionMap.removeItem(id);
+            mSessionInfoToIDMap.removeItemsAt(index);
+        }
+    }
+}
+
+} // namespace clearkeycas
+} // namespace android
diff --git a/drm/mediacas/plugins/clearkey/ClearKeySessionLibrary.h b/drm/mediacas/plugins/clearkey/ClearKeySessionLibrary.h
new file mode 100644
index 0000000..ebefa72
--- /dev/null
+++ b/drm/mediacas/plugins/clearkey/ClearKeySessionLibrary.h
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 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 CLEARKEY_SESSION_LIBRARY_H_
+#define CLEARKEY_SESSION_LIBRARY_H_
+
+#include <media/cas/CasAPI.h>
+#include <media/cas/DescramblerAPI.h>
+#include <openssl/aes.h>
+#include <utils/KeyedVector.h>
+#include <utils/Mutex.h>
+#include <utils/RefBase.h>
+
+namespace android {
+struct ABuffer;
+
+namespace clearkeycas {
+class KeyFetcher;
+
+struct SessionInfo {
+    CasPlugin *plugin;
+    uint16_t program_number;
+    uint16_t elementary_PID;
+};
+
+class ClearKeyCasSession : public RefBase {
+public:
+    ssize_t decrypt(
+            bool secure,
+            DescramblerPlugin::ScramblingControl scramblingControl,
+            size_t numSubSamples,
+            const DescramblerPlugin::SubSample *subSamples,
+            const void *srcPtr,
+            void *dstPtr,
+            AString * /* errorDetailMsg */);
+
+    status_t updateECM(KeyFetcher *keyFetcher, void *ecm, size_t size);
+
+private:
+    enum {
+        kNumKeys = 2,
+    };
+    struct KeyInfo {
+        bool valid;
+        AES_KEY contentKey;
+    };
+    sp<ABuffer> mEcmBuffer;
+    Mutex mKeyLock;
+    SessionInfo mSessionInfo;
+    KeyInfo mKeyInfo[kNumKeys];
+
+    friend class ClearKeySessionLibrary;
+
+    explicit ClearKeyCasSession(const SessionInfo &info);
+    virtual ~ClearKeyCasSession();
+    const SessionInfo& getSessionInfo() const;
+    status_t decryptPayload(
+            const AES_KEY& key, size_t length, size_t offset, char* buffer) const;
+
+    DISALLOW_EVIL_CONSTRUCTORS(ClearKeyCasSession);
+};
+
+class ClearKeySessionLibrary {
+public:
+    static ClearKeySessionLibrary* get();
+
+    status_t addSession(
+            CasPlugin *plugin,
+            uint16_t program_number,
+            uint16_t elementary_PID,
+            CasSessionId *sessionId);
+
+    sp<ClearKeyCasSession> findSession(const CasSessionId& sessionId);
+
+    void destroySession(const CasSessionId& sessionId);
+
+    void destroyPlugin(CasPlugin *plugin);
+
+private:
+    static Mutex sSingletonLock;
+    static ClearKeySessionLibrary* sSingleton;
+
+    Mutex mSessionsLock;
+    uint32_t mNextSessionId;
+    KeyedVector<CasSessionId, sp<ClearKeyCasSession>> mIDToSessionMap;
+    KeyedVector<SessionInfo, CasSessionId> mSessionInfoToIDMap;
+
+    ClearKeySessionLibrary();
+    DISALLOW_EVIL_CONSTRUCTORS(ClearKeySessionLibrary);
+};
+
+} // namespace clearkeycas
+} // namespace android
+
+#endif // CLEARKEY_SESSION_LIBRARY_H_
diff --git a/drm/mediacas/plugins/clearkey/JsonAssetLoader.cpp b/drm/mediacas/plugins/clearkey/JsonAssetLoader.cpp
new file mode 100644
index 0000000..9cd77e9
--- /dev/null
+++ b/drm/mediacas/plugins/clearkey/JsonAssetLoader.cpp
@@ -0,0 +1,234 @@
+
+/*
+ * Copyright (C) 2017 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 "JsonAssetLoader"
+
+#include <media/stagefright/foundation/ABuffer.h>
+#include <media/stagefright/foundation/AString.h>
+#include <media/stagefright/foundation/base64.h>
+#include <media/stagefright/MediaErrors.h>
+#include <utils/Log.h>
+
+#include "JsonAssetLoader.h"
+#include "protos/license_protos.pb.h"
+
+namespace android {
+namespace clearkeycas {
+
+const String8 kIdTag("id");
+const String8 kNameTag("name");
+const String8 kLowerCaseOgranizationNameTag("lowercase_organization_name");
+const String8 kEncryptionKeyTag("encryption_key");
+const String8 kCasTypeTag("cas_type");
+const String8 kBase64Padding("=");
+
+const uint32_t kKeyLength = 16;
+
+JsonAssetLoader::JsonAssetLoader() {
+}
+
+JsonAssetLoader::~JsonAssetLoader() {
+}
+
+/*
+ * Extract a clear key asset from a JSON string.
+ *
+ * Returns OK if a clear key asset is extracted successfully,
+ * or ERROR_DRM_NO_LICENSE if the string doesn't contain a valid
+ * clear key asset.
+ */
+status_t JsonAssetLoader::extractAssetFromString(
+        const String8& jsonAssetString, Asset *asset) {
+    if (!parseJsonAssetString(jsonAssetString, &mJsonObjects)) {
+        return ERROR_DRM_NO_LICENSE;
+    }
+
+    if (mJsonObjects.size() < 1) {
+        return ERROR_DRM_NO_LICENSE;
+    }
+
+    if (!parseJsonObject(mJsonObjects[0], &mTokens))
+        return ERROR_DRM_NO_LICENSE;
+
+    if (!findKey(mJsonObjects[0], asset)) {
+        return ERROR_DRM_NO_LICENSE;
+    }
+    return OK;
+}
+
+//static
+sp<ABuffer> JsonAssetLoader::decodeBase64String(const String8& encodedText) {
+    // Since android::decodeBase64() requires padding characters,
+    // add them so length of encodedText is exactly a multiple of 4.
+    int remainder = encodedText.length() % 4;
+    String8 paddedText(encodedText);
+    if (remainder > 0) {
+        for (int i = 0; i < 4 - remainder; ++i) {
+            paddedText.append(kBase64Padding);
+        }
+    }
+
+    return decodeBase64(AString(paddedText.string()));
+}
+
+bool JsonAssetLoader::findKey(const String8& jsonObject, Asset *asset) {
+
+    String8 value;
+
+    if (jsonObject.find(kIdTag) < 0) {
+        return false;
+    }
+    findValue(kIdTag, &value);
+    ALOGV("found %s=%s", kIdTag.string(), value.string());
+    asset->set_id(atoi(value.string()));
+
+    if (jsonObject.find(kNameTag) < 0) {
+        return false;
+    }
+    findValue(kNameTag, &value);
+    ALOGV("found %s=%s", kNameTag.string(), value.string());
+    asset->set_name(value.string());
+
+    if (jsonObject.find(kLowerCaseOgranizationNameTag) < 0) {
+        return false;
+    }
+    findValue(kLowerCaseOgranizationNameTag, &value);
+    ALOGV("found %s=%s", kLowerCaseOgranizationNameTag.string(), value.string());
+    asset->set_lowercase_organization_name(value.string());
+
+    if (jsonObject.find(kCasTypeTag) < 0) {
+        return false;
+    }
+    findValue(kCasTypeTag, &value);
+    ALOGV("found %s=%s", kCasTypeTag.string(), value.string());
+    // Asset_CasType_CLEARKEY_CAS = 1
+    asset->set_cas_type((Asset_CasType)atoi(value.string()));
+
+    return true;
+}
+
+void JsonAssetLoader::findValue(const String8 &key, String8* value) {
+    value->clear();
+    const char* valueToken;
+    for (Vector<String8>::const_iterator nextToken = mTokens.begin();
+        nextToken != mTokens.end(); ++nextToken) {
+        if (0 == (*nextToken).compare(key)) {
+            if (nextToken + 1 == mTokens.end())
+                break;
+            valueToken = (*(nextToken + 1)).string();
+            value->setTo(valueToken);
+            nextToken++;
+            break;
+        }
+    }
+}
+
+/*
+ * Parses a JSON objects string and initializes a vector of tokens.
+ *
+ * @return Returns false for errors, true for success.
+ */
+bool JsonAssetLoader::parseJsonObject(const String8& jsonObject,
+        Vector<String8>* tokens) {
+    jsmn_parser parser;
+
+    jsmn_init(&parser);
+    int numTokens = jsmn_parse(&parser,
+        jsonObject.string(), jsonObject.size(), NULL, 0);
+    if (numTokens < 0) {
+        ALOGE("Parser returns error code=%d", numTokens);
+        return false;
+    }
+
+    unsigned int jsmnTokensSize = numTokens * sizeof(jsmntok_t);
+    mJsmnTokens.clear();
+    mJsmnTokens.setCapacity(jsmnTokensSize);
+
+    jsmn_init(&parser);
+    int status = jsmn_parse(&parser, jsonObject.string(),
+        jsonObject.size(), mJsmnTokens.editArray(), numTokens);
+    if (status < 0) {
+        ALOGE("Parser returns error code=%d", status);
+        return false;
+    }
+
+    tokens->clear();
+    String8 token;
+    const char *pjs;
+    ALOGV("numTokens: %d", numTokens);
+    for (int j = 0; j < numTokens; ++j) {
+        pjs = jsonObject.string() + mJsmnTokens[j].start;
+        if (mJsmnTokens[j].type == JSMN_STRING ||
+                mJsmnTokens[j].type == JSMN_PRIMITIVE) {
+            token.setTo(pjs, mJsmnTokens[j].end - mJsmnTokens[j].start);
+            tokens->add(token);
+            ALOGV("add token: %s", token.string());
+        }
+    }
+    return true;
+}
+
+/*
+ * Parses JSON asset string and initializes a vector of JSON objects.
+ *
+ * @return Returns false for errors, true for success.
+ */
+bool JsonAssetLoader::parseJsonAssetString(const String8& jsonAsset,
+        Vector<String8>* jsonObjects) {
+    if (jsonAsset.isEmpty()) {
+        ALOGE("Empty JSON Web Key");
+        return false;
+    }
+
+    // The jsmn parser only supports unicode encoding.
+    jsmn_parser parser;
+
+    // Computes number of tokens. A token marks the type, offset in
+    // the original string.
+    jsmn_init(&parser);
+    int numTokens = jsmn_parse(&parser,
+            jsonAsset.string(), jsonAsset.size(), NULL, 0);
+    if (numTokens < 0) {
+        ALOGE("Parser returns error code=%d", numTokens);
+        return false;
+    }
+
+    unsigned int jsmnTokensSize = numTokens * sizeof(jsmntok_t);
+    mJsmnTokens.setCapacity(jsmnTokensSize);
+
+    jsmn_init(&parser);
+    int status = jsmn_parse(&parser, jsonAsset.string(),
+            jsonAsset.size(), mJsmnTokens.editArray(), numTokens);
+    if (status < 0) {
+        ALOGE("Parser returns error code=%d", status);
+        return false;
+    }
+
+    String8 token;
+    const char *pjs;
+    for (int i = 0; i < numTokens; ++i) {
+        pjs = jsonAsset.string() + mJsmnTokens[i].start;
+        if (mJsmnTokens[i].type == JSMN_OBJECT) {
+            token.setTo(pjs, mJsmnTokens[i].end - mJsmnTokens[i].start);
+            jsonObjects->add(token);
+        }
+    }
+    return true;
+}
+
+}  // namespace clearkeycas
+}  // namespace android
diff --git a/drm/mediacas/plugins/clearkey/JsonAssetLoader.h b/drm/mediacas/plugins/clearkey/JsonAssetLoader.h
new file mode 100644
index 0000000..06f9389
--- /dev/null
+++ b/drm/mediacas/plugins/clearkey/JsonAssetLoader.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2014 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 JSON_ASSET_LOADER_H_
+#define JSON_ASSET_LOADER_H_
+
+#include <media/stagefright/foundation/ABase.h>
+#include <utils/KeyedVector.h>
+#include <utils/String8.h>
+#include <utils/StrongPointer.h>
+#include "protos/license_protos.pb.h"
+
+#include "jsmn.h"
+
+namespace android {
+struct ABuffer;
+
+namespace clearkeycas {
+
+class JsonAssetLoader {
+ public:
+    JsonAssetLoader();
+    virtual ~JsonAssetLoader();
+
+    status_t extractAssetFromString(
+            const String8& jsonAssetString, Asset *asset);
+
+ private:
+    Vector<jsmntok_t> mJsmnTokens;
+    Vector<String8> mJsonObjects;
+    Vector<String8> mTokens;
+
+    static sp<ABuffer> decodeBase64String(
+            const String8& encodedText);
+    bool findKey(const String8& jsonObject, Asset *asset);
+    void findValue(
+            const String8 &key, String8* value);
+    bool parseJsonObject(
+            const String8& jsonObject, Vector<String8>* tokens);
+    bool parseJsonAssetString(
+            const String8& jsonString, Vector<String8>* jsonObjects);
+
+    DISALLOW_EVIL_CONSTRUCTORS(JsonAssetLoader);
+};
+
+}  // namespace clearkeycas
+}  // namespace android
+
+#endif  // JSON_ASSET_LOADER_H_
diff --git a/drm/mediacas/plugins/clearkey/KeyFetcher.h b/drm/mediacas/plugins/clearkey/KeyFetcher.h
new file mode 100644
index 0000000..83fe50a
--- /dev/null
+++ b/drm/mediacas/plugins/clearkey/KeyFetcher.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2017 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 KEY_FETCHER_H_
+#define KEY_FETCHER_H_
+
+#include <vector>
+
+#include <media/stagefright/foundation/ABuffer.h>
+#include <utils/Errors.h>
+
+using namespace std;
+
+namespace android {
+namespace clearkeycas {
+
+// Interface for classes which extract the content key from an Ecm.
+class KeyFetcher {
+public:
+    struct KeyInfo {
+        sp<ABuffer> key_bytes;
+        int key_id;
+    };
+
+    KeyFetcher() {}
+    virtual ~KeyFetcher() {}
+
+    // Initializes resources set in subclass-specific calls. This must be called
+    // before threads are started.
+    virtual status_t Init() = 0;
+
+    // Obtains content key(s) based on contents of |ecm|. |asset_id| is the
+    // internal id of the asset, |keys| is a vector containing instances of a
+    // class containing a content key and an id. |asset_id| and |keys| are
+    // owned by the caller and must be non-null.
+    virtual status_t ObtainKey(const sp<ABuffer>& ecm,
+            uint64_t* asset_id, vector<KeyInfo>* keys) = 0;
+};
+
+}  // namespace clearkeycas
+}  // namespace android
+
+#endif  // KEY_FETCHER_H_
diff --git a/drm/mediacas/plugins/clearkey/LicenseFetcher.h b/drm/mediacas/plugins/clearkey/LicenseFetcher.h
new file mode 100644
index 0000000..2a33dd8
--- /dev/null
+++ b/drm/mediacas/plugins/clearkey/LicenseFetcher.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2017 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 LICENSE_FETCHER_H_
+#define LICENSE_FETCHER_H_
+
+#include "protos/license_protos.pb.h"
+#include <media/stagefright/foundation/ABase.h>
+
+namespace android {
+namespace clearkeycas {
+
+// Interface for classes which request a license.
+class LicenseFetcher {
+public:
+    LicenseFetcher() {}
+    virtual ~LicenseFetcher() {}
+
+    // Initializes resources set in subclass-specific calls. This must be called
+    // before threads are started.
+    virtual status_t Init(const char *input) = 0;
+
+    // Fetches license based on |asset_id|.  On return, |asset| contains the
+    // decrypted asset_key needed to decrypt content keys.
+    // |asset| must be non-null.
+    virtual status_t FetchLicense(
+            uint64_t asset_id, clearkeycas::Asset* asset) = 0;
+
+private:
+    DISALLOW_EVIL_CONSTRUCTORS(LicenseFetcher);
+};
+
+}  // namespace clearkeycas
+}  // namespace android
+
+#endif  // LICENSE_FETCHER_H_
diff --git a/drm/mediacas/plugins/clearkey/ecm.cpp b/drm/mediacas/plugins/clearkey/ecm.cpp
new file mode 100644
index 0000000..9fde13a
--- /dev/null
+++ b/drm/mediacas/plugins/clearkey/ecm.cpp
@@ -0,0 +1,188 @@
+/*
+ * Copyright (C) 2017 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 "ecm"
+
+#include "ecm.h"
+#include "ecm_generator.h"
+#include "protos/license_protos.pb.h"
+
+#include <media/stagefright/foundation/ADebug.h>
+#include <media/stagefright/MediaErrors.h>
+#include <utils/Log.h>
+
+namespace android {
+namespace clearkeycas {
+
+Ecm::Ecm()
+    : asset_id_(0),
+      asset_id_set_(false),
+      system_id_(0),
+      system_id_set_(false) {}
+
+Ecm::~Ecm() {}
+
+status_t Ecm::Parse(const sp<ABuffer>& buffer_as_binary) {
+    if (buffer_as_binary->size() < kSizeBytes) {
+        ALOGE("Short Ecm buffer: expected %zu, received %zu.",
+                kSizeBytes, buffer_as_binary->size());
+        return BAD_VALUE;
+    }
+
+    Asset asset;
+    ecm_generator::DefaultEcmFields default_fields;
+    status_t status = ecm_generator::DecodeECMClearFields(
+            buffer_as_binary, &asset, &default_fields);
+    if (status != OK) {
+        ALOGE("DecodeECMClearFields failed with status %d", status);
+        return status;
+    }
+    set_asset_id(asset.id());
+    set_system_id(default_fields.system_id);
+
+    // Save a copy of the buffer_as_binary for a future DecryptEcm call.
+    set_buffer(buffer_as_binary);
+    return OK;
+}
+
+status_t Ecm::Decrypt(
+        const sp<ABuffer>& buffer_as_binary,
+        const Asset& asset_from_emm) {
+    // Invariant: asset has id. These are postconditions for Emm::Decrypt().
+    CHECK(asset_from_emm.has_id());
+
+    // DecodeEcm fills in |asset|.id() with the asset_id from the encoded Ecm.
+    Asset asset(asset_from_emm);
+    ecm_generator::DefaultEcmFields default_fields;
+    sp<ABuffer> content_key;
+    status_t status = ecm_generator::DecodeECM(
+            buffer_as_binary, &asset, &content_key, &default_fields);
+    if (status != OK) {
+        ALOGE("DecodeECM failed with status %d", status);
+        return status;
+    }
+    if (asset.id() != asset_from_emm.id()) {
+        ALOGE("Asset_id from Emm (%llu) does not match asset_id from Ecm (%llu).",
+                asset_from_emm.id(), asset.id());
+        return CLEARKEY_STATUS_INVALID_PARAMETER;
+    }
+    set_asset_id(asset.id());
+    set_system_id(default_fields.system_id);
+    set_content_key(content_key);
+    return status;
+}
+
+EcmDescriptor::EcmDescriptor() : ecm_set_(false), id_(0), id_set_(false) {}
+
+EcmDescriptor::EcmDescriptor(uint16_t id, const Ecm& ecm)
+: ecm_(ecm), ecm_set_(true), id_(id), id_set_(true) {}
+
+EcmDescriptor::~EcmDescriptor() {}
+
+status_t EcmDescriptor::Parse(const sp<ABuffer>& buffer_as_binary) {
+    if (buffer_as_binary->size() < kSizeBytes) {
+        ALOGE("Short EcmDescriptor buffer: expected %zu, received %zu.",
+                kSizeBytes, buffer_as_binary->size());
+        return BAD_VALUE;
+    }
+    sp<ABuffer> id_buffer = new ABuffer(buffer_as_binary->data(), kIdSizeBytes);
+    const uint8_t *id_bytes = id_buffer->data();
+    uint16_t id = (id_bytes[0] << 8) | id_bytes[1];
+    set_id(id);
+
+    // Unmarshall the contained Ecm.
+    sp<ABuffer> ecm_buffer = new ABuffer(
+            buffer_as_binary->data() + kIdSizeBytes, Ecm::kSizeBytes);
+    status_t status = mutable_ecm()->Parse(ecm_buffer);
+    if (status != OK) {
+        return status;
+    }
+    return OK;
+}
+
+EcmContainer::EcmContainer() : count_(0), count_set_(false) {}
+
+EcmContainer::~EcmContainer() {}
+
+status_t EcmContainer::Add(const EcmDescriptor& descriptor) {
+    switch (count_) {
+    case 0:
+        descriptor_[0] = descriptor;
+        count_ = 1;
+        break;
+    case 1:
+        descriptor_[1] = descriptor;
+        count_ = 2;
+        break;
+    case 2:
+        descriptor_[0] = descriptor_[1];
+        descriptor_[1] = descriptor;
+        break;
+    default:
+        ALOGE("Bad state.");
+        return INVALID_OPERATION;
+    }
+    count_set_ = true;
+    return OK;
+}
+
+status_t EcmContainer::Parse(const sp<ABuffer>& buffer_as_binary) {
+    // EcmContainer can contain 1 or 2 EcmDescriptors so this is a check for
+    // minimum size.
+    if (buffer_as_binary->size() < kMinimumSizeBytes) {
+        ALOGE("Short EcmContainer buffer: expected >= %zu, received %zu.",
+                kMinimumSizeBytes, buffer_as_binary->size());
+        return BAD_VALUE;
+    }
+
+    sp<ABuffer> count_buffer = new ABuffer(
+            buffer_as_binary->data(), kCountSizeBytes);
+    const uint8_t *count_bytes = count_buffer->data();
+    size_t count = (count_bytes[0] << 8) | count_bytes[1];
+    // Check that count is a legal value.
+    if (!CountLegal(count)) {
+        ALOGE("Invalid descriptor count: expected %zu <= count <= %zu, received %zu.",
+                kMinDescriptorCount, kMaxDescriptorCount, count);
+        return ERROR_OUT_OF_RANGE;
+    }
+    // If needed, check that buffer_as_binary can hold 2 EcmDescriptors.
+    if (count > kMinDescriptorCount) {
+        size_t expected_bytes =
+                kCountSizeBytes + (count * EcmDescriptor::kSizeBytes);
+        if (buffer_as_binary->size() < expected_bytes) {
+            ALOGE("Short EcmContainer buffer: expected %zu, received %zu.",
+                    expected_bytes, buffer_as_binary->size());
+            return BAD_VALUE;
+        }
+    }
+    set_count(count);
+    // Unmarshall the contained EcmDescriptors.
+    size_t offset = kCountSizeBytes;
+    for (size_t i = 0; i < count_; ++i) {
+        sp<ABuffer> descriptor_buffer = new ABuffer(
+                buffer_as_binary->data() + offset, EcmDescriptor::kSizeBytes);
+        status_t status = mutable_descriptor(i)->Parse(descriptor_buffer);
+        if (status != OK) {
+            return status;
+        }
+        offset += EcmDescriptor::kSizeBytes;
+    }
+    return OK;
+}
+
+}  // namespace clearkeycas
+}  // namespace android
diff --git a/drm/mediacas/plugins/clearkey/ecm.h b/drm/mediacas/plugins/clearkey/ecm.h
new file mode 100644
index 0000000..aef8afb
--- /dev/null
+++ b/drm/mediacas/plugins/clearkey/ecm.h
@@ -0,0 +1,343 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+// Data objects encapsulating the clear key Ecm (Entitlement Control
+// Message) and related container messages. Deserialization and decryption
+// are handled externally to reduce build-time dependencies.
+//
+// Simplified typical client-side use:
+//   Asset asset; // from the AssetRegistry.
+//   uint8[] ecm_buffer; // received over network, contains an EcmContainer.
+//   EcmContainer ecm_container;
+//   util::Status status = ecm_container.Parse(ecm_buffer);
+//   status = ecm_container.descriptor(1).ecm().Decrypt(
+//      ecm_container.descriptor(1).ecm().buffer(), asset_key);
+//   string content_key;
+//   if (ecm_container.descriptor(1).ecm().has_content_key()) {
+//     content_key = ecm_container.descriptor(1).ecm().content_key();
+//   }
+//   // use |content_key| to decrypt content.
+//
+// Simplified typical server-side use:
+//   EcmContainer container;
+//   string encoded_ecm;
+//   // Use the ecm_generator API to encode and encrypt an ECM from data fields.
+//   util::Status status = ecm_generator::EncodeECM(..., &encoded_ecm);
+//   // Use |encoded_ecm| to initialized the Ecm from this library.
+//   Ecm ecm;
+//   util::Status status = ecm.Parse(encoded_ecm);
+//   EcmDescriptor descriptor(crypto_period_id, ecm);
+//   status = container.Add(descriptor);
+//   string serialized_container;
+//   status = container.Marshall(&serialized_container);
+//   // now |serialized_container| can be sent to the STB.
+//
+// Due to past overloading of the term "ECM" this library introduces some
+// new terminology.
+//
+// Ecm: the 32-byte message sent from the head end to a packager that contains
+// the asset_id, system_id, and content_key (clear).
+//
+// EcmDescriptor: contains an Ecm and an id (the crypto period id in the case
+// of the BroadcastEncryptor). It contains no encrypted fields.
+//
+// EcmContainer: sent by the server in the video stream using the ECM pid.
+// This contains 1 or 2 EcmDescriptors and a count. It contains no
+// encrypted fields.
+//
+// The first EcmContainer sent by the server has only one EcmDescriptor. After
+// the first crypto period change, an EcmContainer contains 2 EcmDescriptors.
+// One has an odd id and one has an even id. The decrypted content keys from the
+// Ecms in the EcmDescriptors are used by the Mpeg2 parser as odd and even
+// scrambling keys. As the crypto period changes, the oldest EcmDescriptor is
+// dropped from the EcmContainer and the new EcmDescriptor is added.
+//
+// These classes use a simplified protobuf model. For non-repeating fields,
+// - has_foo() indicates whether the field is populated.
+// - the accessor foo() returns either a value or a const reference.
+// - a mutator sets the value.  Primitive types and strings use
+//   set_foo(value) while for objects mutable_foo() returns a pointer.
+//
+// To prevent null references, objects (like the Asset contained in an Emm)
+// are allocated as members and can be accessed via foo() even if they have
+// not been populated. The caller must call has_foo() to make sure that the
+// object is valid. Calling mutable_foo() to obtain a pointer causes has_foo()
+// to return true.
+//
+// Repeated fields (like the EcmDescriptors contained in an EcmContainer) are
+// handled differently.
+// - foo_size() returns the number of instances.
+// - the accessor foo(index) returns either a value or a const reference to
+//   the instance at index. It is illegal to call with |index| >= the value
+//   returned by foo_size(). |index| is checked with CHECK.
+// - a mutator to change the value of the instance.  Primitive types and
+//   strings use set_foo(index, value) while for objects mutable_foo(index)
+//   returns a pointer. It is illegal to call with |index| >= the value
+//   returned by foo_size(). |index| is checked with CHECK.
+//
+// Accessing a repeated field with an invalid index causes CHECK to fail.
+// Be sure to call EcmContainer::decriptor_size() before calling descriptor()
+// or mutable_descriptor()!
+//
+#ifndef CLEAR_KEY_ECM_H_
+#define CLEAR_KEY_ECM_H_
+
+#include <stddef.h>
+#include <string>
+
+#include "protos/license_protos.pb.h"
+
+#include <media/stagefright/foundation/ABase.h>
+#include <media/stagefright/foundation/ABuffer.h>
+#include <utils/Errors.h>
+
+using namespace std;
+
+namespace android {
+namespace clearkeycas {
+
+// Entitlement Control Message. It contains clear fields. The asset_id
+// and system_id as well as the content_key are clear.
+//
+// This class is not thread-safe.
+class Ecm {
+public:
+    // Wire size of ECM.
+    static constexpr size_t kSizeBytes = 16 + 16; // clear fields + clear key
+
+    // Creates an empty ECM which must be initialized via Parse().
+    Ecm();
+
+    ~Ecm();
+
+    // Parses clear fields of Ecm serialized in |buffer_as_binary| and saves
+    // a copy of |buffer_as_binary| for a future DecryptEcm call.
+    // Returns:
+    // - BAD_VALUE if |buffer_as_binary| is too small.
+    // - CLEARKEY_STATUS_INVALIDASSETID via ecm_generator::DecodeEcmClearFields if
+    //   asset_id is 0.
+    // - CLEARKEY_STATUS_INVALIDSYSTEMID via ecm_generator::DecodeEcmClearFields if
+    //   system_id is 0.
+    // Postconditions:
+    // - |asset_id_| and |system_id_| are populated with non-zero values.
+    // - |buffer_| contains a copy of the serialized Ecm.
+    status_t Parse(const sp<ABuffer>& buffer_as_binary);
+
+    // Parses and decrypts Ecm serialized in |buffer_as_binary| using
+    // |asset_from_emm|.asset_key().encryption_key(). It is not necessary to call
+    // Parse() first.
+    // Returns BAD_VALUE if |buffer_as_binary| is too small.
+    // Returns CLEARKEY_STATUS_INVALIDASSETID via
+    //   ecm_generator::DecodeEcmClearFields if asset_id is 0.
+    // Returns CLEARKEY_STATUS_INVALIDSYSTEMID via
+    //   ecm_generator::DecodeEcmClearFields if system_id is 0.
+    // Returns CLEARKEY_STATUS_INVALID_PARAMETER if
+    // - asset_id in |asset_from_emm| does not match asset_id in serialized Ecm.
+    // Preconditions: |asset_from_emm| must contain asset_id and asset_key fields.
+    // Postconditions: asset_id() and system_id() are populated with non-zero
+    // values, content_key() is populated with the clear content key.
+    status_t Decrypt(const sp<ABuffer>& buffer_as_binary,
+            const Asset& asset_from_emm);
+
+    // |buffer_| is a serialized copy of the Ecm used for later decryption or
+    // for marshalling.
+    inline bool has_buffer() const { return buffer_ != NULL; }
+    const sp<ABuffer> buffer() const { return buffer_; }
+    inline void set_buffer(const sp<ABuffer>& buffer) {
+        buffer_ = ABuffer::CreateAsCopy(buffer->data(), buffer->size());
+    }
+
+    // |content_key| is the clear, encryption/decryption key generated by the server.
+    inline bool has_content_key() const { return content_key_ != NULL; }
+    inline void set_content_key(const sp<ABuffer>& value) {
+        content_key_ = ABuffer::CreateAsCopy(value->data(), value->size());
+    }
+    inline const sp<ABuffer> content_key() const { return content_key_; }
+
+    // |asset_id| from the server.
+    inline bool has_asset_id() const { return asset_id_set_; }
+    inline uint64_t asset_id() const { return asset_id_; }
+    inline void set_asset_id(uint64_t value) {
+        asset_id_ = value;
+        asset_id_set_ = true;
+    }
+
+    // |system_id| from the server.
+    inline bool has_system_id() const { return system_id_set_; }
+    inline uint32_t system_id() const { return system_id_; }
+    inline void set_system_id(uint32_t value) {
+        system_id_ = value;
+        system_id_set_ = true;
+    }
+
+private:
+    uint64_t asset_id_;
+    bool asset_id_set_;
+    sp<ABuffer> buffer_;
+    sp<ABuffer> content_key_;
+    uint32_t system_id_;
+    bool system_id_set_;
+};
+
+// Contains an Ecm and and Id.
+// This class is not thread-safe.
+class EcmDescriptor {
+public:
+    // Wire size of Id field.
+    static constexpr size_t kIdSizeBytes = sizeof(uint16_t);
+    // Wire size of EcmDescriptor.
+    static constexpr size_t kSizeBytes = Ecm::kSizeBytes + kIdSizeBytes;
+
+    // Client-side ctor. Populate from a buffer with Parse().
+    EcmDescriptor();
+
+    // Server-side ctor.
+    // Args:
+    // - |id| is the crypto period ID.
+    // - |ecm| is an ECM which must have been intialized with Ecm::Parse().
+    EcmDescriptor(uint16_t id, const Ecm& ecm);
+
+    ~EcmDescriptor();
+
+    // Parses EcmDescriptor and its contained Ecm which are serialized in the
+    // binary string |buffer_as_binary|.
+    // Returns
+    // - BAD_VALUE if |buffer_as_binary| is too short to contain a
+    //   serialized EcmDescriptor.
+    // - Errors returned by Ecm::Parse.
+    // Postconditions:
+    // - id() is populated. Note that 0 is a legal value.
+    // - the clear fields of the contained Ecm have been populated.
+    status_t Parse(const sp<ABuffer>& buffer_as_binary);
+
+    // |id| of the contained Ecm. Typically the crypto period id.
+    inline bool has_id() const { return id_set_; }
+    inline void set_id(uint16_t value) {
+        id_ = value;
+        id_set_ = true;
+    }
+    inline uint16_t id() const { return id_; }
+
+    // The contained |ecm|.
+    inline bool has_ecm() const { return ecm_set_; }
+    inline Ecm* mutable_ecm() {
+        ecm_set_ = true;
+        return &ecm_;
+    }
+    inline const Ecm& ecm() const { return ecm_; }
+
+private:
+    Ecm ecm_;
+    bool ecm_set_;
+    uint16_t id_;
+    bool id_set_;
+};
+
+// Contains a count and 1 or 2 EcmDescriptors. This is included in the video
+// stream by the sender in the ECM pid.
+// This class is not thread-safe.
+class EcmContainer {
+public:
+    // Wire size of the count field.
+    static constexpr size_t kCountSizeBytes = sizeof(uint16_t);
+    // Minimum wire size assuming one EcmDescriptor.
+    static constexpr size_t kMinimumSizeBytes =
+            EcmDescriptor::kSizeBytes + kCountSizeBytes;
+    static constexpr size_t kMinDescriptorCount = 1;
+    static constexpr size_t kMaxDescriptorCount = 2;
+
+    // Creates an empty EcmContainer which must be populated via Parse()
+    // (client-side) or Add() (server-side).
+    EcmContainer();
+
+    ~EcmContainer();
+
+    // Adds an EcmDescriptor for server-side applications.
+    // If |count_| is 2, |descriptor| replaces the oldest EcmDescriptor.
+    //
+    // Returns:
+    // - INTERNAL if the EcmContainer is in a bad state (count != 0, 1, or 2).
+    // Postconditions:
+    // - count() is within bounds (1 or 2).
+    status_t Add(const EcmDescriptor& descriptor);
+
+    // Parses EcmContainer and its contained EcmDescriptors which are serialized
+    // in |buffer_as_binary|.
+    // Returns
+    // - BAD_VALUE if |buffer_as_binary| is too short to contain a
+    //   serialized EcmDescriptor.
+    // - ERROR_OUT_OF_RANGE if the count contained in the serialized EcmContainer
+    //   is not 1 or 2.
+    // - Errors returned by EcmDescriptor::Parse.
+    // Postconditions:
+    // - count() is within bounds (1 or 2) and.
+    // - contained EcmDescriptor(s) parsed and populated.
+    status_t Parse(const sp<ABuffer>& buffer_as_binary);
+
+    inline bool has_count() const { return count_set_; }
+    // Sets the |count| of contained EcmDecriptors. Illegal values are silently
+    // ignored.
+    inline void set_count(size_t count) {
+        if (!CountLegal(count)) return;
+        count_ = count;
+        count_set_ = true;
+    }
+    // Number of contained EcmDecriptors. Only 1 and 2 are legal values.
+    inline size_t count() const { return count_; }
+
+    // Returns the number of allowable descriptors. This is redundant but is
+    // provided for protobuf compatibility.
+    inline size_t descriptor_size() const { return count_; }
+
+    // Returns a pointer to the EcmDescriptor at |index| for valid index values,
+    // otherwise calls CHECK and aborts. Always call descriptor_size() first!
+    inline EcmDescriptor* mutable_descriptor(size_t index) {
+        //CHECK(IndexValid(index));
+        return &descriptor_[index];
+    }
+
+    // Returns a reference to the EcmDescriptor at |index| for valid index
+    // values, otherwise calls CHECK and aborts. Call descriptor_size() first!
+    inline const EcmDescriptor& descriptor(size_t index) const {
+        //CHECK(IndexValid(index));
+        return descriptor_[index];
+    }
+
+private:
+    // Count value must be 1 or 2.
+    inline bool CountLegal(size_t count) const {
+        return count <= kMaxDescriptorCount && count >= kMinDescriptorCount;
+    }
+    // Index must be 0 or 1.
+    inline bool IndexLegal(size_t index) const {
+        return index < kMaxDescriptorCount;
+    }
+    // |index| is valid for this object: it is legal and < count_.
+    inline bool IndexValid(size_t index) const {
+        if (!IndexLegal(index)) return false;
+        return index < count_;
+    }
+    size_t count_;
+    bool count_set_;
+    EcmDescriptor descriptor_[kMaxDescriptorCount];
+
+    DISALLOW_EVIL_CONSTRUCTORS(EcmContainer);
+};
+
+}  // namespace clearkeycas
+}  // namespace android
+
+#endif  // CLEAR_KEY_ECM_H_
diff --git a/drm/mediacas/plugins/clearkey/ecm_generator.cpp b/drm/mediacas/plugins/clearkey/ecm_generator.cpp
new file mode 100644
index 0000000..f1aa973
--- /dev/null
+++ b/drm/mediacas/plugins/clearkey/ecm_generator.cpp
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 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 "ecm_generator"
+#include "ecm_generator.h"
+
+#include <string.h>
+#include <algorithm>
+#include <endian.h>
+
+#include "protos/license_protos.pb.h"
+
+#include <media/stagefright/foundation/ADebug.h>
+#include <media/stagefright/MediaErrors.h>
+#include <openssl/aes.h>
+#include <utils/Log.h>
+
+namespace android {
+namespace clearkeycas {
+
+// These constants are internal to this module.
+const uint16_t kEcmClearFieldsSize = 16;
+const uint32_t kContentKeyByteSize = 16;
+const uint16_t kTotalEcmSize =
+        kEcmClearFieldsSize + kContentKeyByteSize; // clear fields + clear key
+
+const uint32_t kKeyLength = 16;
+
+#define UNALIGNED_LOAD32(_p) (*reinterpret_cast<const uint32_t *>(_p))
+
+static uint32_t Load32(const void *p) {
+    return ntohl(UNALIGNED_LOAD32(p));
+}
+
+static uint32_t LoadNext32(const uint8_t** pptr) {
+    CHECK(pptr);
+    CHECK(*pptr);
+    const uint8_t* p = *pptr;
+    *pptr += sizeof(uint32_t);
+    return Load32(p);
+}
+
+namespace ecm_generator {
+
+status_t DecodeECM(const sp<ABuffer>& ecm, Asset* asset,
+        sp<ABuffer> *content_key, DefaultEcmFields* default_fields) {
+    CHECK(asset);
+    CHECK(content_key);
+    CHECK(default_fields);
+
+    status_t status = DecodeECMClearFields(ecm, asset, default_fields);
+    if (status != OK) {
+        return status;
+    }
+
+    const uint8_t* ptr = ecm->data() + kEcmClearFieldsSize;
+    *content_key = new ABuffer(kContentKeyByteSize);
+    memcpy((*content_key)->data(), ptr, kContentKeyByteSize);
+
+    return OK;
+}
+
+status_t DecodeECMClearFields(const sp<ABuffer>& ecm, Asset* asset,
+        DefaultEcmFields* default_fields) {
+    CHECK(asset);
+    CHECK(default_fields);
+
+    if (ecm->size() < kTotalEcmSize) {
+        ALOGE("Short ECM: expected_length=%zu, actual_length=%zu",
+                kTotalEcmSize, ecm->size());
+        return BAD_VALUE;
+    }
+    const uint8_t* ptr = ecm->data();
+    default_fields->old_version = LoadNext32(&ptr);
+    default_fields->clear_lead = LoadNext32(&ptr);
+    default_fields->system_id = LoadNext32(&ptr);
+    // The real ecm version is hidden in the system id.
+    default_fields->ecm_version = (default_fields->system_id >> 24) & 0xFF;
+    default_fields->system_id &= 0x00FFFFFF;
+    if (default_fields->system_id == 0) {
+        ALOGE("Ecm has invalid system_id 0");
+        return CLEARKEY_STATUS_INVALIDSYSTEMID;
+    }
+    asset->set_id(LoadNext32(&ptr));
+    if (asset->id() == 0) {
+        ALOGE("Ecm has invalid asset_id 0");
+        return CLEARKEY_STATUS_INVALIDASSETID;
+    }
+    return OK;
+}
+
+}  // namespace ecm_generator
+}  // namespace clearkeycas
+}  // namespace android
diff --git a/drm/mediacas/plugins/clearkey/ecm_generator.h b/drm/mediacas/plugins/clearkey/ecm_generator.h
new file mode 100644
index 0000000..2ef06c4
--- /dev/null
+++ b/drm/mediacas/plugins/clearkey/ecm_generator.h
@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2017 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 CLEAR_KEY_ECM_GENERATOR_H_
+#define CLEAR_KEY_ECM_GENERATOR_H_
+
+#include <string>
+
+#include "protos/license_protos.pb.h"
+
+#include <media/stagefright/foundation/ABuffer.h>
+#include <media/stagefright/MediaErrors.h>
+
+using namespace std;
+
+namespace android {
+namespace clearkeycas {
+enum {
+    CLEARKEY_STATUS_BASE = ERROR_DRM_VENDOR_MAX,
+    CLEARKEY_STATUS_INVALIDASSETID = CLEARKEY_STATUS_BASE - 1,
+    CLEARKEY_STATUS_INVALIDSYSTEMID = CLEARKEY_STATUS_BASE - 2,
+    CLEARKEY_STATUS_INVALID_PARAMETER = CLEARKEY_STATUS_BASE - 3,
+};
+class Organization;
+
+namespace ecm_generator {
+
+// Layout of the ECM
+// ECM
+//  0 -  3 : Old ECM version (deprecated)
+//  4 -  7 : Clear lead (milliseconds)
+//       8 : ECM Version
+//  9 - 11 : System ID
+// 12 - 15 : Asset ID
+// 16 - 31 : Content Key (clear)
+//
+// The clear asset ID (bytes 12-15) is compared to the encrypted asset ID
+// (bytes 48-51) as a consistency check.
+
+struct DefaultEcmFields {
+    uint32_t old_version;
+    uint32_t clear_lead;
+    uint32_t ecm_version;
+    uint32_t system_id;
+};
+
+// Decodes a clear key ecm.
+// The following fields are decoded from the clear fields portion of the ecm:
+//   asset->id
+//   default_fields->old_version
+//   default_fields->clear_lead
+//   default_fields->system_id
+//   default_fields->ecm_version
+//
+// The following fields are decoded from the content key portion of the ecm:
+//   content_key
+//
+// |asset|, |content_key|, |default_fields| are owned by caller and must not
+// be NULL.
+// Returns failure via ecm_generator::DecodeECMClearFields.
+//
+// Example usage:
+//   Asset asset;
+//   string content_key;
+//   DefaultEcmFields default_fields;
+//   // Get a clear key |ecm|.
+//   status_t status = ecm_generator::DecodeECM(ecm, &asset, &content_key, &default_fields);
+status_t DecodeECM(const sp<ABuffer>& ecm, Asset* asset,
+        sp<ABuffer> *content_key, DefaultEcmFields* default_fields);
+
+// Decodes the following fields from the clear fields portion of the ecm:
+//   asset->id
+//   default_fields->old_version
+//   default_fields->clear_lead
+//   default_fields->system_id
+//   default_fields->ecm_version
+//
+// offset, asset and default_fields are owned by caller and must not be NULL.
+// offset is updated to show the number of bytes consumed.
+// Returns:
+// - BAD_VALUE on short ECM, or
+// - CLEARKEY_STATUS_INVALIDASSETID via ecm_generator::DecodeEcmClearFields if
+//   asset_id is 0, or
+// - CLEARKEY_STATUS_INVALIDSYSTEMID via ecm_generator::DecodeEcmClearFields if
+//   system_id is 0.
+//
+// Example usage:
+//   Asset asset;
+//   DefaultEcmFields default_fields;
+//   // Get a clear key ecm.
+//   status_t status = ecm_generator::DecodeECMClearFields(ecm, &asset, &default_fields);
+status_t DecodeECMClearFields(const sp<ABuffer>& ecm, Asset* asset,
+        DefaultEcmFields* default_fields);
+
+}  // namespace ecm_generator
+}  // namespace clearkeycas
+}  // namespace android
+#endif  // CLEAR_KEY_ECM_GENERATOR_H_
diff --git a/drm/mediacas/plugins/clearkey/protos/license_protos.proto b/drm/mediacas/plugins/clearkey/protos/license_protos.proto
new file mode 100644
index 0000000..397145d
--- /dev/null
+++ b/drm/mediacas/plugins/clearkey/protos/license_protos.proto
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2017, 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.
+ */
+
+syntax = "proto2";
+
+package android.clearkeycas;
+
+option java_package = "com.google.video.clearkey.protos";
+
+// The Asset is the data describing licensing requirements and polciy for a
+// customer's video asset.
+//
+// The asset_id must not be set on creation.  It is only used for assets of
+// CasType: CLEARKEY_CAS.
+//
+message Asset {
+  // Indicates the type of digital rights management scheme used.
+  // CLEARKEY_CAS: Clearkey Media CAS.
+  enum CasType {
+    UNKNOWN = 0;
+    CLEARKEY_CAS = 1;
+  }
+
+  // Must be unset on creation.  Required for mutate operations on CLEARKEY_CAS assets.
+  optional uint64 id = 1;
+
+  // Organization-specified name of the asset. Required. Must not be empty.
+  // 'bytes' instead of 'string' due to UTF-8 validation in the latter.
+  optional bytes name = 2;
+
+  // The lowercase_organization_name is required.  It's a foreign key to the
+  // Organization table and part of the primary key for the Asset table.
+  optional string lowercase_organization_name = 3;
+
+  // The policy_name is required.  It's a foreign key to the policy table.
+  optional string policy_name = 4; // Name of the Policy to apply to this asset.
+
+  // Key information for decrypting content. Not used for CLEARKEY_CAS.
+  optional AssetKey asset_key = 5;
+
+  optional CasType cas_type = 6 [default = UNKNOWN];
+}
+
+// AssetKey defines a key that can be used to decrypt the license.
+// Note: In the previous implementation, the schema accommodated multiple
+// asset keys per asset.  This is not supported in this implementation.
+message AssetKey {
+  optional bytes encryption_key = 1;  // 256-byte key for the asset.
+}
diff --git a/drm/mediacas/plugins/clearkey/tests/Android.mk b/drm/mediacas/plugins/clearkey/tests/Android.mk
new file mode 100644
index 0000000..5418c1d
--- /dev/null
+++ b/drm/mediacas/plugins/clearkey/tests/Android.mk
@@ -0,0 +1,44 @@
+#
+# Copyright (C) 2017 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+    ClearKeyFetcherTest.cpp
+
+LOCAL_MODULE := ClearKeyFetcherTest
+
+# LOCAL_LDFLAGS is needed here for the test to use the plugin, because
+# the plugin is not in standard library search path. Without this .so
+# loading fails at run-time (linking is okay).
+LOCAL_LDFLAGS := \
+    -Wl,--rpath,\$${ORIGIN}/../../../system/vendor/lib/mediacas -Wl,--enable-new-dtags
+
+LOCAL_SHARED_LIBRARIES := \
+    libutils libclearkeycasplugin libstagefright_foundation libprotobuf-cpp-lite liblog
+
+LOCAL_C_INCLUDES += \
+    $(TOP)/frameworks/av/drm/mediacas/plugins/clearkey \
+    $(TOP)/frameworks/av/include \
+    $(TOP)/frameworks/native/include/media \
+
+LOCAL_MODULE_TAGS := tests
+
+include $(BUILD_NATIVE_TEST)
+
+
+
diff --git a/drm/mediacas/plugins/clearkey/tests/ClearKeyFetcherTest.cpp b/drm/mediacas/plugins/clearkey/tests/ClearKeyFetcherTest.cpp
new file mode 100644
index 0000000..ace086a
--- /dev/null
+++ b/drm/mediacas/plugins/clearkey/tests/ClearKeyFetcherTest.cpp
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2017 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 "ClearKeyFetcherTest"
+#include <utils/Log.h>
+#include <gtest/gtest.h>
+#include <stddef.h>
+#include <algorithm>
+#include <string>
+
+#include "ClearKeyFetcher.h"
+#include "ClearKeyLicenseFetcher.h"
+#include "protos/license_protos.pb.h"
+
+namespace android {
+namespace clearkeycas {
+
+const char *kTestAssetInJson =
+        "{                                                   "
+        "  \"id\": 21140844,                                 "
+        "  \"name\": \"Test Title\",                         "
+        "  \"lowercase_organization_name\": \"Android\",     "
+        "  \"asset_key\": {                                  "
+        "  \"encryption_key\": \"nezAr3CHFrmBR9R8Tedotw==\"  "
+        "  },                                                "
+        "  \"cas_type\": 1,                                  "
+        "  \"track_types\": [ ]                              "
+        "}                                                   " ;
+
+const uint8_t kTestEcmContainer[] = {
+        0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+        0x00, 0x00, 0x27, 0x10, 0x02, 0x00, 0x01, 0x77,
+        0x01, 0x42, 0x95, 0x6c, 0x0e, 0xe3, 0x91, 0xbc,
+        0xfd, 0x05, 0xb1, 0x60, 0x4f, 0x17, 0x82, 0xa4,
+        0x86, 0x9b, 0x23, 0x56, 0x00, 0x01, 0x00, 0x00,
+        0x00, 0x01, 0x00, 0x00, 0x27, 0x10, 0x02, 0x00,
+        0x01, 0x77, 0x01, 0x42, 0x95, 0x6c, 0xd7, 0x43,
+        0x62, 0xf8, 0x1c, 0x62, 0x19, 0x05, 0xc7, 0x3a,
+        0x42, 0xcd, 0xfd, 0xd9, 0x13, 0x48,
+};
+
+const uint8_t kTestContentKey0[] = {
+        0x0e, 0xe3, 0x91, 0xbc, 0xfd, 0x05, 0xb1, 0x60,
+        0x4f, 0x17, 0x82, 0xa4, 0x86, 0x9b, 0x23, 0x56};
+
+const uint8_t kTestContentKey1[] = {
+        0xd7, 0x43, 0x62, 0xf8, 0x1c, 0x62, 0x19, 0x05,
+        0xc7, 0x3a, 0x42, 0xcd, 0xfd, 0xd9, 0x13, 0x48};
+
+constexpr uint32_t kTestEcmCount = 2;
+
+class ClearKeyFetcherTest : public testing::Test {
+protected:
+    virtual void SetUp();
+
+protected:
+    std::unique_ptr<ClearKeyLicenseFetcher> license_fetcher_;
+    sp<ABuffer> ecm_;
+    sp<ABuffer> content_key_[kTestEcmCount];
+};
+
+void ClearKeyFetcherTest::SetUp() {
+    license_fetcher_.reset(new ClearKeyLicenseFetcher());
+    EXPECT_EQ(OK, license_fetcher_->Init(kTestAssetInJson));
+    ecm_ = new ABuffer((void*) (kTestEcmContainer), sizeof(kTestEcmContainer));
+    content_key_[0] = new ABuffer(
+            (void*)kTestContentKey0, sizeof(kTestContentKey0));
+    content_key_[1] = new ABuffer(
+            (void*)kTestContentKey1, sizeof(kTestContentKey1));
+}
+
+TEST_F(ClearKeyFetcherTest, Ctor) {
+    ClearKeyFetcher fetcher(std::move(license_fetcher_));
+}
+
+TEST_F(ClearKeyFetcherTest, Success) {
+    ClearKeyFetcher fetcher(std::move(license_fetcher_));
+    EXPECT_EQ(OK, fetcher.Init());
+    uint64_t asset_id;
+    std::vector<KeyFetcher::KeyInfo> keys;
+    EXPECT_EQ(OK, fetcher.ObtainKey(ecm_, &asset_id, &keys));
+    EXPECT_EQ(2, keys.size());
+    EXPECT_EQ(0, keys[0].key_id);
+    EXPECT_EQ(content_key_[0]->size(), keys[0].key_bytes->size());
+    EXPECT_EQ(0, memcmp(content_key_[0]->data(),
+            keys[0].key_bytes->data(), content_key_[0]->size()));
+    EXPECT_EQ(1, keys[1].key_id);
+    EXPECT_EQ(content_key_[1]->size(), keys[1].key_bytes->size());
+    EXPECT_EQ(0, memcmp(content_key_[1]->data(),
+            keys[1].key_bytes->data(), content_key_[1]->size()));
+}
+
+} // namespace clearkeycas
+} // namespace android
diff --git a/drm/mediacas/plugins/mock/Android.mk b/drm/mediacas/plugins/mock/Android.mk
new file mode 100644
index 0000000..a97fac6
--- /dev/null
+++ b/drm/mediacas/plugins/mock/Android.mk
@@ -0,0 +1,37 @@
+#
+# Copyright (C) 2017 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= \
+    MockCasPlugin.cpp \
+    MockSessionLibrary.cpp \
+
+LOCAL_MODULE := libmockcasplugin
+
+LOCAL_PROPRIETARY_MODULE := true
+LOCAL_MODULE_RELATIVE_PATH := mediacas
+
+LOCAL_SHARED_LIBRARIES := \
+    libutils liblog
+
+LOCAL_C_INCLUDES += \
+    $(TOP)/frameworks/av/include \
+    $(TOP)/frameworks/native/include/media \
+
+LOCAL_MODULE_TAGS := optional
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/drm/mediacas/plugins/mock/MockCasPlugin.cpp b/drm/mediacas/plugins/mock/MockCasPlugin.cpp
new file mode 100644
index 0000000..12cac60
--- /dev/null
+++ b/drm/mediacas/plugins/mock/MockCasPlugin.cpp
@@ -0,0 +1,267 @@
+/*
+ * Copyright (C) 2017 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 "MockCasPlugin"
+
+#include <media/stagefright/foundation/hexdump.h>
+#include <media/stagefright/MediaErrors.h>
+#include <utils/Log.h>
+
+#include "MockCasPlugin.h"
+#include "MockSessionLibrary.h"
+
+android::CasFactory* createCasFactory() {
+    return new android::MockCasFactory();
+}
+
+android::DescramblerFactory* createDescramblerFactory() {
+    return new android::MockDescramblerFactory();
+}
+
+namespace android {
+
+static const int32_t sMockId = 0xFFFF;
+
+bool MockCasFactory::isSystemIdSupported(int32_t CA_system_id) const {
+    return CA_system_id == sMockId;
+}
+
+status_t MockCasFactory::queryPlugins(
+        std::vector<CasPluginDescriptor> *descriptors) const {
+    descriptors->clear();
+    descriptors->push_back({sMockId, String8("MockCAS")});
+    return OK;
+}
+
+status_t MockCasFactory::createPlugin(
+        int32_t CA_system_id,
+        uint64_t appData,
+        CasPluginCallback callback,
+        CasPlugin **plugin) {
+    if (!isSystemIdSupported(CA_system_id)) {
+        return BAD_VALUE;
+    }
+
+    *plugin = new MockCasPlugin();
+    return OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool MockDescramblerFactory::isSystemIdSupported(int32_t CA_system_id) const {
+    return CA_system_id == sMockId;
+}
+
+status_t MockDescramblerFactory::createPlugin(
+        int32_t CA_system_id, DescramblerPlugin** plugin) {
+    if (!isSystemIdSupported(CA_system_id)) {
+        return BAD_VALUE;
+    }
+
+    *plugin = new MockDescramblerPlugin();
+    return OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static String8 arrayToString(const std::vector<uint8_t> &array) {
+    String8 result;
+    for (size_t i = 0; i < array.size(); i++) {
+        result.appendFormat("%02x ", array[i]);
+    }
+    if (result.isEmpty()) {
+        result.append("(null)");
+    }
+    return result;
+}
+
+MockCasPlugin::MockCasPlugin() {
+    ALOGV("CTOR");
+}
+
+MockCasPlugin::~MockCasPlugin() {
+    ALOGV("DTOR");
+    MockSessionLibrary::get()->destroyPlugin(this);
+}
+
+status_t MockCasPlugin::setPrivateData(const CasData &data) {
+    ALOGV("setPrivateData");
+    return OK;
+}
+
+status_t MockCasPlugin::openSession(
+        uint16_t program_number, CasSessionId* sessionId) {
+    ALOGV("openSession: program_number=%u", program_number);
+    return MockSessionLibrary::get()->addSession(
+            this, program_number, 0, sessionId);
+}
+
+status_t MockCasPlugin::openSession(
+        uint16_t program_number,
+        uint16_t elementary_PID,
+        CasSessionId *sessionId) {
+    ALOGV("openSession: program_number=%u, elementary_PID=%u",
+            program_number, elementary_PID);
+
+    return MockSessionLibrary::get()->addSession(
+            this, program_number, elementary_PID, sessionId);
+}
+
+status_t MockCasPlugin::closeSession(const CasSessionId &sessionId) {
+    ALOGV("closeSession: sessionId=%s", arrayToString(sessionId).string());
+    Mutex::Autolock lock(mLock);
+
+    sp<MockCasSession> session =
+            MockSessionLibrary::get()->findSession(sessionId);
+    if (session == NULL) {
+        return BAD_VALUE;
+    }
+
+    MockSessionLibrary::get()->destroySession(sessionId);
+    return OK;
+}
+
+status_t MockCasPlugin::setSessionPrivateData(
+        const CasSessionId &sessionId, const CasData &data) {
+    ALOGV("setSessionPrivateData: sessionId=%s",
+            arrayToString(sessionId).string());
+    Mutex::Autolock lock(mLock);
+
+    sp<MockCasSession> session =
+            MockSessionLibrary::get()->findSession(sessionId);
+    if (session == NULL) {
+        return BAD_VALUE;
+    }
+    return OK;
+}
+
+status_t MockCasPlugin::processEcm(
+        const CasSessionId &sessionId, const CasEcm& ecm) {
+    ALOGV("processEcm: sessionId=%s", arrayToString(sessionId).string());
+    Mutex::Autolock lock(mLock);
+
+    sp<MockCasSession> session =
+            MockSessionLibrary::get()->findSession(sessionId);
+    if (session == NULL) {
+        return BAD_VALUE;
+    }
+    ALOGV("ECM: size=%d", ecm.size());
+    ALOGV("ECM: data=%s", arrayToString(ecm).string());
+
+    return OK;
+}
+
+status_t MockCasPlugin::processEmm(const CasEmm& emm) {
+    ALOGV("processEmm");
+    Mutex::Autolock lock(mLock);
+
+    ALOGV("EMM: size=%d", emm.size());
+    ALOGV("EMM: data=%s", arrayToString(emm).string());
+
+    return OK;
+}
+
+status_t MockCasPlugin::sendEvent(
+        int32_t event, int arg, const CasData &eventData) {
+    ALOGV("sendEvent: event=%d", event);
+    Mutex::Autolock lock(mLock);
+
+    return OK;
+}
+
+status_t MockCasPlugin::provision(const String8 &str) {
+    ALOGV("provision: provisionString=%s", str.string());
+    Mutex::Autolock lock(mLock);
+
+    return OK;
+}
+
+status_t MockCasPlugin::refreshEntitlements(
+        int32_t refreshType, const CasData &refreshData) {
+    ALOGV("refreshEntitlements: refreshData=%s", arrayToString(refreshData).string());
+    Mutex::Autolock lock(mLock);
+
+    return OK;
+}
+
+/////////////////////////////////////////////////////////////////
+bool MockDescramblerPlugin::requiresSecureDecoderComponent(
+        const char *mime) const {
+    ALOGV("MockDescramblerPlugin::requiresSecureDecoderComponent"
+            "(mime=%s)", mime);
+    return false;
+}
+
+status_t MockDescramblerPlugin::setMediaCasSession(
+        const CasSessionId &sessionId) {
+    ALOGV("MockDescramblerPlugin::setMediaCasSession");
+    sp<MockCasSession> session =
+            MockSessionLibrary::get()->findSession(sessionId);
+
+    if (session == NULL) {
+        ALOGE("MockDescramblerPlugin: session not found");
+        return ERROR_DRM_SESSION_NOT_OPENED;
+    }
+
+    return OK;
+}
+
+ssize_t MockDescramblerPlugin::descramble(
+        bool secure,
+        ScramblingControl scramblingControl,
+        size_t numSubSamples,
+        const SubSample *subSamples,
+        const void *srcPtr,
+        int32_t srcOffset,
+        void *dstPtr,
+        int32_t dstOffset,
+        AString *errorDetailMsg) {
+    ALOGV("MockDescramblerPlugin::descramble(secure=%d, sctrl=%d,"
+          "subSamples=%s, srcPtr=%p, dstPtr=%p, srcOffset=%d, dstOffset=%d)",
+          (int)secure, (int)scramblingControl,
+          subSamplesToString(subSamples, numSubSamples).string(),
+          srcPtr, dstPtr, srcOffset, dstOffset);
+
+    return 0;
+}
+
+// Conversion utilities
+String8 MockDescramblerPlugin::arrayToString(
+        uint8_t const *array, size_t len) const
+{
+    String8 result("{ ");
+    for (size_t i = 0; i < len; i++) {
+        result.appendFormat("0x%02x ", array[i]);
+    }
+    result += "}";
+    return result;
+}
+
+String8 MockDescramblerPlugin::subSamplesToString(
+        SubSample const *subSamples, size_t numSubSamples) const
+{
+    String8 result;
+    for (size_t i = 0; i < numSubSamples; i++) {
+        result.appendFormat("[%zu] {clear:%u, encrypted:%u} ", i,
+                            subSamples[i].mNumBytesOfClearData,
+                            subSamples[i].mNumBytesOfEncryptedData);
+    }
+    return result;
+}
+
+} // namespace android
+
diff --git a/drm/mediacas/plugins/mock/MockCasPlugin.h b/drm/mediacas/plugins/mock/MockCasPlugin.h
new file mode 100644
index 0000000..91c8855
--- /dev/null
+++ b/drm/mediacas/plugins/mock/MockCasPlugin.h
@@ -0,0 +1,129 @@
+/*
+ * Copyright (C) 2017 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 MOCK_CAS_PLUGIN_H_
+#define MOCK_CAS_PLUGIN_H_
+
+#include <media/cas/CasAPI.h>
+#include <media/cas/DescramblerAPI.h>
+#include <utils/Mutex.h>
+
+extern "C" {
+      android::CasFactory *createCasFactory();
+      android::DescramblerFactory *createDescramblerFactory();
+}
+
+namespace android {
+
+class MockCasFactory : public CasFactory {
+public:
+    MockCasFactory() {}
+    virtual ~MockCasFactory() {}
+
+    virtual bool isSystemIdSupported(
+            int32_t CA_system_id) const override;
+    virtual status_t queryPlugins(
+            std::vector<CasPluginDescriptor> *descriptors) const override;
+    virtual status_t createPlugin(
+            int32_t CA_system_id,
+            uint64_t appData,
+            CasPluginCallback callback,
+            CasPlugin **plugin) override;
+};
+
+class MockDescramblerFactory : public DescramblerFactory {
+public:
+    MockDescramblerFactory() {}
+    virtual ~MockDescramblerFactory() {}
+
+    virtual bool isSystemIdSupported(
+            int32_t CA_system_id) const override;
+    virtual status_t createPlugin(
+            int32_t CA_system_id, DescramblerPlugin **plugin) override;
+};
+
+class MockCasPlugin : public CasPlugin {
+public:
+    MockCasPlugin();
+    virtual ~MockCasPlugin();
+
+    virtual status_t setPrivateData(
+            const CasData &data) override;
+
+    virtual status_t openSession(
+            uint16_t program_number, CasSessionId *sessionId) override;
+
+    virtual status_t openSession(
+            uint16_t program_number,
+            uint16_t elementary_PID,
+            CasSessionId *sessionId) override;
+
+    virtual status_t closeSession(
+            const CasSessionId &sessionId) override;
+
+    virtual status_t setSessionPrivateData(
+            const CasSessionId &sessionId,
+            const CasData &data) override;
+
+    virtual status_t processEcm(
+            const CasSessionId &sessionId, const CasEcm &ecm) override;
+
+    virtual status_t processEmm(const CasEmm &emm) override;
+
+    virtual status_t sendEvent(
+            int32_t event, int32_t arg, const CasData &eventData) override;
+
+    virtual status_t provision(const String8 &str) override;
+
+    virtual status_t refreshEntitlements(
+            int32_t refreshType, const CasData &refreshData) override;
+
+private:
+
+    Mutex mLock;
+};
+
+class MockDescramblerPlugin : public DescramblerPlugin {
+public:
+    MockDescramblerPlugin() {}
+    virtual ~MockDescramblerPlugin() {};
+
+    virtual bool requiresSecureDecoderComponent(
+            const char *mime) const override;
+
+    virtual status_t setMediaCasSession(
+            const CasSessionId &sessionId) override;
+
+    virtual ssize_t descramble(
+            bool secure,
+            ScramblingControl scramblingControl,
+            size_t numSubSamples,
+            const SubSample *subSamples,
+            const void *srcPtr,
+            int32_t srcOffset,
+            void *dstPtr,
+            int32_t dstOffset,
+            AString *errorDetailMsg) override;
+
+private:
+    String8 subSamplesToString(
+            SubSample const *subSamples,
+            size_t numSubSamples) const;
+    String8 arrayToString(uint8_t const *array, size_t len) const;
+};
+} // namespace android
+
+#endif // MOCK_CAS_PLUGIN_H_
diff --git a/drm/mediacas/plugins/mock/MockSessionLibrary.cpp b/drm/mediacas/plugins/mock/MockSessionLibrary.cpp
new file mode 100644
index 0000000..8679a04
--- /dev/null
+++ b/drm/mediacas/plugins/mock/MockSessionLibrary.cpp
@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2017 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 "MockSessionLibrary"
+
+#include <utils/Log.h>
+#include <utils/String8.h>
+#include "MockSessionLibrary.h"
+
+namespace android {
+
+Mutex MockSessionLibrary::sSingletonLock;
+MockSessionLibrary* MockSessionLibrary::sSingleton = NULL;
+
+inline bool operator < (
+        const SessionInfo& lhs,
+        const SessionInfo& rhs) {
+    if (lhs.plugin < rhs.plugin) return true;
+    else if (lhs.plugin > rhs.plugin) return false;
+
+    if (lhs.program_number < rhs.program_number) return true;
+    else if (lhs.program_number > rhs.program_number) return false;
+
+    return lhs.elementary_PID < rhs.elementary_PID;
+}
+
+void MockCasSession::setSessionInfo(const SessionInfo &info) {
+    mSessionInfo = info;
+}
+
+const SessionInfo& MockCasSession::getSessionInfo() const {
+    return mSessionInfo;
+}
+
+MockSessionLibrary* MockSessionLibrary::get() {
+    Mutex::Autolock lock(sSingletonLock);
+
+    if (sSingleton == NULL) {
+        ALOGD("Instantiating Session Library Singleton.");
+        sSingleton = new MockSessionLibrary();
+    }
+
+    return sSingleton;
+}
+
+MockSessionLibrary::MockSessionLibrary() : mNextSessionId(1) {}
+
+status_t MockSessionLibrary::addSession(
+        CasPlugin *plugin,
+        uint16_t program_number,
+        uint16_t elementary_PID,
+        CasSessionId *sessionId) {
+    Mutex::Autolock lock(mSessionsLock);
+
+    SessionInfo info = {plugin, program_number, elementary_PID};
+    ssize_t index = mSessionInfoToIDMap.indexOfKey(info);
+    if (index >= 0) {
+        ALOGW("Session already exists: program_number=%u, elementary_PID=%u",
+                program_number, elementary_PID);
+        *sessionId = mSessionInfoToIDMap[index];
+        return OK;
+    }
+
+    sp<MockCasSession> session = new MockCasSession();
+    session->setSessionInfo(info);
+
+    uint8_t *byteArray = (uint8_t *) &mNextSessionId;
+    sessionId->push_back(byteArray[3]);
+    sessionId->push_back(byteArray[2]);
+    sessionId->push_back(byteArray[1]);
+    sessionId->push_back(byteArray[0]);
+    mNextSessionId++;
+
+    mSessionInfoToIDMap.add(info, *sessionId);
+    mIDToSessionMap.add(*sessionId, session);
+    return OK;
+}
+
+sp<MockCasSession> MockSessionLibrary::findSession(
+        const CasSessionId& sessionId) {
+    Mutex::Autolock lock(mSessionsLock);
+
+    ssize_t index = mIDToSessionMap.indexOfKey(sessionId);
+    if (index < 0) {
+        return NULL;
+    }
+    return mIDToSessionMap.valueFor(sessionId);
+}
+
+void MockSessionLibrary::destroySession(const CasSessionId& sessionId) {
+    Mutex::Autolock lock(mSessionsLock);
+
+    ssize_t index = mIDToSessionMap.indexOfKey(sessionId);
+    if (index < 0) {
+        return;
+    }
+
+    sp<MockCasSession> session = mIDToSessionMap.valueAt(index);
+    mSessionInfoToIDMap.removeItem(session->getSessionInfo());
+    mIDToSessionMap.removeItemsAt(index);
+}
+
+void MockSessionLibrary::destroyPlugin(CasPlugin *plugin) {
+    Mutex::Autolock lock(mSessionsLock);
+
+    for (ssize_t index = mSessionInfoToIDMap.size() - 1; index >= 0; index--) {
+        const SessionInfo &info = mSessionInfoToIDMap.keyAt(index);
+        if (info.plugin == plugin) {
+            const CasSessionId &id = mSessionInfoToIDMap.valueAt(index);
+            mIDToSessionMap.removeItem(id);
+            mSessionInfoToIDMap.removeItemsAt(index);
+        }
+    }
+}
+
+} // namespace android
diff --git a/drm/mediacas/plugins/mock/MockSessionLibrary.h b/drm/mediacas/plugins/mock/MockSessionLibrary.h
new file mode 100644
index 0000000..d28cbdc
--- /dev/null
+++ b/drm/mediacas/plugins/mock/MockSessionLibrary.h
@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2017 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 MOCK_CAS_SESSION_LIBRARY_H_
+#define MOCK_CAS_SESSION_LIBRARY_H_
+
+#include <media/cas/CasAPI.h>
+#include <media/stagefright/foundation/ABase.h>
+#include <utils/KeyedVector.h>
+#include <utils/Mutex.h>
+#include <utils/RefBase.h>
+
+namespace android {
+
+struct SessionInfo {
+    CasPlugin *plugin;
+    uint16_t program_number;
+    uint16_t elementary_PID;
+};
+
+class MockCasSession : public RefBase {
+public:
+    explicit MockCasSession() {}
+    virtual ~MockCasSession() {}
+
+private:
+    friend class MockSessionLibrary;
+    SessionInfo mSessionInfo;
+
+    void setSessionInfo(const SessionInfo &info);
+    const SessionInfo& getSessionInfo() const;
+
+    DISALLOW_EVIL_CONSTRUCTORS(MockCasSession);
+};
+
+class MockSessionLibrary {
+public:
+    static MockSessionLibrary* get();
+
+    status_t addSession(
+            CasPlugin *plugin,
+            uint16_t program_number,
+            uint16_t elementary_PID,
+            CasSessionId *sessionId);
+
+    sp<MockCasSession> findSession(const CasSessionId& sessionId);
+
+    void destroySession(const CasSessionId& sessionId);
+
+    void destroyPlugin(CasPlugin *plugin);
+
+private:
+    static Mutex sSingletonLock;
+    static MockSessionLibrary* sSingleton;
+
+    Mutex mSessionsLock;
+    uint32_t mNextSessionId;
+    KeyedVector<CasSessionId, sp<MockCasSession> > mIDToSessionMap;
+    KeyedVector<SessionInfo, CasSessionId> mSessionInfoToIDMap;
+
+    MockSessionLibrary();
+    DISALLOW_EVIL_CONSTRUCTORS(MockSessionLibrary);
+};
+} // namespace android
+
+#endif // MOCK_CAS_SESSION_LIBRARY_H_
diff --git a/include/ndk/NdkImage.h b/include/ndk/NdkImage.h
index 40c1699..3d1bacc 100644
--- a/include/ndk/NdkImage.h
+++ b/include/ndk/NdkImage.h
@@ -40,6 +40,10 @@
 
 #include "NdkMediaError.h"
 
+#if __ANDROID_API__ >= 26
+#include <android/hardware_buffer.h>
+#endif /* __ANDROID_API__ >= 26 */
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -707,6 +711,53 @@
 
 #endif /* __ANDROID_API__ >= 24 */
 
+#if __ANDROID_API__ >= 26
+
+/*
+ * Return the image back the the system and delete the AImage object from memory asynchronously.
+ *
+ * <p>Similar to {@link AImage_delete}, do NOT use the image pointer after this method returns.
+ * However, the caller can still hold on to the {@link AHardwareBuffer} returned from this image and
+ * signal the release of the hardware buffer back to the {@link AImageReader}'s queue using
+ * releaseFenceFd.</p>
+ *
+ * @param image The {@link AImage} to be deleted.
+ * @param releaseFenceFd A sync fence fd defined in {@link sync.h}, which signals the release of
+ *         underlying {@link AHardwareBuffer}.
+ *
+ * @see sync.h
+ */
+void AImage_deleteAsync(AImage* image, int releaseFenceFd);
+
+/**
+ * Get the hardware buffer handle of the input image intended for GPU and/or hardware access.
+ *
+ * <p>Note that no reference on the returned {@link AHardwareBuffer} handle is acquired
+ * automatically. Once the {@link AImage} or the parent {@link AImageReader} is deleted, the
+ * {@link AHardwareBuffer} handle from previous {@link AImage_getHardwareBuffer} becomes
+ * invalid.</p>
+ *
+ * <p>If the caller ever needs to hold on a reference to the {@link AHardwareBuffer} handle after
+ * the {@link AImage} or the parent {@link AImageReader} is deleted, it must call {@link
+ * AHardwareBuffer_acquire} to acquire an extra reference, and call {@link AHardwareBuffer_release}
+ * once it has finished using it in order to properly deallocate the underlying memory managed by
+ * {@link AHardwareBuffer}. If the caller has acquired extra reference on an {@link AHardwareBuffer}
+ * returned from this function, it must also listen to {@link onBufferFreed} callback to be
+ * notified when the buffer is no longer used by {@link AImageReader}.</p>
+ *
+ * @param image the {@link AImage} of interest.
+ * @param outBuffer The memory area pointed to by buffer will contain the acquired AHardwareBuffer
+ *         handle.
+ * @return <ul>
+ *         <li>{@link AMEDIA_OK} if the method call succeeds.</li>
+ *         <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if image or buffer is NULL</li></ul>
+ *
+ * @see AImageReader_ImageCallback
+ */
+media_status_t AImage_getHardwareBuffer(const AImage* image, /*out*/AHardwareBuffer** buffer);
+
+#endif /* __ANDROID_API__ >= 26 */
+
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/include/ndk/NdkImageReader.h b/include/ndk/NdkImageReader.h
index 8d72c28..a158da9 100644
--- a/include/ndk/NdkImageReader.h
+++ b/include/ndk/NdkImageReader.h
@@ -300,6 +300,127 @@
 
 #endif /* __ANDROID_API__ >= 24 */
 
+#if __ANDROID_API__ >= 26
+
+/**
+ * AImageReader constructor similar to {@link AImageReader_new} that takes an additional parameter
+ * for the consumer usage. All other parameters and the return values are identical to those passed
+ * to {@line AImageReader_new}.
+ *
+ * @param usage0 specifies how the consumer will access the AImage, using combination of the
+ *            AHARDWAREBUFFER_USAGE0 flags described in {@link hardware_buffer.h}.
+ *            Passing {@link AHARDWAREBUFFER_USAGE0_CPU_READ_OFTEN} is equivalent to calling
+ *            {@link AImageReader_new} with the same parameters. Note that consumers that do not
+ *            require CPU access to the buffer should omit {@link
+ *            AHARDWAREBUFFER_USAGE0_CPU_READ_OFTEN} to improve performance.
+ * @param usage1 specifies how the consumer will access the AImage, using combination of the
+ *            AHARDWAREBUFFER_USAGE1 flags described in {@link hardware_buffer.h}.
+ *
+ * @see AImage
+ * @see AImageReader_new
+ * @see AHardwareBuffer
+ */
+media_status_t AImageReader_newWithUsage(
+        int32_t width, int32_t height, int32_t format, uint64_t usage0,
+        uint64_t usage1, int32_t maxImages, /*out*/ AImageReader** reader);
+
+/*
+ * Acquire the next {@link AImage} from the image reader's queue asynchronously.
+ *
+ * <p>AImageReader acquire method similar to {@link AImageReader_acquireNextImage} that takes an
+ * additional parameter for the sync fence. All other parameters and the return values are
+ * identical to those passed to {@link AImageReader_acquireNextImage}.</p>
+ *
+ * @param acquireFenceFd A sync fence fd defined in {@link sync.h}, which is used to signal when the
+ *         buffer is ready to consume. When synchronization fence is not needed, fence will be set
+ *         to -1 and the {@link AImage} returned is ready for use immediately. Otherwise, user shall
+ *         use syscalls such as {@code poll()}, {@code epoll()}, {@code select()} to wait for the
+ *         fence fd to change status before attempting to access the {@link AImage} returned.
+ *
+ * @see sync.h
+ * @see sync_get_fence_info
+ */
+media_status_t AImageReader_acquireNextImageAsync(
+        AImageReader* reader, /*out*/AImage** image, /*out*/int* acquireFenceFd);
+
+/*
+ * Acquire the latest {@link AImage} from the image reader's queue asynchronously, dropping older
+ * images.
+ *
+ * <p>AImageReader acquire method similar to {@link AImageReader_acquireLatestImage} that takes an
+ * additional parameter for the sync fence. All other parameters and the return values are
+ * identical to those passed to {@link AImageReader_acquireLatestImage}.</p>
+ *
+ * @param acquireFenceFd A sync fence fd defined in {@link sync.h}, which is used to signal when the
+ *         buffer is ready to consume. When synchronization fence is not needed, fence will be set
+ *         to -1 and the {@link AImage} returned is ready for use immediately. Otherwise, user shall
+ *         use syscalls such as {@code poll()}, {@code epoll()}, {@code select()} to wait for the
+ *         fence fd to change status before attempting to access the {@link AImage} returned.
+ *
+ * @see sync.h
+ * @see sync_get_fence_info
+ */
+media_status_t AImageReader_acquireLatestImageAsync(
+        AImageReader* reader, /*out*/AImage** image, /*out*/int* acquireFenceFd);
+/**
+ * The definition of {@link AImageReader} buffer removed callback.
+ *
+ * @param context The optional application context provided by user in
+ *                {@link AImageReader_setBufferRemovedListener}.
+ * @param reader The {@link AImageReader} of interest.
+ * @param buffer The {@link AHardwareBuffer} that is being removed from this image reader.
+ */
+typedef void (*AImageReader_BufferRemovedCallback)(void* context,
+        AImageReader* reader,
+        AHardwareBuffer* buffer);
+
+typedef struct AImageReader_BufferRemovedListener {
+    /// optional application context.
+    void*                      context;
+
+    /**
+     * This callback is called when an old {@link AHardwareBuffer} is about to be removed from the
+     * image reader.
+     *
+     * <p>Note that registering this callback is optional unless the user holds on extra reference
+     * to {@link AHardwareBuffer} returned from {@link AImage_getHardwareBuffer} by calling {@link
+     * AHardwareBuffer_acquire} or creating external graphic objects, such as EglImage, from it.</p>
+     *
+     * <p>If the callback is registered, the {@link AImageReader} will hold on the last of its
+     * references to the {@link AHardwareBuffer} until this callback returns. User can use the
+     * callback to get notified that it becomes the last owner of the buffer. It is up to the user
+     * to decide to either 1) immediately release all of its references to the buffer; or 2) keep
+     * using the buffer and release it in future. Note that, if option 2 if used, user of this API
+     * is responsible to deallocate the buffer properly by calling {@link AHardwareBuffer_release}.
+     * </p>
+     *
+     * @see AHardwareBuffer_release
+     * @see AImage_getHardwareBuffer
+     */
+    AImageReader_BufferRemovedCallback onBufferRemoved;
+} AImageReader_BufferRemovedListener;
+
+/**
+ * Set the onBufferRemoved listener of this image reader.
+ *
+ * <p>Note that calling this method will replace previously registered listeners.</p>
+ *
+ * @param reader The image reader of interest.
+ * @param listener the {@link AImageReader_BufferRemovedListener} to be registered. Set this to
+ * NULL if application no longer needs to listen to buffer removed events.
+ *
+ * @return <ul>
+ *         <li>{@link AMEDIA_OK} if the method call succeeds.</li>
+ *         <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if reader is NULL.</li></ul>
+ *
+ * @see AImage_getHardwareBuffer
+ */
+media_status_t AImageReader_setBufferRemovedListener(
+        AImageReader* reader, AImageReader_BufferRemovedListener* listener);
+
+#endif /* __ANDROID_API__ >= 26 */
+
+
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/include/ndk/NdkMediaCodec.h b/include/ndk/NdkMediaCodec.h
index a63f39a..637bf9b 100644
--- a/include/ndk/NdkMediaCodec.h
+++ b/include/ndk/NdkMediaCodec.h
@@ -179,6 +179,78 @@
 media_status_t AMediaCodec_releaseOutputBufferAtTime(
         AMediaCodec *mData, size_t idx, int64_t timestampNs);
 
+/**
+ * Creates a Surface that can be used as the input to encoder, in place of input buffers
+ *
+ * This can only be called after the codec has been configured via
+ * AMediaCodec_configure(..); and before AMediaCodec_start() has been called.
+ *
+ * The application is responsible for releasing the surface by calling
+ * ANativeWindow_release() when done.
+ *
+ * For more details, see the Java documentation for MediaCodec.createInputSurface.
+ */
+media_status_t AMediaCodec_createInputSurface(
+        AMediaCodec *mData, ANativeWindow **surface);
+
+/**
+ * Creates a persistent Surface that can be used as the input to encoder
+ *
+ * Persistent surface can be reused by MediaCodec instances and can be set
+ * on a new instance via AMediaCodec_setInputSurface().
+ * A persistent surface can be connected to at most one instance of MediaCodec
+ * at any point in time.
+ *
+ * The application is responsible for releasing the surface by calling
+ * ANativeWindow_release() when done.
+ *
+ * For more details, see the Java documentation for MediaCodec.createPersistentInputSurface.
+ */
+media_status_t AMediaCodec_createPersistentInputSurface(
+        ANativeWindow **surface);
+
+/**
+ * Set a persistent-surface that can be used as the input to encoder, in place of input buffers
+ *
+ * The surface provided *must* be a persistent surface created via
+ * AMediaCodec_createPersistentInputSurface()
+ * This can only be called after the codec has been configured by calling
+ * AMediaCodec_configure(..); and before AMediaCodec_start() has been called.
+ *
+ * For more details, see the Java documentation for MediaCodec.setInputSurface.
+ */
+media_status_t AMediaCodec_setInputSurface(
+        AMediaCodec *mData, ANativeWindow *surface);
+
+/**
+ * Signal additional parameters to the codec instance.
+ *
+ * Parameters can be communicated only when the codec is running, i.e
+ * after AMediaCodec_start() has been called.
+ *
+ * NOTE: Some of these parameter changes may silently fail to apply.
+ */
+media_status_t AMediaCodec_setParameters(
+        AMediaCodec *mData, const AMediaFormat* params);
+
+/**
+ * Signals end-of-stream on input. Equivalent to submitting an empty buffer with
+ * AMEDIACODEC_BUFFER_FLAG_END_OF_STREAM set.
+ *
+ * Returns AMEDIA_ERROR_INVALID_OPERATION when used with an encoder not in executing state
+ * or not receiving input from a Surface created by AMediaCodec_createInputSurface or
+ * AMediaCodec_createPersistentInputSurface.
+ *
+ * Returns the previous codec error if one exists.
+ *
+ * Returns AMEDIA_OK when completed succesfully.
+ *
+ * For more details, see the Java documentation for MediaCodec.signalEndOfInputStream.
+ */
+media_status_t AMediaCodec_signalEndOfInputStream(AMediaCodec *mData);
+
+
+
 typedef enum {
     AMEDIACODECRYPTOINFO_MODE_CLEAR = 0,
     AMEDIACODECRYPTOINFO_MODE_AES_CTR = 1,
diff --git a/include/ndk/NdkMediaError.h b/include/ndk/NdkMediaError.h
index 9709a6f..1b51364 100644
--- a/include/ndk/NdkMediaError.h
+++ b/include/ndk/NdkMediaError.h
@@ -45,6 +45,7 @@
     AMEDIA_ERROR_UNSUPPORTED           = AMEDIA_ERROR_BASE - 2,
     AMEDIA_ERROR_INVALID_OBJECT        = AMEDIA_ERROR_BASE - 3,
     AMEDIA_ERROR_INVALID_PARAMETER     = AMEDIA_ERROR_BASE - 4,
+    AMEDIA_ERROR_INVALID_OPERATION     = AMEDIA_ERROR_BASE - 5,
 
     AMEDIA_DRM_ERROR_BASE              = -20000,
     AMEDIA_DRM_NOT_PROVISIONED         = AMEDIA_DRM_ERROR_BASE - 1,
diff --git a/media/libaudiohal/DevicesFactoryHalHidl.cpp b/media/libaudiohal/DevicesFactoryHalHidl.cpp
index 758a5805..fc2645e 100644
--- a/media/libaudiohal/DevicesFactoryHalHidl.cpp
+++ b/media/libaudiohal/DevicesFactoryHalHidl.cpp
@@ -45,7 +45,8 @@
         // and thus have the same lifespan.
         mDevicesFactory->linkToDeath(HalDeathHandler::getInstance(), 0 /*cookie*/);
     } else {
-        LOG_ALWAYS_FATAL("Failed to obtain IDevicesFactory service");
+        ALOGE("Failed to obtain IDevicesFactory service, terminating process.");
+        exit(1);
     }
 }
 
diff --git a/media/libaudiohal/EffectsFactoryHalHidl.cpp b/media/libaudiohal/EffectsFactoryHalHidl.cpp
index f7dbb9c..605c059 100644
--- a/media/libaudiohal/EffectsFactoryHalHidl.cpp
+++ b/media/libaudiohal/EffectsFactoryHalHidl.cpp
@@ -44,7 +44,10 @@
 
 EffectsFactoryHalHidl::EffectsFactoryHalHidl() : ConversionHelperHidl("EffectsFactory") {
     mEffectsFactory = IEffectsFactory::getService();
-    LOG_ALWAYS_FATAL_IF(mEffectsFactory == 0, "Failed to obtain IEffectsFactory service");
+    if (mEffectsFactory == 0) {
+        ALOGE("Failed to obtain IEffectsFactory service, terminating process.");
+        exit(1);
+    }
 }
 
 EffectsFactoryHalHidl::~EffectsFactoryHalHidl() {
diff --git a/media/libaudioprocessing/AudioResamplerFirProcess.h b/media/libaudioprocessing/AudioResamplerFirProcess.h
index 176202e..a741677 100644
--- a/media/libaudioprocessing/AudioResamplerFirProcess.h
+++ b/media/libaudioprocessing/AudioResamplerFirProcess.h
@@ -186,7 +186,7 @@
         TINTERP lerpP,
         const TO* const volumeLR)
 {
-    COMPILE_TIME_ASSERT_FUNCTION_SCOPE(CHANNELS > 0)
+    static_assert(CHANNELS > 0, "CHANNELS must be > 0");
 
     if (CHANNELS > 2) {
         // TO accum[CHANNELS];
diff --git a/media/libaudioprocessing/AudioResamplerFirProcessNeon.h b/media/libaudioprocessing/AudioResamplerFirProcessNeon.h
index 1ce76a8..c335050 100644
--- a/media/libaudioprocessing/AudioResamplerFirProcessNeon.h
+++ b/media/libaudioprocessing/AudioResamplerFirProcessNeon.h
@@ -83,7 +83,7 @@
         const int16_t* coefsN1)
 {
     ALOG_ASSERT(count > 0 && (count & 7) == 0); // multiple of 8
-    COMPILE_TIME_ASSERT_FUNCTION_SCOPE(CHANNELS == 1 || CHANNELS == 2);
+    static_assert(CHANNELS == 1 || CHANNELS == 2, "CHANNELS must be 1 or 2");
 
     sP -= CHANNELS*((STRIDE>>1)-1);
     coefsP = (const int16_t*)__builtin_assume_aligned(coefsP, 16);
@@ -191,7 +191,7 @@
         const int32_t* coefsN1)
 {
     ALOG_ASSERT(count > 0 && (count & 7) == 0); // multiple of 8
-    COMPILE_TIME_ASSERT_FUNCTION_SCOPE(CHANNELS == 1 || CHANNELS == 2);
+    static_assert(CHANNELS == 1 || CHANNELS == 2, "CHANNELS must be 1 or 2");
 
     sP -= CHANNELS*((STRIDE>>1)-1);
     coefsP = (const int32_t*)__builtin_assume_aligned(coefsP, 16);
@@ -366,7 +366,7 @@
         const float* coefsN1)
 {
     ALOG_ASSERT(count > 0 && (count & 7) == 0); // multiple of 8
-    COMPILE_TIME_ASSERT_FUNCTION_SCOPE(CHANNELS == 1 || CHANNELS == 2);
+    static_assert(CHANNELS == 1 || CHANNELS == 2, "CHANNELS must be 1 or 2");
 
     sP -= CHANNELS*((STRIDE>>1)-1);
     coefsP = (const float*)__builtin_assume_aligned(coefsP, 16);
diff --git a/media/libaudioprocessing/AudioResamplerFirProcessSSE.h b/media/libaudioprocessing/AudioResamplerFirProcessSSE.h
index 63ed052..30233b5 100644
--- a/media/libaudioprocessing/AudioResamplerFirProcessSSE.h
+++ b/media/libaudioprocessing/AudioResamplerFirProcessSSE.h
@@ -47,7 +47,7 @@
         const float* coefsN1)
 {
     ALOG_ASSERT(count > 0 && (count & 7) == 0); // multiple of 8
-    COMPILE_TIME_ASSERT_FUNCTION_SCOPE(CHANNELS == 1 || CHANNELS == 2);
+    static_assert(CHANNELS == 1 || CHANNELS == 2, "CHANNELS must be 1 or 2");
 
     sP -= CHANNELS*(4-1);   // adjust sP for a loop iteration of four
 
diff --git a/media/libeffects/lvm/wrapper/Bundle/EffectBundle.cpp b/media/libeffects/lvm/wrapper/Bundle/EffectBundle.cpp
index 0d8142d..8028969 100644
--- a/media/libeffects/lvm/wrapper/Bundle/EffectBundle.cpp
+++ b/media/libeffects/lvm/wrapper/Bundle/EffectBundle.cpp
@@ -1345,6 +1345,7 @@
     case AUDIO_DEVICE_OUT_WIRED_HEADSET:
     case AUDIO_DEVICE_OUT_WIRED_HEADPHONE:
     case AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES:
+    case AUDIO_DEVICE_OUT_USB_HEADSET:
         return 0;
     default :
         return -EINVAL;
diff --git a/media/libeffects/preprocessing/PreProcessing.cpp b/media/libeffects/preprocessing/PreProcessing.cpp
index ccfd29c..f2844ed 100644
--- a/media/libeffects/preprocessing/PreProcessing.cpp
+++ b/media/libeffects/preprocessing/PreProcessing.cpp
@@ -531,6 +531,7 @@
         break;
     case AUDIO_DEVICE_OUT_WIRED_HEADSET:
     case AUDIO_DEVICE_OUT_WIRED_HEADPHONE:
+    case AUDIO_DEVICE_OUT_USB_HEADSET:
     default:
         break;
     }
diff --git a/media/libmedia/TypeConverter.cpp b/media/libmedia/TypeConverter.cpp
index bead69a..a6eba86 100644
--- a/media/libmedia/TypeConverter.cpp
+++ b/media/libmedia/TypeConverter.cpp
@@ -54,6 +54,7 @@
     MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_IP),
     MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_BUS),
     MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_PROXY),
+    MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_USB_HEADSET),
     MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_DEFAULT),
     // STUB must be after DEFAULT, so the latter is picked up by toString first.
     MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_OUT_STUB),
@@ -89,6 +90,7 @@
     MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_IP),
     MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_BUS),
     MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_PROXY),
+    MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_USB_HEADSET),
     MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_DEFAULT),
     // STUB must be after DEFAULT, so the latter is picked up by toString first.
     MAKE_STRING_FROM_ENUM(AUDIO_DEVICE_IN_STUB),
@@ -112,6 +114,7 @@
     MAKE_STRING_FROM_ENUM(AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO),
     MAKE_STRING_FROM_ENUM(AUDIO_OUTPUT_FLAG_DIRECT_PCM),
     MAKE_STRING_FROM_ENUM(AUDIO_OUTPUT_FLAG_MMAP_NOIRQ),
+    MAKE_STRING_FROM_ENUM(AUDIO_OUTPUT_FLAG_VOIP_RX),
     TERMINATOR
 };
 
@@ -124,6 +127,7 @@
     MAKE_STRING_FROM_ENUM(AUDIO_INPUT_FLAG_RAW),
     MAKE_STRING_FROM_ENUM(AUDIO_INPUT_FLAG_SYNC),
     MAKE_STRING_FROM_ENUM(AUDIO_INPUT_FLAG_MMAP_NOIRQ),
+    MAKE_STRING_FROM_ENUM(AUDIO_INPUT_FLAG_VOIP_TX),
     TERMINATOR
 };
 
diff --git a/media/libmediaplayerservice/MediaRecorderClient.cpp b/media/libmediaplayerservice/MediaRecorderClient.cpp
index c00a951..638eec3 100644
--- a/media/libmediaplayerservice/MediaRecorderClient.cpp
+++ b/media/libmediaplayerservice/MediaRecorderClient.cpp
@@ -465,6 +465,10 @@
     } else {
         // Legacy IOMX
         binder = sm->getService(String16("media.codec"));
+        if (binder == NULL) {
+           ALOGE("Unable to connect to media codec service");
+           return NO_INIT;
+        }
         mCodecDeathListener = new ServiceDeathNotifier(binder, listener,
                 MediaPlayerService::MEDIACODEC_PROCESS_DEATH);
         binder->linkToDeath(mCodecDeathListener);
diff --git a/media/libmediaplayerservice/StagefrightRecorder.cpp b/media/libmediaplayerservice/StagefrightRecorder.cpp
index 73570c8..f689ac9 100644
--- a/media/libmediaplayerservice/StagefrightRecorder.cpp
+++ b/media/libmediaplayerservice/StagefrightRecorder.cpp
@@ -69,7 +69,23 @@
 // key for media statistics
 static const char *kKeyRecorder = "recorder";
 // attrs for media statistics
-//
+static const char *kRecorderHeight = "android.media.mediarecorder.height";
+static const char *kRecorderWidth = "android.media.mediarecorder.width";
+static const char *kRecorderFrameRate = "android.media.mediarecorder.frame-rate";
+static const char *kRecorderVideoBitrate = "android.media.mediarecorder.video-bitrate";
+static const char *kRecorderAudioSampleRate = "android.media.mediarecorder.audio-samplerate";
+static const char *kRecorderAudioChannels = "android.media.mediarecorder.audio-channels";
+static const char *kRecorderAudioBitrate = "android.media.mediarecorder.audio-bitrate";
+static const char *kRecorderVideoIframeInterval = "android.media.mediarecorder.video-iframe-interval";
+static const char *kRecorderMovieTimescale = "android.media.mediarecorder.movie-timescale";
+static const char *kRecorderAudioTimescale = "android.media.mediarecorder.audio-timescale";
+static const char *kRecorderVideoTimescale = "android.media.mediarecorder.video-timescale";
+static const char *kRecorderVideoProfile = "android.media.mediarecorder.video-encoder-profile";
+static const char *kRecorderVideoLevel = "android.media.mediarecorder.video-encoder-level";
+static const char *kRecorderCaptureFpsEnable = "android.media.mediarecorder.capture-fpsenable";
+static const char *kRecorderCaptureFps = "android.media.mediarecorder.capture-fps";
+static const char *kRecorderRotation = "android.media.mediarecorder.rotation";
+
 // To collect the encoder usage for the battery app
 static void addBatteryData(uint32_t params) {
     sp<IBinder> binder =
@@ -124,34 +140,34 @@
     // TBD mOutputFormat  = OUTPUT_FORMAT_THREE_GPP;
     // TBD mAudioEncoder  = AUDIO_ENCODER_AMR_NB;
     // TBD mVideoEncoder  = VIDEO_ENCODER_DEFAULT;
-    mAnalyticsItem->setInt32("ht", mVideoHeight);
-    mAnalyticsItem->setInt32("wid", mVideoWidth);
-    mAnalyticsItem->setInt32("frame-rate", mFrameRate);
-    mAnalyticsItem->setInt32("video-bitrate", mVideoBitRate);
-    mAnalyticsItem->setInt32("audio-samplerate", mSampleRate);
-    mAnalyticsItem->setInt32("audio-channels", mAudioChannels);
-    mAnalyticsItem->setInt32("audio-bitrate", mAudioBitRate);
+    mAnalyticsItem->setInt32(kRecorderHeight, mVideoHeight);
+    mAnalyticsItem->setInt32(kRecorderWidth, mVideoWidth);
+    mAnalyticsItem->setInt32(kRecorderFrameRate, mFrameRate);
+    mAnalyticsItem->setInt32(kRecorderVideoBitrate, mVideoBitRate);
+    mAnalyticsItem->setInt32(kRecorderAudioSampleRate, mSampleRate);
+    mAnalyticsItem->setInt32(kRecorderAudioChannels, mAudioChannels);
+    mAnalyticsItem->setInt32(kRecorderAudioBitrate, mAudioBitRate);
     // TBD mInterleaveDurationUs = 0;
-    mAnalyticsItem->setInt32("video-iframe-interval", mIFramesIntervalSec);
+    mAnalyticsItem->setInt32(kRecorderVideoIframeInterval, mIFramesIntervalSec);
     // TBD mAudioSourceNode = 0;
     // TBD mUse64BitFileOffset = false;
-    mAnalyticsItem->setInt32("movie-timescale", mMovieTimeScale);
-    mAnalyticsItem->setInt32("audio-timescale", mAudioTimeScale);
-    mAnalyticsItem->setInt32("video-timescale", mVideoTimeScale);
+    mAnalyticsItem->setInt32(kRecorderMovieTimescale, mMovieTimeScale);
+    mAnalyticsItem->setInt32(kRecorderAudioTimescale, mAudioTimeScale);
+    mAnalyticsItem->setInt32(kRecorderVideoTimescale, mVideoTimeScale);
     // TBD mCameraId        = 0;
     // TBD mStartTimeOffsetMs = -1;
-    mAnalyticsItem->setInt32("video-encoder-profile", mVideoEncoderProfile);
-    mAnalyticsItem->setInt32("video-encoder-level", mVideoEncoderLevel);
+    mAnalyticsItem->setInt32(kRecorderVideoProfile, mVideoEncoderProfile);
+    mAnalyticsItem->setInt32(kRecorderVideoLevel, mVideoEncoderLevel);
     // TBD mMaxFileDurationUs = 0;
     // TBD mMaxFileSizeBytes = 0;
     // TBD mTrackEveryTimeDurationUs = 0;
-    mAnalyticsItem->setInt32("capture-fpsenable", mCaptureFpsEnable);
-    mAnalyticsItem->setInt32("capture-fps", mCaptureFps);
+    mAnalyticsItem->setInt32(kRecorderCaptureFpsEnable, mCaptureFpsEnable);
+    mAnalyticsItem->setDouble(kRecorderCaptureFps, mCaptureFps);
     // TBD mTimeBetweenCaptureUs = -1;
     // TBD mCameraSourceTimeLapse = NULL;
     // TBD mMetaDataStoredInVideoBuffers = kMetadataBufferTypeInvalid;
     // TBD mEncoderProfiles = MediaProfiles::getInstance();
-    mAnalyticsItem->setInt32("rotation", mRotationDegrees);
+    mAnalyticsItem->setInt32(kRecorderRotation, mRotationDegrees);
     // PII mLatitudex10000 = -3600000;
     // PII mLongitudex10000 = -3600000;
     // TBD mTotalBitRate = 0;
diff --git a/media/libmediaplayerservice/nuplayer/NuPlayer.cpp b/media/libmediaplayerservice/nuplayer/NuPlayer.cpp
index 50d5343..510794c 100644
--- a/media/libmediaplayerservice/nuplayer/NuPlayer.cpp
+++ b/media/libmediaplayerservice/nuplayer/NuPlayer.cpp
@@ -1535,8 +1535,6 @@
     if (driver != NULL) {
         int64_t now = systemTime();
         int64_t played = now - mLastStartedPlayingTimeNs;
-        ALOGD("played from %" PRId64 " to %" PRId64 " = %" PRId64 ,
-              mLastStartedPlayingTimeNs, now, played);
 
         driver->notifyMorePlayingTimeUs((played+500)/1000);
     }
diff --git a/media/libmediaplayerservice/nuplayer/NuPlayerDriver.cpp b/media/libmediaplayerservice/nuplayer/NuPlayerDriver.cpp
index 19c4d85..01008b4 100644
--- a/media/libmediaplayerservice/nuplayer/NuPlayerDriver.cpp
+++ b/media/libmediaplayerservice/nuplayer/NuPlayerDriver.cpp
@@ -38,6 +38,22 @@
 
 namespace android {
 
+// key for media statistics
+static const char *kKeyPlayer = "nuplayer";
+// attrs for media statistics
+static const char *kPlayerVMime = "android.media.mediaplayer.video.mime";
+static const char *kPlayerVCodec = "android.media.mediaplayer.video.codec";
+static const char *kPlayerWidth = "android.media.mediaplayer.width";
+static const char *kPlayerHeight = "android.media.mediaplayer.height";
+static const char *kPlayerFrames = "android.media.mediaplayer.frames";
+static const char *kPlayerFramesDropped = "android.media.mediaplayer.dropped";
+static const char *kPlayerAMime = "android.media.mediaplayer.audio.mime";
+static const char *kPlayerACodec = "android.media.mediaplayer.audio.codec";
+static const char *kPlayerDuration = "android.media.mediaplayer.durationMs";
+static const char *kPlayerPlaying = "android.media.mediaplayer.playingMs";
+static const char *kPlayerError = "android.media.mediaplayer.err";
+static const char *kPlayerErrorCode = "android.media.mediaplayer.errcode";
+
 
 NuPlayerDriver::NuPlayerDriver(pid_t pid)
     : mState(STATE_IDLE),
@@ -59,7 +75,7 @@
     mLooper->setName("NuPlayerDriver Looper");
 
     // set up an analytics record
-    mAnalyticsItem = new MediaAnalyticsItem("nuplayer");
+    mAnalyticsItem = new MediaAnalyticsItem(kKeyPlayer);
     mAnalyticsItem->generateSessionID();
 
     mLooper->start(
@@ -77,7 +93,7 @@
     mLooper->stop();
 
     // finalize any pending metrics, usually a no-op.
-    finalizeMetrics("destructor");
+    updateMetrics("destructor");
     logMetrics("destructor");
 
     if (mAnalyticsItem != NULL) {
@@ -495,11 +511,11 @@
     return OK;
 }
 
-void NuPlayerDriver::finalizeMetrics(const char *where) {
+void NuPlayerDriver::updateMetrics(const char *where) {
     if (where == NULL) {
         where = "unknown";
     }
-    ALOGD("finalizeMetrics(%p) from %s at state %d", this, where, mState);
+    ALOGV("updateMetrics(%p) from %s at state %d", this, where, mState);
 
     // gather the final stats for this record
     Vector<sp<AMessage>> trackStats;
@@ -517,15 +533,15 @@
 
             if (mime.startsWith("video/")) {
                 int32_t width, height;
-                mAnalyticsItem->setCString("video/mime", mime.c_str());
+                mAnalyticsItem->setCString(kPlayerVMime, mime.c_str());
                 if (!name.empty()) {
-                    mAnalyticsItem->setCString("video/codec", name.c_str());
+                    mAnalyticsItem->setCString(kPlayerVCodec, name.c_str());
                 }
 
                 if (stats->findInt32("width", &width)
                         && stats->findInt32("height", &height)) {
-                    mAnalyticsItem->setInt32("wid", width);
-                    mAnalyticsItem->setInt32("ht", height);
+                    mAnalyticsItem->setInt32(kPlayerWidth, width);
+                    mAnalyticsItem->setInt32(kPlayerHeight, height);
                 }
 
                 int64_t numFramesTotal = 0;
@@ -533,29 +549,27 @@
                 stats->findInt64("frames-total", &numFramesTotal);
                 stats->findInt64("frames-dropped-output", &numFramesDropped);
 
-                mAnalyticsItem->setInt64("frames", numFramesTotal);
-                mAnalyticsItem->setInt64("dropped", numFramesDropped);
+                mAnalyticsItem->setInt64(kPlayerFrames, numFramesTotal);
+                mAnalyticsItem->setInt64(kPlayerFramesDropped, numFramesDropped);
 
 
             } else if (mime.startsWith("audio/")) {
-                mAnalyticsItem->setCString("audio/mime", mime.c_str());
+                mAnalyticsItem->setCString(kPlayerAMime, mime.c_str());
                 if (!name.empty()) {
-                    mAnalyticsItem->setCString("audio/codec", name.c_str());
+                    mAnalyticsItem->setCString(kPlayerACodec, name.c_str());
                 }
             }
         }
-
-        // getDuration() uses mLock for mutex -- careful where we use it.
-        int duration_ms = -1;
-        getDuration(&duration_ms);
-        if (duration_ms != -1) {
-            mAnalyticsItem->setInt64("duration", duration_ms);
-        }
-
-        if (mPlayingTimeUs > 0) {
-            mAnalyticsItem->setInt64("playing", (mPlayingTimeUs+500)/1000 );
-        }
     }
+
+    // always provide duration and playing time, even if they have 0/unknown values.
+
+    // getDuration() uses mLock for mutex -- careful where we use it.
+    int duration_ms = -1;
+    getDuration(&duration_ms);
+    mAnalyticsItem->setInt64(kPlayerDuration, duration_ms);
+
+    mAnalyticsItem->setInt64(kPlayerPlaying, (mPlayingTimeUs+500)/1000 );
 }
 
 
@@ -563,14 +577,18 @@
     if (where == NULL) {
         where = "unknown";
     }
-    ALOGD("logMetrics(%p) from %s at state %d", this, where, mState);
+    ALOGV("logMetrics(%p) from %s at state %d", this, where, mState);
 
     if (mAnalyticsItem == NULL || mAnalyticsItem->isEnabled() == false) {
         return;
     }
 
-    // only bother to log non-empty records
-    if (mAnalyticsItem->count() > 0) {
+    // log only non-empty records
+    // we always updateMetrics() before we get here
+    // and that always injects 2 fields (duration and playing time) into
+    // the record.
+    // So the canonical "empty" record has 2 elements in it.
+    if (mAnalyticsItem->count() > 2) {
 
         mAnalyticsItem->setFinalized(true);
         mAnalyticsItem->selfrecord();
@@ -589,7 +607,7 @@
 status_t NuPlayerDriver::reset() {
     ALOGD("reset(%p) at state %d", this, mState);
 
-    finalizeMetrics("reset");
+    updateMetrics("reset");
     logMetrics("reset");
 
     Mutex::Autolock autoLock(mLock);
@@ -715,7 +733,7 @@
     if (key == FOURCC('m','t','r','X')) {
         // mtrX -- a play on 'metrics' (not matrix)
         // gather current info all together, parcel it, and send it back
-        finalizeMetrics("api");
+        updateMetrics("api");
         mAnalyticsItem->writeToParcel(reply);
         return OK;
     }
@@ -923,6 +941,15 @@
 
         case MEDIA_ERROR:
         {
+            // when we have an error, add it to the analytics for this playback.
+            // ext1 is our primary 'error type' value. Only add ext2 when non-zero.
+            // [test against msg is due to fall through from previous switch value]
+            if (msg == MEDIA_ERROR) {
+                mAnalyticsItem->setInt32(kPlayerError, ext1);
+                if (ext2 != 0) {
+                    mAnalyticsItem->setInt32(kPlayerErrorCode, ext2);
+                }
+            }
             mAtEOS = true;
             break;
         }
diff --git a/media/libmediaplayerservice/nuplayer/NuPlayerDriver.h b/media/libmediaplayerservice/nuplayer/NuPlayerDriver.h
index 082f71a..c5ddcb0 100644
--- a/media/libmediaplayerservice/nuplayer/NuPlayerDriver.h
+++ b/media/libmediaplayerservice/nuplayer/NuPlayerDriver.h
@@ -137,7 +137,7 @@
     bool mLooping;
     bool mAutoLoop;
 
-    void finalizeMetrics(const char *where);
+    void updateMetrics(const char *where);
     void logMetrics(const char *where);
 
     status_t prepare_l();
diff --git a/media/libnbaio/NBLog.cpp b/media/libnbaio/NBLog.cpp
index 7936ad2..de38e7f 100644
--- a/media/libnbaio/NBLog.cpp
+++ b/media/libnbaio/NBLog.cpp
@@ -68,24 +68,32 @@
 
 NBLog::FormatEntry::iterator NBLog::FormatEntry::args() const {
     auto it = begin();
-    // Second entry can be author or timestamp. Skip author if present
-    if ((++it)->type == EVENT_AUTHOR) {
+    // skip start fmt
+    ++it;
+    // skip timestamp
+    ++it;
+    // Skip author if present
+    if (it->type == EVENT_AUTHOR) {
         ++it;
     }
-    return ++it;
+    return it;
 }
 
 timespec NBLog::FormatEntry::timestamp() const {
     auto it = begin();
-    if ((++it)->type != EVENT_TIMESTAMP) {
-        ++it;
-    }
+    // skip start fmt
+    ++it;
     return it.payload<timespec>();
 }
 
 pid_t NBLog::FormatEntry::author() const {
     auto it = begin();
-    if ((++it)->type == EVENT_AUTHOR) {
+    // skip start fmt
+    ++it;
+    // skip timestamp
+    ++it;
+    // if there is an author entry, return it, return -1 otherwise
+    if (it->type == EVENT_AUTHOR) {
         return it.payload<int>();
     }
     return -1;
@@ -96,6 +104,8 @@
     auto it = begin();
     // copy fmt start entry
     it.copyTo(dst);
+    // copy timestamp
+    (++it).copyTo(dst);
     // insert author entry
     size_t authorEntrySize = NBLog::Entry::kOverhead + sizeof(author);
     uint8_t authorEntry[authorEntrySize];
diff --git a/media/libnbaio/include/NBLog.h b/media/libnbaio/include/NBLog.h
index 7aaf298..59b77bd 100644
--- a/media/libnbaio/include/NBLog.h
+++ b/media/libnbaio/include/NBLog.h
@@ -59,8 +59,8 @@
 
 // a formatted entry has the following structure:
 //    * START_FMT entry, containing the format string
-//    * author entry of the thread that generated it (optional, present in merged log)
 //    * TIMESTAMP entry
+//    * author entry of the thread that generated it (optional, present in merged log)
 //    * format arg1
 //    * format arg2
 //    * ...
diff --git a/media/libstagefright/ACodec.cpp b/media/libstagefright/ACodec.cpp
index 81eecaf..37e1546 100644
--- a/media/libstagefright/ACodec.cpp
+++ b/media/libstagefright/ACodec.cpp
@@ -551,7 +551,8 @@
       mCreateInputBuffersSuspended(false),
       mTunneled(false),
       mDescribeColorAspectsIndex((OMX_INDEXTYPE)0),
-      mDescribeHDRStaticInfoIndex((OMX_INDEXTYPE)0) {
+      mDescribeHDRStaticInfoIndex((OMX_INDEXTYPE)0),
+      mVendorExtensionsStatus(kExtensionsUnchecked) {
     mUninitializedState = new UninitializedState(this);
     mLoadedState = new LoadedState(this);
     mLoadedToIdleState = new LoadedToIdleState(this);
@@ -2216,13 +2217,16 @@
     int32_t maxInputSize;
     if (msg->findInt32("max-input-size", &maxInputSize)) {
         err = setMinBufferSize(kPortIndexInput, (size_t)maxInputSize);
+        err = OK; // ignore error
     } else if (!strcmp("OMX.Nvidia.aac.decoder", mComponentName.c_str())) {
         err = setMinBufferSize(kPortIndexInput, 8192);  // XXX
+        err = OK; // ignore error
     }
 
     int32_t priority;
     if (msg->findInt32("priority", &priority)) {
         err = setPriority(priority);
+        err = OK; // ignore error
     }
 
     int32_t rateInt = -1;
@@ -2233,6 +2237,14 @@
     }
     if (rateFloat > 0) {
         err = setOperatingRate(rateFloat, video);
+        err = OK; // ignore errors
+    }
+
+    if (err == OK) {
+        err = setVendorParameters(msg);
+        if (err != OK) {
+            return err;
+        }
     }
 
     // NOTE: both mBaseOutputFormat and mOutputFormat are outputFormat to signal first frame.
@@ -5106,7 +5118,7 @@
             return BAD_TYPE;
     }
 
-    return OK;
+    return getVendorParameters(portIndex, notify);
 }
 
 void ACodec::onDataSpaceChanged(android_dataspace dataSpace, const ColorAspects &aspects) {
@@ -7176,7 +7188,362 @@
         err = OK; // ignore failure
     }
 
-    return err;
+    return setVendorParameters(params);
+}
+
+// Removes trailing tags matching |tag| from |key| (e.g. a settings name). |minLength| specifies
+// the minimum number of characters to keep in |key| (even if it has trailing tags).
+// (Used to remove trailing 'value' tags in settings names, e.g. to normalize
+// 'vendor.settingsX.value' to 'vendor.settingsX')
+static void removeTrailingTags(char *key, size_t minLength, const char *tag) {
+    size_t length = strlen(key);
+    size_t tagLength = strlen(tag);
+    while (length > minLength + tagLength
+            && !strcmp(key + length - tagLength, tag)
+            && key[length - tagLength - 1] == '.') {
+        length -= tagLength + 1;
+        key[length] = '\0';
+    }
+}
+
+/**
+ * Struct encompassing a vendor extension config structure and a potential error status (in case
+ * the structure is null). Used to iterate through vendor extensions.
+ */
+struct VendorExtension {
+    OMX_CONFIG_ANDROID_VENDOR_EXTENSIONTYPE *config;  // structure does not own config
+    status_t status;
+
+    // create based on an error status
+    VendorExtension(status_t s_ = NO_INIT) : config(nullptr), status(s_) { }
+
+    // create based on a successfully retrieved config structure
+    VendorExtension(OMX_CONFIG_ANDROID_VENDOR_EXTENSIONTYPE *c_) : config(c_), status(OK) { }
+};
+
+// class VendorExtensions;
+/**
+ * Forward iterator to enumerate vendor extensions supported by an OMX component.
+ */
+class VendorExtensionIterator {
+//private:
+    static constexpr size_t kLastIndex = ~(size_t)0; // last index marker
+
+    sp<IOMXNode> mNode;                   // component
+    size_t mIndex;                        // current android extension index
+    std::unique_ptr<uint8_t[]> mBacking;  // current extension's backing
+    VendorExtension mCurrent;             // current extension
+
+    VendorExtensionIterator(const sp<IOMXNode> &node, size_t index)
+        : mNode(node),
+          mIndex(index) {
+        mCurrent = retrieve();
+    }
+
+    friend class VendorExtensions;
+
+public:
+    // copy constructor
+    VendorExtensionIterator(const VendorExtensionIterator &it)
+        : VendorExtensionIterator(it.mNode, it.mIndex) { }
+
+    // retrieves the current extension pointed to by this iterator
+    VendorExtension retrieve() {
+        if (mIndex == kLastIndex) {
+            return NO_INIT;
+        }
+
+        // try with one param first, then retry if extension needs more than 1 param
+        for (size_t paramSizeUsed = 1;; ) {
+            if (paramSizeUsed > OMX_MAX_ANDROID_VENDOR_PARAMCOUNT) {
+                return BAD_VALUE; // this prevents overflow in the following formula
+            }
+
+            size_t size = sizeof(OMX_CONFIG_ANDROID_VENDOR_EXTENSIONTYPE) +
+                (paramSizeUsed - 1) * sizeof(OMX_CONFIG_ANDROID_VENDOR_EXTENSIONTYPE::param);
+            mBacking.reset(new uint8_t[size]);
+            if (!mBacking) {
+                return NO_MEMORY;
+            }
+
+            OMX_CONFIG_ANDROID_VENDOR_EXTENSIONTYPE *config =
+                reinterpret_cast<OMX_CONFIG_ANDROID_VENDOR_EXTENSIONTYPE *>(mBacking.get());
+
+            InitOMXParams(config);
+            config->nSize = size;
+            config->nIndex = mIndex;
+            config->nParamSizeUsed = paramSizeUsed;
+            status_t err = mNode->getConfig(
+                    (OMX_INDEXTYPE)OMX_IndexConfigAndroidVendorExtension, config, size);
+            if (err == OK && config->nParamCount > paramSizeUsed && paramSizeUsed == 1) {
+                // reallocate if we need a bigger config
+                paramSizeUsed = config->nParamCount;
+                continue;
+            } else if (err == NOT_ENOUGH_DATA
+                   || (err != OK && mIndex == 0)) {
+                // stop iterator on no-more signal, or if index is not at all supported
+                mIndex = kLastIndex;
+                return NO_INIT;
+            } else if (err != OK) {
+                return err;
+            } else if (paramSizeUsed != config->nParamSizeUsed) {
+                return BAD_VALUE; // component shall not modify size of nParam
+            }
+
+            return config;
+        }
+    }
+
+    // returns extension pointed to by this iterator
+    VendorExtension operator*() {
+        return mCurrent;
+    }
+
+    // prefix increment: move to next extension
+    VendorExtensionIterator &operator++() { // prefix
+        if (mIndex != kLastIndex) {
+            ++mIndex;
+            mCurrent = retrieve();
+        }
+        return *this;
+    }
+
+    // iterator equality operators
+    bool operator==(const VendorExtensionIterator &o) {
+        return mNode == o.mNode && mIndex == o.mIndex;
+    }
+
+    bool operator!=(const VendorExtensionIterator &o) {
+        return !(*this == o);
+    }
+};
+
+/**
+ * Iterable container for vendor extensions provided by a component
+ */
+class VendorExtensions {
+//private:
+    sp<IOMXNode> mNode;
+
+public:
+    VendorExtensions(const sp<IOMXNode> &node)
+        : mNode(node) {
+    }
+
+    VendorExtensionIterator begin() {
+        return VendorExtensionIterator(mNode, 0);
+    }
+
+    VendorExtensionIterator end() {
+        return VendorExtensionIterator(mNode, VendorExtensionIterator::kLastIndex);
+    }
+};
+
+status_t ACodec::setVendorParameters(const sp<AMessage> &params) {
+    std::map<std::string, std::string> vendorKeys; // maps reduced name to actual name
+    constexpr char prefix[] = "vendor.";
+    constexpr size_t prefixLength = sizeof(prefix) - 1;
+    // longest possible vendor param name
+    char reducedKey[OMX_MAX_STRINGNAME_SIZE + OMX_MAX_STRINGVALUE_SIZE];
+
+    // identify all vendor keys to speed up search later and to detect vendor keys
+    for (size_t i = params->countEntries(); i; --i) {
+        AMessage::Type keyType;
+        const char* key = params->getEntryNameAt(i - 1, &keyType);
+        if (key != nullptr && !strncmp(key, prefix, prefixLength)
+                // it is safe to limit format keys to the max vendor param size as we only
+                // shorten parameter names by removing any trailing 'value' tags, and we
+                // already remove the vendor prefix.
+                && strlen(key + prefixLength) < sizeof(reducedKey)
+                && (keyType == AMessage::kTypeInt32
+                        || keyType == AMessage::kTypeInt64
+                        || keyType == AMessage::kTypeString)) {
+            strcpy(reducedKey, key + prefixLength);
+            removeTrailingTags(reducedKey, 0, "value");
+            auto existingKey = vendorKeys.find(reducedKey);
+            if (existingKey != vendorKeys.end()) {
+                ALOGW("[%s] vendor parameter '%s' aliases parameter '%s'",
+                        mComponentName.c_str(), key, existingKey->second.c_str());
+                // ignore for now
+            }
+            vendorKeys.emplace(reducedKey, key);
+        }
+    }
+
+    // don't bother component if we don't have vendor extensions as they may not have implemented
+    // the android vendor extension support, which will lead to unnecessary OMX failure logs.
+    if (vendorKeys.empty()) {
+        return OK;
+    }
+
+    char key[sizeof(OMX_CONFIG_ANDROID_VENDOR_EXTENSIONTYPE::cName) +
+            sizeof(OMX_CONFIG_ANDROID_VENDOR_PARAMTYPE::cKey)];
+
+    status_t finalError = OK;
+
+    // don't try again if component does not have vendor extensions
+    if (mVendorExtensionsStatus == kExtensionsNone) {
+        return OK;
+    }
+
+    for (VendorExtension ext : VendorExtensions(mOMXNode)) {
+        OMX_CONFIG_ANDROID_VENDOR_EXTENSIONTYPE *config = ext.config;
+        if (config == nullptr) {
+            return ext.status;
+        }
+
+        mVendorExtensionsStatus = kExtensionsExist;
+
+        config->cName[sizeof(config->cName) - 1] = '\0'; // null-terminate name
+        strcpy(key, (const char *)config->cName);
+        size_t nameLength = strlen(key);
+        key[nameLength] = '.';
+
+        // don't set vendor extension if client has not provided any of its parameters
+        // or if client simply unsets parameters that are already unset
+        bool needToSet = false;
+        for (size_t paramIndex = 0; paramIndex < config->nParamCount; ++paramIndex) {
+            // null-terminate param key
+            config->param[paramIndex].cKey[sizeof(config->param[0].cKey) - 1] = '\0';
+            strcpy(key + nameLength + 1, (const char *)config->param[paramIndex].cKey);
+            removeTrailingTags(key, nameLength, "value");
+            auto existingKey = vendorKeys.find(key);
+
+            // don't touch (e.g. change) parameters that are not specified by client
+            if (existingKey == vendorKeys.end()) {
+                continue;
+            }
+
+            bool wasSet = config->param[paramIndex].bSet;
+            switch (config->param[paramIndex].eValueType) {
+            case OMX_AndroidVendorValueInt32:
+            {
+                int32_t value;
+                config->param[paramIndex].bSet =
+                    (OMX_BOOL)params->findInt32(existingKey->second.c_str(), &value);
+                if (config->param[paramIndex].bSet) {
+                    config->param[paramIndex].nInt32 = value;
+                }
+                break;
+            }
+            case OMX_AndroidVendorValueInt64:
+            {
+                int64_t value;
+                config->param[paramIndex].bSet =
+                    (OMX_BOOL)params->findAsInt64(existingKey->second.c_str(), &value);
+                if (config->param[paramIndex].bSet) {
+                    config->param[paramIndex].nInt64 = value;
+                }
+                break;
+            }
+            case OMX_AndroidVendorValueString:
+            {
+                AString value;
+                config->param[paramIndex].bSet =
+                    (OMX_BOOL)params->findString(existingKey->second.c_str(), &value);
+                if (config->param[paramIndex].bSet) {
+                    strncpy((char *)config->param[paramIndex].cString, value.c_str(),
+                            sizeof(OMX_CONFIG_ANDROID_VENDOR_PARAMTYPE::cString));
+                }
+                break;
+            }
+            default:
+                ALOGW("[%s] vendor parameter '%s' is not a supported value",
+                        mComponentName.c_str(), key);
+                continue;
+            }
+            if (config->param[paramIndex].bSet || wasSet) {
+                needToSet = true;
+            }
+        }
+
+        if (needToSet) {
+            status_t err = mOMXNode->setConfig(
+                    (OMX_INDEXTYPE)OMX_IndexConfigAndroidVendorExtension,
+                    config, config->nSize);
+            if (err != OK) {
+                key[nameLength] = '\0';
+                ALOGW("[%s] failed to set vendor extension '%s'", mComponentName.c_str(), key);
+                // try to set each extension, and return first failure
+                if (finalError == OK) {
+                    finalError = err;
+                }
+            }
+        }
+    }
+
+    if (mVendorExtensionsStatus == kExtensionsUnchecked) {
+        mVendorExtensionsStatus = kExtensionsNone;
+    }
+
+    return finalError;
+}
+
+status_t ACodec::getVendorParameters(OMX_U32 portIndex, sp<AMessage> &format) {
+    constexpr char prefix[] = "vendor.";
+    constexpr size_t prefixLength = sizeof(prefix) - 1;
+    char key[sizeof(OMX_CONFIG_ANDROID_VENDOR_EXTENSIONTYPE::cName) +
+            sizeof(OMX_CONFIG_ANDROID_VENDOR_PARAMTYPE::cKey) + prefixLength];
+    strcpy(key, prefix);
+
+    // don't try again if component does not have vendor extensions
+    if (mVendorExtensionsStatus == kExtensionsNone) {
+        return OK;
+    }
+
+    for (VendorExtension ext : VendorExtensions(mOMXNode)) {
+        OMX_CONFIG_ANDROID_VENDOR_EXTENSIONTYPE *config = ext.config;
+        if (config == nullptr) {
+            return ext.status;
+        }
+
+        mVendorExtensionsStatus = kExtensionsExist;
+
+        if (config->eDir != (portIndex == kPortIndexInput ? OMX_DirInput : OMX_DirOutput)) {
+            continue;
+        }
+
+        config->cName[sizeof(config->cName) - 1] = '\0'; // null-terminate name
+        strcpy(key + prefixLength, (const char *)config->cName);
+        size_t nameLength = strlen(key);
+        key[nameLength] = '.';
+
+        for (size_t paramIndex = 0; paramIndex < config->nParamCount; ++paramIndex) {
+            // null-terminate param key
+            config->param[paramIndex].cKey[sizeof(config->param[0].cKey) - 1] = '\0';
+            strcpy(key + nameLength + 1, (const char *)config->param[paramIndex].cKey);
+            removeTrailingTags(key, nameLength, "value");
+            if (config->param[paramIndex].bSet) {
+                switch (config->param[paramIndex].eValueType) {
+                case OMX_AndroidVendorValueInt32:
+                {
+                    format->setInt32(key, config->param[paramIndex].nInt32);
+                    break;
+                }
+                case OMX_AndroidVendorValueInt64:
+                {
+                    format->setInt64(key, config->param[paramIndex].nInt64);
+                    break;
+                }
+                case OMX_AndroidVendorValueString:
+                {
+                    config->param[paramIndex].cString[OMX_MAX_STRINGVALUE_SIZE - 1] = '\0';
+                    format->setString(key, (const char *)config->param[paramIndex].cString);
+                    break;
+                }
+                default:
+                    ALOGW("vendor parameter %s is not a supported value", key);
+                    continue;
+                }
+            }
+        }
+    }
+
+    if (mVendorExtensionsStatus == kExtensionsUnchecked) {
+        mVendorExtensionsStatus = kExtensionsNone;
+    }
+
+    return OK;
 }
 
 void ACodec::onSignalEndOfInputStream() {
diff --git a/media/libstagefright/ACodecBufferChannel.cpp b/media/libstagefright/ACodecBufferChannel.cpp
index 259e134..ecbbd03 100644
--- a/media/libstagefright/ACodecBufferChannel.cpp
+++ b/media/libstagefright/ACodecBufferChannel.cpp
@@ -75,6 +75,9 @@
 }
 
 status_t ACodecBufferChannel::queueInputBuffer(const sp<MediaCodecBuffer> &buffer) {
+    if (mDealer != nullptr) {
+        return -ENOSYS;
+    }
     std::shared_ptr<const std::vector<const BufferInfo>> array(
             std::atomic_load(&mInputBuffers));
     BufferInfoIterator it = findClientBuffer(array, buffer);
@@ -94,7 +97,7 @@
         const uint8_t *iv, CryptoPlugin::Mode mode, CryptoPlugin::Pattern pattern,
         const CryptoPlugin::SubSample *subSamples, size_t numSubSamples,
         AString *errorDetailMsg) {
-    if (!hasCryptoOrDescrambler()) {
+    if (!hasCryptoOrDescrambler() || mDealer == nullptr) {
         return -ENOSYS;
     }
     std::shared_ptr<const std::vector<const BufferInfo>> array(
diff --git a/media/libstagefright/MediaCodec.cpp b/media/libstagefright/MediaCodec.cpp
index 8728b6f..f695717 100644
--- a/media/libstagefright/MediaCodec.cpp
+++ b/media/libstagefright/MediaCodec.cpp
@@ -62,10 +62,15 @@
 // key for media statistics
 static const char *kCodecKeyName = "codec";
 // attrs for media statistics
-static const char *kCodecCodec = "codec";               /* e.g. OMX.google.aac.decoder */
-static const char *kCodecMime = "mime";                 /* e.g. audio/mime */
-static const char *kCodecMode = "mode";                 /* audio, video */
-static const char *kCodecSecure = "secure";             /* 0, 1 */
+static const char *kCodecCodec = "android.media.mediacodec.codec";  /* e.g. OMX.google.aac.decoder */
+static const char *kCodecMime = "android.media.mediacodec.mime";    /* e.g. audio/mime */
+static const char *kCodecMode = "android.media.mediacodec.mode";    /* audio, video */
+static const char *kCodecSecure = "android.media.mediacodec.secure";   /* 0, 1 */
+static const char *kCodecHeight = "android.media.mediacodec.height";   /* 0..n */
+static const char *kCodecWidth = "android.media.mediacodec.width";     /* 0..n */
+static const char *kCodecRotation = "android.media.mediacodec.rotation-degrees";  /* 0/90/180/270 */
+static const char *kCodecCrypto = "android.media.mediacodec.crypto";   /* 0,1 */
+static const char *kCodecEncoder = "android.media.mediacodec.encoder"; /* 0,1 */
 
 
 
@@ -636,9 +641,8 @@
             mAnalyticsItem->setCString(kCodecCodec, name.c_str());
         }
         mAnalyticsItem->setCString(kCodecMode, mIsVideo ? "video" : "audio");
-        //mAnalyticsItem->setInt32("type", nameIsType);
         if (nameIsType)
-            mAnalyticsItem->setInt32("encoder", encoder);
+            mAnalyticsItem->setInt32(kCodecEncoder, encoder);
     }
 
     status_t err;
@@ -698,14 +702,14 @@
     if (mIsVideo) {
         format->findInt32("width", &mVideoWidth);
         format->findInt32("height", &mVideoHeight);
-        if (!format->findInt32("rotation-degrees", &mRotationDegrees)) {
+        if (!format->findInt32(kCodecRotation, &mRotationDegrees)) {
             mRotationDegrees = 0;
         }
 
         if (mAnalyticsItem != NULL) {
-            mAnalyticsItem->setInt32("width", mVideoWidth);
-            mAnalyticsItem->setInt32("height", mVideoHeight);
-            mAnalyticsItem->setInt32("rotation", mRotationDegrees);
+            mAnalyticsItem->setInt32(kCodecWidth, mVideoWidth);
+            mAnalyticsItem->setInt32(kCodecHeight, mVideoHeight);
+            mAnalyticsItem->setInt32(kCodecRotation, mRotationDegrees);
         }
 
         // Prevent possible integer overflow in downstream code.
@@ -728,7 +732,7 @@
         }
         if (mAnalyticsItem != NULL) {
             // XXX: save indication that it's crypto in some way...
-            mAnalyticsItem->setInt32("crypto", 1);
+            mAnalyticsItem->setInt32(kCodecCrypto, 1);
         }
     }
 
@@ -1167,7 +1171,9 @@
     return OK;
 }
 
-status_t MediaCodec::getMetrics(Parcel *reply) {
+status_t MediaCodec::getMetrics(MediaAnalyticsItem * &reply) {
+
+    reply = NULL;
 
     // shouldn't happen, but be safe
     if (mAnalyticsItem == NULL) {
@@ -1177,7 +1183,7 @@
     // XXX: go get current values for whatever in-flight data we want
 
     // send it back to the caller.
-    mAnalyticsItem->writeToParcel(reply);
+    reply = mAnalyticsItem->dup();
 
     return OK;
 }
diff --git a/media/libstagefright/MediaExtractor.cpp b/media/libstagefright/MediaExtractor.cpp
index 62c0d8a..76775c2 100644
--- a/media/libstagefright/MediaExtractor.cpp
+++ b/media/libstagefright/MediaExtractor.cpp
@@ -57,6 +57,9 @@
 // key for media statistics
 static const char *kKeyExtractor = "extractor";
 // attrs for media statistics
+static const char *kExtractorMime = "android.media.mediaextractor.mime";
+static const char *kExtractorTracks = "android.media.mediaextractor.ntrk";
+static const char *kExtractorFormat = "android.media.mediaextractor.fmt";
 
 MediaExtractor::MediaExtractor() {
     if (!LOG_NDEBUG) {
@@ -265,9 +268,9 @@
        if (MEDIA_LOG) {
           if (ret->mAnalyticsItem != NULL) {
               size_t ntracks = ret->countTracks();
-              ret->mAnalyticsItem->setCString("fmt",  ret->name());
+              ret->mAnalyticsItem->setCString(kExtractorFormat,  ret->name());
               // tracks (size_t)
-              ret->mAnalyticsItem->setInt32("ntrk",  ntracks);
+              ret->mAnalyticsItem->setInt32(kExtractorTracks,  ntracks);
               // metadata
               sp<MetaData> pMetaData = ret->getMetaData();
               if (pMetaData != NULL) {
@@ -276,7 +279,7 @@
                 // 'mime'
                 const char *mime = NULL;
                 if (pMetaData->findCString(kKeyMIMEType, &mime)) {
-                    ret->mAnalyticsItem->setCString("mime",  mime);
+                    ret->mAnalyticsItem->setCString(kExtractorMime,  mime);
                 }
                 // what else is interesting and not already available?
               }
diff --git a/media/libstagefright/codecs/avc/Android.mk b/media/libstagefright/codecs/avc/Android.mk
deleted file mode 100644
index 2e43120..0000000
--- a/media/libstagefright/codecs/avc/Android.mk
+++ /dev/null
@@ -1,4 +0,0 @@
-LOCAL_PATH:= $(call my-dir)
-include $(CLEAR_VARS)
-
-include $(call all-makefiles-under,$(LOCAL_PATH))
diff --git a/media/libstagefright/codecs/avc/common/Android.mk b/media/libstagefright/codecs/avc/common/Android.mk
deleted file mode 100644
index 9959554..0000000
--- a/media/libstagefright/codecs/avc/common/Android.mk
+++ /dev/null
@@ -1,23 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES := \
-	src/deblock.cpp \
- 	src/dpb.cpp \
- 	src/fmo.cpp \
- 	src/mb_access.cpp \
- 	src/reflist.cpp
-
-LOCAL_MODULE := libstagefright_avc_common
-
-LOCAL_CFLAGS := -DOSCL_EXPORT_REF= -DOSCL_IMPORT_REF=
-
-LOCAL_C_INCLUDES := \
-	$(LOCAL_PATH)/src \
- 	$(LOCAL_PATH)/include
-
-LOCAL_CFLAGS += -Werror
-LOCAL_SANITIZE := signed-integer-overflow cfi
-LOCAL_SANITIZE_DIAG := cfi
-
-include $(BUILD_SHARED_LIBRARY)
diff --git a/media/libstagefright/codecs/avc/common/MODULE_LICENSE_APACHE2 b/media/libstagefright/codecs/avc/common/MODULE_LICENSE_APACHE2
deleted file mode 100644
index e69de29..0000000
--- a/media/libstagefright/codecs/avc/common/MODULE_LICENSE_APACHE2
+++ /dev/null
diff --git a/media/libstagefright/codecs/avc/common/NOTICE b/media/libstagefright/codecs/avc/common/NOTICE
deleted file mode 100644
index c5b1efa..0000000
--- a/media/libstagefright/codecs/avc/common/NOTICE
+++ /dev/null
@@ -1,190 +0,0 @@
-
-   Copyright (c) 2005-2008, 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.
-
-   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.
-
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
diff --git a/media/libstagefright/codecs/avc/common/include/avc_types.h b/media/libstagefright/codecs/avc/common/include/avc_types.h
deleted file mode 100644
index ec8b6de..0000000
--- a/media/libstagefright/codecs/avc/common/include/avc_types.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * Copyright (C) 2009 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#ifndef AVC_TYPES_H_
-
-#define AVC_TYPES_H_
-
-#include <stdint.h>
-
-typedef uint8_t uint8;
-typedef uint16_t uint16;
-typedef int16_t int16;
-typedef uint32_t uint32;
-typedef int32_t int32;
-typedef unsigned int uint;
-
-#endif  // AVC_TYPES_H_
diff --git a/media/libstagefright/codecs/avc/common/include/avcapi_common.h b/media/libstagefright/codecs/avc/common/include/avcapi_common.h
deleted file mode 100644
index abffe6e..0000000
--- a/media/libstagefright/codecs/avc/common/include/avcapi_common.h
+++ /dev/null
@@ -1,274 +0,0 @@
-/* ------------------------------------------------------------------
- * 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 file contains common type definitions and enumerations used by AVC encoder
-and decoder libraries which are exposed to the users.
-@publishedAll
-*/
-
-#ifndef AVCAPI_COMMON_H_INCLUDED
-#define AVCAPI_COMMON_H_INCLUDED
-
-#include "avc_types.h"
-
-#define PV_MEMORY_POOL
-/**
-This is common return status.
-@publishedAll
-*/
-typedef enum
-{
-    AVC_NO_BUFFER = -2,
-    AVC_MEMORY_FAIL = -1,
-    AVC_FAIL = 0,
-    AVC_SUCCESS = 1,
-    AVC_PICTURE_OUTPUT_READY = 2
-} AVCStatus;
-
-/**
-This enumeration is for profiles. The value follows the profile_idc  in sequence
-parameter set rbsp. See Annex A.
-@publishedAll
-*/
-typedef enum
-{
-    AVC_BASELINE = 66,
-    AVC_MAIN = 77,
-    AVC_EXTENDED = 88,
-    AVC_HIGH = 100,
-    AVC_HIGH10 = 110,
-    AVC_HIGH422 = 122,
-    AVC_HIGH444 = 144
-} AVCProfile;
-
-/**
-This enumeration is for levels. The value follows the level_idc in sequence
-parameter set rbsp. See Annex A.
-@published All
-*/
-typedef enum
-{
-    AVC_LEVEL_AUTO = 0,
-    AVC_LEVEL1_B = 9,
-    AVC_LEVEL1 = 10,
-    AVC_LEVEL1_1 = 11,
-    AVC_LEVEL1_2 = 12,
-    AVC_LEVEL1_3 = 13,
-    AVC_LEVEL2 = 20,
-    AVC_LEVEL2_1 = 21,
-    AVC_LEVEL2_2 = 22,
-    AVC_LEVEL3 = 30,
-    AVC_LEVEL3_1 = 31,
-    AVC_LEVEL3_2 = 32,
-    AVC_LEVEL4 = 40,
-    AVC_LEVEL4_1 = 41,
-    AVC_LEVEL4_2 = 42,
-    AVC_LEVEL5 = 50,
-    AVC_LEVEL5_1 = 51
-} AVCLevel;
-
-/**
-This enumeration follows Table 7-1 for NAL unit type codes.
-This may go to avccommon_api.h later (external common).
-@publishedAll
-*/
-typedef enum
-{
-    AVC_NALTYPE_SLICE = 1,  /* non-IDR non-data partition */
-    AVC_NALTYPE_DPA = 2,    /* data partition A */
-    AVC_NALTYPE_DPB = 3,    /* data partition B */
-    AVC_NALTYPE_DPC = 4,    /* data partition C */
-    AVC_NALTYPE_IDR = 5,    /* IDR NAL */
-    AVC_NALTYPE_SEI = 6,    /* supplemental enhancement info */
-    AVC_NALTYPE_SPS = 7,    /* sequence parameter set */
-    AVC_NALTYPE_PPS = 8,    /* picture parameter set */
-    AVC_NALTYPE_AUD = 9,    /* access unit delimiter */
-    AVC_NALTYPE_EOSEQ = 10, /* end of sequence */
-    AVC_NALTYPE_EOSTREAM = 11, /* end of stream */
-    AVC_NALTYPE_FILL = 12   /* filler data */
-} AVCNalUnitType;
-
-/**
-This enumeration specifies debug logging type.
-This may go to avccommon_api.h later (external common).
-@publishedAll
-*/
-typedef enum
-{
-    AVC_LOGTYPE_ERROR = 0,
-    AVC_LOGTYPE_WARNING = 1,
-    AVC_LOGTYPE_INFO = 2
-} AVCLogType;
-
-/**
-This enumerate the status of certain flags.
-@publishedAll
-*/
-typedef enum
-{
-    AVC_OFF = 0,
-    AVC_ON = 1
-} AVCFlag;
-
-/**
-This structure contains input information.
-Note, this structure is identical to AVCDecOutput for now.
-*/
-typedef struct tagAVCFrameIO
-{
-    /** A unique identification number for a particular instance of this structure.
-    To remain unchanged by the application between the time when it is given to the
-    library and the time when the library returns it back. */
-    uint32 id;
-
-    /** Array of pointers to Y,Cb,Cr content in 4:2:0 format. For AVC decoding,
-    this memory is allocated by the AVC decoder library. For AVC encoding, only the
-    memory for original unencoded frame is allocated by the application. Internal
-    memory is also allocated by the AVC encoder library. */
-    uint8 *YCbCr[3];
-
-    /** In/Out: Coded width of the luma component, it has to be multiple of 16. */
-    int pitch;
-
-    /** In/Out: Coded height of the luma component, must be multiple of 16. */
-    int height;
-
-    /** In/Out: Display width, less than picth */
-    int clip_width;
-
-    /** In/Out: Display height, less than height */
-    int clip_height;
-
-    /** Input: Origin of the display area [0]=>row, [1]=>column  */
-    int clip_origin[2];
-
-    /** Output: Frame number in de/encoding order (not necessary)*/
-    uint32 coding_order;
-
-    /** Output: Frame number in displaying order (this may or may not be associated with the POC at all!!!). */
-    uint32 disp_order;
-
-    /** In/Out: Flag for use for reference or not. */
-    uint  is_reference;
-
-    /** In/Out: Coding timestamp in msec (not display timestamp) */
-    uint32 coding_timestamp;
-
-    /* there could be something else here such as format, DON (decoding order number)
-     if available thru SEI, etc. */
-} AVCFrameIO;
-
-
-/** CALLBACK FUNCTION TO BE IMPLEMENTED BY APPLICATION */
-/** In AVCDecControls structure, userData is a pointer to an object with the following
-    member functions.
-*/
-
-
-/** @brief Decoded picture buffers (DPB) must be allocated or re-allocated before an
-    IDR frame is decoded. If PV_MEMORY_POOL is not defined, AVC lib will allocate DPB
-    internally which cannot be shared with the application. In that case, this function
-    will not be called.
-    @param userData  The same value of userData in AVCHandle object.
-    @param frame_size_in_mbs  The size of each frame in number of macroblocks.
-    @param num_frames The number of frames in DPB.
-    @return 1 for success, 0 for fail (cannot allocate DPB)
-*/
-
-typedef int (*FunctionType_DPBAlloc)(void *userData, uint frame_size_in_mbs, uint num_buffers);
-
-/** @brief AVC library calls this function is reserve a memory of one frame from the DPB.
-    Once reserved, this frame shall not be deleted or over-written by the app.
-    @param userData  The same value of userData in AVCHandle object.
-    @param indx      Index of a frame in DPB (AVC library keeps track of the index).
-    @param yuv      The address of the yuv pointer returned to the AVC lib.
-    @return         1 for success, 0 for fail (no frames available to bind).
-    */
-typedef int (*FunctionType_FrameBind)(void *userData, int indx, uint8 **yuv);
-
-/** @brief AVC library calls this function once a bound frame is not needed for decoding
-    operation (falls out of the sliding window, or marked unused for reference).
-    @param userData  The same value of userData in AVCHandle object.
-    @param indx      Index of frame to be unbound (AVC library keeps track of the index).
-    @return  none.
-*/
-typedef void (*FuctionType_FrameUnbind)(void *userData, int);
-
-/** Pointer to malloc function for general memory allocation, so that application can keep track of
-    memory usage.
-\param "size" "Size of requested memory in bytes."
-\param "attribute" "Some value specifying types, priority, etc. of the memory."
-\return "The address of the allocated, zero-initialized memory"
-*/
-typedef void* (*FunctionType_Malloc)(void *userData, int32 size, int attribute);
-
-/** Function pointer to free
-\param "mem" "Pointer to the memory to be freed"
-\return "void"
-*/
-typedef void (*FunctionType_Free)(void *userData, void *mem);
-
-/** Debug logging information is returned to the application thru this function.
-\param "type"   "Type of logging message, see definition of AVCLogType."
-\param "string1"    "Logging message."
-\param "string2"    "To be defined."
-*/
-typedef void (*FunctionType_DebugLog)(uint32 *userData, AVCLogType type, char *string1, int val1, int val2);
-
-/**
-This structure has to be allocated and maintained by the user of the library.
-This structure is used as a handle to the library object.
-*/
-typedef struct tagAVCHandle
-{
-    /** A pointer to the internal data structure. Users have to make sure that this value
-        is NULL at the beginning.
-    */
-    void        *AVCObject;
-
-    /** A pointer to user object which has the following member functions used for
-    callback purpose.  !!! */
-    void        *userData;
-
-    /** Pointers to functions implemented by the users of AVC library */
-    FunctionType_DPBAlloc CBAVC_DPBAlloc;
-
-    FunctionType_FrameBind CBAVC_FrameBind;
-
-    FuctionType_FrameUnbind CBAVC_FrameUnbind;
-
-    FunctionType_Malloc CBAVC_Malloc;
-
-    FunctionType_Free  CBAVC_Free;
-
-    FunctionType_DebugLog CBAVC_DebugLog;
-
-    /** Flag to enable debugging */
-    uint32  debugEnable;
-
-} AVCHandle;
-
-
-
-#ifdef PVDEBUGMSG_LOG
-#define DEBUG_LOG(a,b,c,d,e)    CBAVC_DebugLog(a,b,c,d,e)
-#else
-#define DEBUG_LOG(a,b,c,d,e)
-#endif
-
-#endif /* _AVCAPI_COMMON_H_ */
diff --git a/media/libstagefright/codecs/avc/common/include/avcint_common.h b/media/libstagefright/codecs/avc/common/include/avcint_common.h
deleted file mode 100644
index 465e604..0000000
--- a/media/libstagefright/codecs/avc/common/include/avcint_common.h
+++ /dev/null
@@ -1,882 +0,0 @@
-/* ------------------------------------------------------------------
- * 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 file contains common code shared between AVC decoder and AVC encoder for
-internal use only.
-@publishedAll
-*/
-
-#ifndef AVCINT_COMMON_H_INCLUDED
-#define AVCINT_COMMON_H_INCLUDED
-
-#ifndef AVCAPI_COMMON_H_INCLUDED
-#include "avcapi_common.h"
-#endif
-
-
-#ifndef TRUE
-#define TRUE  1
-#define FALSE 0
-#endif
-
-
-
-/**
-Mathematic functions defined in subclause 5.7.
-Can be replaced with assembly instructions for speedup.
-@publishedAll
-*/
-#define AVC_ABS(x)   (((x)<0)? -(x) : (x))
-#define AVC_SIGN(x)  (((x)<0)? -1 : 1)
-#define AVC_SIGN0(x) (((x)<0)? -1 : (((x)>0) ? 1 : 0))
-#define AVC_MAX(x,y) ((x)>(y)? (x):(y))
-#define AVC_MIN(x,y) ((x)<(y)? (x):(y))
-#define AVC_MEDIAN(A,B,C) ((A) > (B) ? ((A) < (C) ? (A) : (B) > (C) ? (B) : (C)): (B) < (C) ? (B) : (C) > (A) ? (C) : (A))
-#define AVC_CLIP3(a,b,x) (AVC_MAX(a,AVC_MIN(x,b)))  /* clip x between a and b */
-#define AVC_CLIP(x)  AVC_CLIP3(0,255,x)
-#define AVC_FLOOR(x) ((int)(x))
-#define AVC_RASTER_SCAN(x,y,n)  ((x)+(y)*(n))
-#define AVC_ROUND(x) (AVC_SIGN(x)*AVC_FLOOR(AVC_ABS(x)+0.5))
-#define AVC_INVERSE_RASTER_SCAN(a,b,c,d,e) (((e)==0)? (((a)%((d)/(b)))*(b)): (((a)/((d)/(b)))*(c)))
-/* a:block address, b:block width, c:block height, d:total_width, e:x or y coordinate */
-
-#define DEFAULT_ATTR  0  /* default memory attribute  */
-#define FAST_MEM_ATTR 1  /* fast memory attribute */
-
-
-/* This section is for definition of constants. */
-#define MB_SIZE 16
-#define BLOCK_SIZE 4
-#define EMULATION_PREVENTION_THREE_BYTE 0x3
-#define NUM_PIXELS_IN_MB  (24*16)
-#define NUM_BLKS_IN_MB 24
-
-#define AVCNumI4PredMode  9
-#define AVCNumI16PredMode  4
-#define AVCNumIChromaMode  4
-
-/* constants used in the structures below */
-#define MAXIMUMVALUEOFcpb_cnt   32  /* used in HRDParams */
-#define MAX_NUM_REF_FRAMES_IN_PIC_ORDER_CNT_CYCLE 255   /* used in SeqParamSet */
-#define MAX_NUM_SLICE_GROUP  8      /* used in PicParamSet */
-#define MAX_REF_PIC_LIST_REORDERING 32  /* 32 is maximum according to Annex A, SliceHeader */
-#define MAX_DEC_REF_PIC_MARKING 64   /* 64 is the maximum possible given the max num ref pictures to 31. */
-#define MAX_FS (16+1)  /* pre-defined size of frame store array */
-#define MAX_LEVEL_IDX  15  /* only 15 levels defined for now */
-#define MAX_REF_PIC_LIST 33 /* max size of the RefPicList0 and RefPicList1 */
-
-
-/**
-Architectural related macros.
-@publishedAll
-*/
-#ifdef USE_PRED_BLOCK
-#define MB_BASED_DEBLOCK
-#endif
-
-/**
-Picture type, PV created.
-@publishedAll
-*/
-typedef enum
-{
-    AVC_FRAME = 3
-} AVCPictureType;
-
-/**
-This slice type follows Table 7-3. The bottom 5 items may not needed.
-@publishedAll
-*/
-typedef enum
-{
-    AVC_P_SLICE = 0,
-    AVC_B_SLICE = 1,
-    AVC_I_SLICE = 2,
-    AVC_SP_SLICE = 3,
-    AVC_SI_SLICE = 4,
-    AVC_P_ALL_SLICE = 5,
-    AVC_B_ALL_SLICE = 6,
-    AVC_I_ALL_SLICE = 7,
-    AVC_SP_ALL_SLICE = 8,
-    AVC_SI_ALL_SLICE = 9
-} AVCSliceType;
-
-/**
-Types of the macroblock and partition. PV Created.
-@publishedAll
-*/
-typedef enum
-{
-    /* intra */
-    AVC_I4,
-    AVC_I16,
-    AVC_I_PCM,
-    AVC_SI4,
-
-    /* inter for both P and B*/
-    AVC_BDirect16,
-    AVC_P16,
-    AVC_P16x8,
-    AVC_P8x16,
-    AVC_P8,
-    AVC_P8ref0,
-    AVC_SKIP
-} AVCMBMode;
-
-/**
-Enumeration for sub-macroblock mode, interpreted from sub_mb_type.
-@publishedAll
-*/
-typedef enum
-{
-    /* for sub-partition mode */
-    AVC_BDirect8,
-    AVC_8x8,
-    AVC_8x4,
-    AVC_4x8,
-    AVC_4x4
-} AVCSubMBMode;
-
-/**
-Mode of prediction of partition or sub-partition. PV Created.
-Do not change the order!!! Used in table look-up mode prediction in
-vlc.c.
-@publishedAll
-*/
-typedef enum
-{
-    AVC_Pred_L0 = 0,
-    AVC_Pred_L1,
-    AVC_BiPred,
-    AVC_Direct
-} AVCPredMode;
-
-
-/**
-Mode of intra 4x4 prediction. Table 8-2
-@publishedAll
-*/
-typedef enum
-{
-    AVC_I4_Vertical = 0,
-    AVC_I4_Horizontal,
-    AVC_I4_DC,
-    AVC_I4_Diagonal_Down_Left,
-    AVC_I4_Diagonal_Down_Right,
-    AVC_I4_Vertical_Right,
-    AVC_I4_Horizontal_Down,
-    AVC_I4_Vertical_Left,
-    AVC_I4_Horizontal_Up
-} AVCIntra4x4PredMode;
-
-/**
-Mode of intra 16x16 prediction. Table 8-3
-@publishedAll
-*/
-typedef enum
-{
-    AVC_I16_Vertical = 0,
-    AVC_I16_Horizontal,
-    AVC_I16_DC,
-    AVC_I16_Plane
-} AVCIntra16x16PredMode;
-
-
-/**
-Mode of intra chroma prediction. Table 8-4
-@publishedAll
-*/
-typedef enum
-{
-    AVC_IC_DC = 0,
-    AVC_IC_Horizontal,
-    AVC_IC_Vertical,
-    AVC_IC_Plane
-} AVCIntraChromaPredMode;
-
-/**
-Type of residual going to residual_block_cavlc function, PV created.
-@publishedAll
-*/
-typedef enum
-{
-    AVC_Luma,
-    AVC_Intra16DC,
-    AVC_Intra16AC,
-    AVC_ChromaDC,
-    AVC_ChromaAC
-} AVCResidualType;
-
-
-/**
-This structure contains VUI parameters as specified in Annex E.
-Some variables may be removed from the structure if they are found to be useless to store.
-@publishedAll
-*/
-typedef struct tagHRDParams
-{
-    uint  cpb_cnt_minus1;                                   /* ue(v), range 0..31 */
-    uint  bit_rate_scale;                          /* u(4) */
-    uint  cpb_size_scale;                          /* u(4) */
-    uint32  bit_rate_value_minus1[MAXIMUMVALUEOFcpb_cnt];/* ue(v), range 0..2^32-2 */
-    uint32  cpb_size_value_minus1[MAXIMUMVALUEOFcpb_cnt]; /* ue(v), range 0..2^32-2 */
-    uint  cbr_flag[MAXIMUMVALUEOFcpb_cnt];         /* u(1) */
-    uint  initial_cpb_removal_delay_length_minus1;   /* u(5), default 23 */
-    uint  cpb_removal_delay_length_minus1;           /* u(5), default 23 */
-    uint  dpb_output_delay_length_minus1;            /* u(5), default 23 */
-    uint  time_offset_length;                        /* u(5), default 24 */
-} AVCHRDParams;
-
-/**
-This structure contains VUI parameters as specified in Annex E.
-Some variables may be removed from the structure if they are found to be useless to store.
-@publishedAll
-*/
-typedef struct tagVUIParam
-{
-    uint      aspect_ratio_info_present_flag;     /* u(1) */
-    uint  aspect_ratio_idc;                     /* u(8), table E-1 */
-    uint  sar_width;                          /* u(16) */
-    uint  sar_height;                         /* u(16) */
-    uint      overscan_info_present_flag;         /* u(1) */
-    uint      overscan_appropriate_flag;        /* u(1) */
-    uint      video_signal_type_present_flag;     /* u(1) */
-    uint  video_format;                         /* u(3), Table E-2, default 5, unspecified */
-    uint      video_full_range_flag;            /* u(1) */
-    uint      colour_description_present_flag;  /* u(1) */
-    uint  colour_primaries;                   /* u(8), Table E-3, default 2, unspecified */
-    uint  transfer_characteristics;           /* u(8), Table E-4, default 2, unspecified */
-    uint  matrix_coefficients;                /* u(8), Table E-5, default 2, unspecified */
-    uint      chroma_location_info_present_flag;  /* u(1) */
-    uint  chroma_sample_loc_type_top_field;                /* ue(v), Fig. E-1range 0..5, default 0 */
-    uint  chroma_sample_loc_type_bottom_field;                /* ue(v) */
-    uint      timing_info_present_flag;           /* u(1) */
-    uint  num_units_in_tick;                    /* u(32), must be > 0 */
-    uint  time_scale;                           /* u(32), must be > 0 */
-    uint      fixed_frame_rate_flag;            /* u(1), Eq. C-13 */
-    uint      nal_hrd_parameters_present_flag;    /* u(1) */
-    AVCHRDParams nal_hrd_parameters;               /* hrd_paramters */
-    uint      vcl_hrd_parameters_present_flag;    /* u(1) */
-    AVCHRDParams vcl_hrd_parameters;               /* hrd_paramters */
-    /* if ((nal_hrd_parameters_present_flag || (vcl_hrd_parameters_present_flag)) */
-    uint      low_delay_hrd_flag;               /* u(1) */
-    uint    pic_struct_present_flag;
-    uint      bitstream_restriction_flag;         /* u(1) */
-    uint      motion_vectors_over_pic_boundaries_flag;    /* u(1) */
-    uint  max_bytes_per_pic_denom;              /* ue(v), default 2 */
-    uint  max_bits_per_mb_denom;                /* ue(v), range 0..16, default 1 */
-    uint  log2_max_mv_length_vertical;          /* ue(v), range 0..16, default 16 */
-    uint  log2_max_mv_length_horizontal;        /* ue(v), range 0..16, default 16 */
-    uint  max_dec_frame_reordering;             /* ue(v) */
-    uint  max_dec_frame_buffering;              /* ue(v) */
-} AVCVUIParams;
-
-
-/**
-This structure contains information in a sequence parameter set NAL.
-Some variables may be removed from the structure if they are found to be useless to store.
-@publishedAll
-*/
-typedef struct tagSeqParamSet
-{
-    uint   Valid;            /* indicates the parameter set is valid */
-
-    uint  profile_idc;              /* u(8) */
-    uint   constrained_set0_flag;  /* u(1) */
-    uint   constrained_set1_flag;  /* u(1) */
-    uint   constrained_set2_flag;  /* u(1) */
-    uint   constrained_set3_flag;  /* u(1) */
-    uint  level_idc;               /* u(8) */
-    uint  seq_parameter_set_id;    /* ue(v), range 0..31 */
-    uint  log2_max_frame_num_minus4; /* ue(v), range 0..12 */
-    uint pic_order_cnt_type;        /* ue(v), range 0..2 */
-    /* if( pic_order_cnt_type == 0 )  */
-    uint log2_max_pic_order_cnt_lsb_minus4; /* ue(v), range 0..12 */
-    /* else if( pic_order_cnt_type == 1 ) */
-    uint delta_pic_order_always_zero_flag;  /* u(1) */
-    int32  offset_for_non_ref_pic;       /* se(v) */
-    int32  offset_for_top_to_bottom_field;  /* se(v) */
-    uint  num_ref_frames_in_pic_order_cnt_cycle;   /* ue(v) , range 0..255 */
-    /* for( i = 0; i < num_ref_frames_in_pic_order_cnt_cycle; i++ ) */
-    int32   offset_for_ref_frame[MAX_NUM_REF_FRAMES_IN_PIC_ORDER_CNT_CYCLE];        /* se(v) */
-    uint  num_ref_frames;                           /* ue(v), range 0..16 */
-    uint   gaps_in_frame_num_value_allowed_flag;    /* u(1) */
-    uint  pic_width_in_mbs_minus1;                  /* ue(v) */
-    uint  pic_height_in_map_units_minus1;           /* ue(v) */
-    uint   frame_mbs_only_flag;                     /* u(1) */
-    /* if( !frame_mbs_only_flag ) */
-    uint   mb_adaptive_frame_field_flag;          /* u(1) */
-    uint   direct_8x8_inference_flag;    /* u(1), must be 1 when frame_mbs_only_flag is 0 */
-    uint   frame_cropping_flag;                     /* u(1) */
-    /* if( frmae_cropping_flag) */
-    uint  frame_crop_left_offset;                /* ue(v) */
-    uint  frame_crop_right_offset;               /* ue(v) */
-    uint  frame_crop_top_offset;                 /* ue(v) */
-    uint  frame_crop_bottom_offset;              /* ue(v) */
-    uint   vui_parameters_present_flag;                      /* u(1) */
-//  uint nal_hrd_parameters_present_flag;
-//  uint vcl_hrd_parameters_present_flag;
-//  AVCHRDParams *nal_hrd_parameters;
-//  AVCHRDParams *vcl_hrd_parameters;
-    AVCVUIParams vui_parameters;                  /* AVCVUIParam */
-} AVCSeqParamSet;
-
-/**
-This structure contains information in a picture parameter set NAL.
-Some variables may be removed from the structure if they are found to be useless to store.
-@publishedAll
-*/
-typedef struct tagPicParamSet
-{
-    uint  pic_parameter_set_id;              /* ue(v), range 0..255 */
-    uint  seq_parameter_set_id;              /* ue(v), range 0..31 */
-    uint  entropy_coding_mode_flag;         /* u(1) */
-    uint  pic_order_present_flag;        /* u(1) */
-    uint  num_slice_groups_minus1;           /* ue(v), range in Annex A */
-    /* if( num_slice_groups_minus1 > 0) */
-    uint  slice_group_map_type;           /* ue(v), range 0..6 */
-    /* if( slice_group_map_type = = 0 ) */
-    /* for(0:1:num_slice_groups_minus1) */
-    uint  run_length_minus1[MAX_NUM_SLICE_GROUP]; /* ue(v) */
-    /* else if( slice_group_map_type = = 2 ) */
-    /* for(0:1:num_slice_groups_minus1-1) */
-    uint  top_left[MAX_NUM_SLICE_GROUP-1];      /* ue(v) */
-    uint  bottom_right[MAX_NUM_SLICE_GROUP-1];  /* ue(v) */
-    /* else if( slice_group_map_type = = 3 || 4 || 5 */
-    uint  slice_group_change_direction_flag;        /* u(1) */
-    uint  slice_group_change_rate_minus1;            /* ue(v) */
-    /* else if( slice_group_map_type = = 6 ) */
-    uint  pic_size_in_map_units_minus1;          /* ue(v) */
-    /* for(0:1:pic_size_in_map_units_minus1) */
-    uint  *slice_group_id;                           /* complete MBAmap u(v) */
-    uint  num_ref_idx_l0_active_minus1;                  /* ue(v), range 0..31 */
-    uint  num_ref_idx_l1_active_minus1;                  /* ue(v), range 0..31 */
-    uint  weighted_pred_flag;                           /* u(1) */
-    uint  weighted_bipred_idc;                          /* u(2), range 0..2 */
-    int   pic_init_qp_minus26;                       /* se(v), range -26..25 */
-    int   pic_init_qs_minus26;                       /* se(v), range -26..25 */
-    int   chroma_qp_index_offset;                    /* se(v), range -12..12 */
-    uint  deblocking_filter_control_present_flag;       /* u(1) */
-    uint  constrained_intra_pred_flag;                  /* u(1) */
-    uint  redundant_pic_cnt_present_flag;               /* u(1) */
-} AVCPicParamSet;
-
-
-/**
-This structure contains slice header information.
-Some variables may be removed from the structure if they are found to be useless to store.
-@publishedAll
-*/
-typedef struct tagSliceHeader
-{
-    uint    first_mb_in_slice;      /* ue(v) */
-    AVCSliceType slice_type;                /* ue(v), Table 7-3, range 0..9 */
-    uint    pic_parameter_set_id;   /* ue(v), range 0..255 */
-    uint    frame_num;              /* u(v), see log2max_frame_num_minus4 */
-    /* if( !frame_mbs_only_flag) */
-    uint    field_pic_flag;         /* u(1) */
-    /* if(field_pic_flag) */
-    uint bottom_field_flag; /* u(1) */
-    /* if(nal_unit_type == 5) */
-    uint    idr_pic_id;         /* ue(v), range 0..65535 */
-    /* if(pic_order_cnt_type==0) */
-    uint    pic_order_cnt_lsb;  /* u(v), range 0..MaxPicOrderCntLsb-1 */
-    /* if(pic_order_present_flag && !field_pic_flag) */
-    int32 delta_pic_order_cnt_bottom;   /* se(v) */
-    /* if(pic_order_cnt_type==1 && !delta_pic_order_always_zero_flag) */
-    /* if(pic_order_present_flag && !field_pic_flag) */
-    int32 delta_pic_order_cnt[2];
-    /* if(redundant_pic_cnt_present_flag) */
-    uint redundant_pic_cnt; /* ue(v), range 0..127 */
-    /* if(slice_type == B) */
-    uint direct_spatial_mv_pred_flag; /* u(1) */
-    /* if(slice_type == P || slice_type==SP || slice_type==B) */
-    uint num_ref_idx_active_override_flag;  /* u(1) */
-    /* if(num_ref_idx_active_override_flag) */
-    uint num_ref_idx_l0_active_minus1;  /* ue(v) */
-    /* if(slie_type == B) */
-    uint num_ref_idx_l1_active_minus1;  /* ue(v) */
-
-    /* ref_pic_list_reordering() */
-    uint ref_pic_list_reordering_flag_l0;   /* u(1) */
-    uint reordering_of_pic_nums_idc_l0[MAX_REF_PIC_LIST_REORDERING];   /* ue(v), range 0..3 */
-    uint abs_diff_pic_num_minus1_l0[MAX_REF_PIC_LIST_REORDERING];   /* ue(v) */
-    uint long_term_pic_num_l0[MAX_REF_PIC_LIST_REORDERING];     /* ue(v) */
-    uint ref_pic_list_reordering_flag_l1;   /* u(1) */
-    uint reordering_of_pic_nums_idc_l1[MAX_REF_PIC_LIST_REORDERING];   /* ue(v), range 0..3 */
-    uint abs_diff_pic_num_minus1_l1[MAX_REF_PIC_LIST_REORDERING];   /* ue(v) */
-    uint long_term_pic_num_l1[MAX_REF_PIC_LIST_REORDERING];     /* ue(v) */
-
-    /* end ref_pic_list_reordering() */
-    /* if(nal_ref_idc!=0) */
-    /* dec_ref_pic_marking() */
-    uint    no_output_of_prior_pics_flag;   /* u(1) */
-    uint long_term_reference_flag;      /* u(1) */
-    uint    adaptive_ref_pic_marking_mode_flag; /* u(1) */
-    uint    memory_management_control_operation[MAX_DEC_REF_PIC_MARKING];   /* ue(v), range 0..6 */
-    uint difference_of_pic_nums_minus1[MAX_DEC_REF_PIC_MARKING];    /* ue(v) */
-    uint    long_term_pic_num[MAX_DEC_REF_PIC_MARKING];             /* ue(v) */
-    uint    long_term_frame_idx[MAX_DEC_REF_PIC_MARKING];           /* ue(v) */
-    uint    max_long_term_frame_idx_plus1[MAX_DEC_REF_PIC_MARKING]; /* ue(v) */
-    /* end dec_ref_pic_marking() */
-    /* if(entropy_coding_mode_flag && slice_type!=I && slice_type!=SI) */
-    uint cabac_init_idc;        /* ue(v), range 0..2 */
-    int slice_qp_delta;     /* se(v), range 0..51 */
-    /* if(slice_type==SP || slice_type==SI) */
-    /* if(slice_type==SP) */
-    uint    sp_for_switch_flag; /* u(1) */
-    int slice_qs_delta;     /* se(v) */
-
-    /* if(deblocking_filter_control_present_flag)*/
-    uint disable_deblocking_filter_idc; /* ue(v), range 0..2 */
-    /* if(disable_deblocking_filter_idc!=1) */
-    int slice_alpha_c0_offset_div2; /* se(v), range -6..6, default 0 */
-    int slice_beta_offset_div_2; /* se(v), range -6..6, default 0 */
-    /* if(num_slice_groups_minus1>0 && slice_group_map_type>=3 && slice_group_map_type<=5)*/
-    uint    slice_group_change_cycle;   /* u(v), use ceil(log2(PicSizeInMapUnits/SliceGroupChangeRate + 1)) bits*/
-
-} AVCSliceHeader;
-
-/**
-This struct contains information about the neighboring pixel.
-@publishedAll
-*/
-typedef struct tagPixPos
-{
-    int available;
-    int mb_addr;    /* macroblock address of the current pixel, see below */
-    int x;      /* x,y positions of current pixel relative to the macroblock mb_addr */
-    int y;
-    int pos_x;  /* x,y positions of current pixel relative to the picture. */
-    int pos_y;
-} AVCPixelPos;
-
-typedef struct tagNeighborAvailability
-{
-    int left;
-    int top;    /* macroblock address of the current pixel, see below */
-    int top_right;      /* x,y positions of current pixel relative to the macroblock mb_addr */
-} AVCNeighborAvailability;
-
-
-/**
-This structure contains picture data and related information necessary to be used as
-reference frame.
-@publishedAll
-*/
-typedef struct tagPictureData
-{
-    uint16 RefIdx;  /* index used for reference frame */
-    uint8 *Sl;   /* derived from base_dpb in AVCFrameStore */
-    uint8 *Scb;  /* for complementary fields, YUV are interlaced */
-    uint8 *Scr;  /* Sl of top_field and bottom_fields will be one line apart and the
-                    stride will be 2 times the width. */
-    /* For non-complementary field, the above still applies. A special
-       output formatting is required. */
-
-    /* Then, necessary variables that need to be stored */
-    AVCPictureType  picType; /* frame, top-field or bot-field */
-    /*bool*/
-    uint    isReference;
-    /*bool*/
-    uint    isLongTerm;
-    int     PicOrderCnt;
-    int     PicNum;
-    int     LongTermPicNum;
-
-    int     width; /* how many pixel per line */
-    int     height;/* how many line */
-    int     pitch; /* how many pixel between the line */
-
-    uint    padded; /* flag for being padded */
-
-} AVCPictureData;
-
-/**
-This structure contains information for frame storage.
-@publishedAll
-*/
-typedef struct tagFrameStore
-{
-    uint8 *base_dpb;    /* base pointer for the YCbCr */
-
-    int     IsReference; /*  0=not used for ref; 1=top used; 2=bottom used; 3=both fields (or frame) used */
-    int     IsLongTerm;  /*  0=not used for ref; 1=top used; 2=bottom used; 3=both fields (or frame) used */
-    /* if IsLongTerm is true, IsReference can be ignored. */
-    /* if IsReference is true, IsLongterm will be checked for short-term or long-term. */
-    /* IsUsed must be true to enable the validity of IsReference and IsLongTerm */
-
-    int     IsOutputted;  /* has it been outputted via AVCDecGetOutput API, then don't output it again,
-                            wait until it is returned. */
-    AVCPictureData frame;
-
-    int     FrameNum;
-    int     FrameNumWrap;
-    int     LongTermFrameIdx;
-    int     PicOrderCnt; /* of the frame, smaller of the 2 fields */
-
-} AVCFrameStore;
-
-/**
-This structure maintains the actual memory for the decoded picture buffer (DPB) which is
-allocated at the beginning according to profile/level.
-Once decoded_picture_buffer is allocated, Sl,Scb,Scr in
-AVCPictureData structure just point to the address in decoded_picture_buffer.
-used_size maintains the used space.
-NOTE:: In order to maintain contiguous memory space, memory equal to a single frame is
-assigned at a time. Two opposite fields reside in the same frame memory.
-
-  |-------|---|---|---|xxx|-------|xxx|---|-------|   decoded_picture_buffer
-    frame  top bot top      frame      bot  frame
-      0     1   1   2         3         4     5
-
-  bot 2 and top 4 do not exist, the memory is not used.
-
-@publishedAll
-*/
-typedef struct tagDecPicBuffer
-{
-    uint8 *decoded_picture_buffer;  /* actual memory */
-    uint32  dpb_size;       /* size of dpb in bytes */
-    uint32  used_size;  /* used size */
-    struct tagFrameStore    *fs[MAX_FS]; /* list of frame stored, actual buffer */
-    int     num_fs;  /* size of fs */
-
-} AVCDecPicBuffer;
-
-
-/**
-This structure contains macroblock related variables.
-@publishedAll
-*/
-typedef struct tagMacroblock
-{
-    AVCIntraChromaPredMode  intra_chroma_pred_mode;  /* ue(v) */
-
-    int32 mvL0[16];  /* motion vectors, 16 bit packed (x,y) per element  */
-    int32 mvL1[16];
-    int16 ref_idx_L0[4];
-    int16 ref_idx_L1[4];
-    uint16 RefIdx[4]; /* ref index, has value of AVCPictureData->RefIdx */
-    /* stored data */
-    /*bool*/
-    uint    mb_intra; /* intra flag */
-    /*bool*/
-    uint    mb_bottom_field;
-
-    AVCMBMode mbMode;   /* type of MB prediction */
-    AVCSubMBMode subMbMode[4]; /* for each 8x8 partition */
-
-    uint    CBP; /* CodeBlockPattern */
-    AVCIntra16x16PredMode i16Mode; /* Intra16x16PredMode */
-    AVCIntra4x4PredMode i4Mode[16]; /* Intra4x4PredMode, in raster scan order */
-    int NumMbPart; /* number of partition */
-    AVCPredMode MBPartPredMode[4][4]; /* prediction mode [MBPartIndx][subMBPartIndx] */
-    int MbPartWidth;
-    int MbPartHeight;
-    int NumSubMbPart[4];  /* for each 8x8 partition */
-    int SubMbPartWidth[4];  /* for each 8x8 partition */
-    int SubMbPartHeight[4]; /* for each 8x8 partition */
-
-    uint8 nz_coeff[NUM_BLKS_IN_MB];  /* [blk_y][blk_x], Chroma is [4..5][0...3], see predict_nnz() function */
-
-    int QPy; /* Luma QP */
-    int QPc; /* Chroma QP */
-    int QSc; /* Chroma QP S-picture */
-
-    int slice_id;           // MC slice
-} AVCMacroblock;
-
-
-/**
-This structure contains common internal variables between the encoder and decoder
-such that some functions can be shared among them.
-@publishedAll
-*/
-typedef struct tagCommonObj
-{
-    /* put these 2 up here to make sure they are word-aligned */
-    int16   block[NUM_PIXELS_IN_MB]; /* for transformed residue coefficient */
-    uint8   *pred_block;    /* pointer to prediction block, could point to a frame */
-#ifdef USE_PRED_BLOCK
-    uint8   pred[688];  /* for prediction */
-    /* Luma [0-399], Cb [400-543], Cr[544-687] */
-#endif
-    int     pred_pitch; /* either equal to 20 or to frame pitch */
-
-    /* temporary buffers for intra prediction */
-    /* these variables should remain inside fast RAM */
-#ifdef MB_BASED_DEBLOCK
-    uint8   *intra_pred_top; /* a row of pixel for intra prediction */
-    uint8   intra_pred_left[17]; /* a column of pixel for intra prediction */
-    uint8   *intra_pred_top_cb;
-    uint8   intra_pred_left_cb[9];
-    uint8   *intra_pred_top_cr;
-    uint8   intra_pred_left_cr[9];
-#endif
-    /* pointer to the prediction area for intra prediction */
-    uint8   *pintra_pred_top;   /* pointer to the top intra prediction value */
-    uint8   *pintra_pred_left;  /* pointer to the left intra prediction value */
-    uint8   intra_pred_topleft; /* the [-1,-1] neighboring pixel */
-    uint8   *pintra_pred_top_cb;
-    uint8   *pintra_pred_left_cb;
-    uint8   intra_pred_topleft_cb;
-    uint8   *pintra_pred_top_cr;
-    uint8   *pintra_pred_left_cr;
-    uint8   intra_pred_topleft_cr;
-
-    int QPy;
-    int QPc;
-    int QPy_div_6;
-    int QPy_mod_6;
-    int QPc_div_6;
-    int QPc_mod_6;
-    /**** nal_unit ******/
-    /* previously in AVCNALUnit format */
-    uint    NumBytesInRBSP;
-    int     forbidden_bit;
-    int     nal_ref_idc;
-    AVCNalUnitType  nal_unit_type;
-    AVCNalUnitType  prev_nal_unit_type;
-    /*bool*/
-    uint    slice_data_partitioning; /* flag when nal_unit_type is between 2 and 4 */
-    /**** ******** ******/
-    AVCSliceType slice_type;
-    AVCDecPicBuffer     *decPicBuf; /* decoded picture buffer */
-
-    AVCSeqParamSet *currSeqParams; /*  the currently used one */
-
-    AVCPicParamSet  *currPicParams; /* the currently used one */
-    uint        seq_parameter_set_id;
-    /* slice header */
-    AVCSliceHeader *sliceHdr;   /* slice header param syntax variables */
-
-    AVCPictureData  *currPic; /* pointer to current picture */
-    AVCFrameStore   *currFS;  /* pointer to current frame store */
-    AVCPictureType  currPicType; /* frame, top-field or bot-field */
-    /*bool*/
-    uint    newPic; /* flag for new picture */
-    uint            newSlice; /* flag for new slice */
-    AVCPictureData  *prevRefPic; /* pointer to previous picture */
-
-    AVCMacroblock   *mblock; /* array of macroblocks covering entire picture */
-    AVCMacroblock   *currMB; /* pointer to current macroblock */
-    uint                    mbNum; /* number of current MB */
-    int                 mb_x;  /* x-coordinate of the current mbNum */
-    int                 mb_y;  /* y-coordinate of the current mbNum */
-
-    /* For internal operation, scratch memory for MV, prediction, transform, etc.*/
-    uint32 cbp4x4; /* each bit represent nonzero 4x4 block in reverse raster scan order */
-    /* starting from luma, Cb and Cr, lsb toward msb */
-    int mvd_l0[4][4][2]; /* [mbPartIdx][subMbPartIdx][compIdx], se(v) */
-    int mvd_l1[4][4][2]; /* [mbPartIdx][subMbPartIdx][compIdx], se(v) */
-
-    int mbAddrA, mbAddrB, mbAddrC, mbAddrD; /* address of neighboring MBs */
-    /*bool*/
-    uint    mbAvailA, mbAvailB, mbAvailC, mbAvailD; /* availability */
-    /*bool*/
-    uint    intraAvailA, intraAvailB, intraAvailC, intraAvailD; /* for intra mode */
-    /***********************************************/
-    /* The following variables are defined in the draft. */
-    /* They may need to be stored in PictureData structure and used for reference. */
-    /* In that case, just move or copy it to AVCDecPictureData structure. */
-
-    int     padded_size;    /* size of extra padding to a frame */
-
-    uint    MaxFrameNum;    /*2^(log2_max_frame_num_minus4+4), range 0.. 2^16-1 */
-    uint    MaxPicOrderCntLsb; /*2^(log2_max_pic_order_cnt_lsb_minus4+4), 0..2^16-1 */
-    uint    PicWidthInMbs;  /*pic_width_in_mbs_minus1+1 */
-    uint    PicWidthInSamplesL; /* PicWidthInMbs*16 */
-    uint    PicWidthInSamplesC; /* PicWIdthInMbs*8 */
-    uint    PicHeightInMapUnits; /* pic_height_in_map_units_minus1+1 */
-    uint    PicSizeInMapUnits;  /* PicWidthInMbs*PicHeightInMapUnits */
-    uint    FrameHeightInMbs;   /*(2-frame_mbs_only_flag)*PicHeightInMapUnits */
-
-    uint    SliceGroupChangeRate; /* slice_group_change_rate_minus1 + 1 */
-
-    /* access unit */
-    uint    primary_pic_type;   /* u(3), Table 7-2, kinda informative only */
-
-    /* slice data partition */
-    uint    slice_id;           /* ue(v) */
-
-    uint    UnusedShortTermFrameNum;
-    uint    PrevRefFrameNum;
-    uint    MbaffFrameFlag; /* (mb_adaptive_frame_field_flag && !field_pic_flag) */
-    uint    PicHeightInMbs; /* FrameHeightInMbs/(1+field_pic_flag) */
-    int     PicHeightInSamplesL; /* PicHeightInMbs*16 */
-    int     PicHeightInSamplesC; /* PicHeightInMbs*8 */
-    uint    PicSizeInMbs;   /* PicWidthInMbs*PicHeightInMbs */
-    uint    level_idc;
-    int     numMBs;
-    uint    MaxPicNum;
-    uint    CurrPicNum;
-    int     QSy;    /* 26+pic_init_qp_minus26+slice_qs_delta */
-    int     FilterOffsetA;
-    int     FilterOffsetB;
-    uint    MapUnitsInSliceGroup0;  /* Min(slie_group_change_cycle*SliceGroupChangeRate,PicSizeInMapUnits) */
-    /* dec_ref_pic_marking */
-    int     MaxLongTermFrameIdx;
-    int     LongTermFrameIdx;
-
-    /* POC related variables */
-    /*bool*/
-    uint    mem_mgr_ctrl_eq_5;  /* if memory_management_control_operation equal to 5 flag */
-    int     PicOrderCnt;
-    int     BottomFieldOrderCnt, TopFieldOrderCnt;
-    /* POC mode 0 */
-    int     prevPicOrderCntMsb;
-    uint    prevPicOrderCntLsb;
-    int     PicOrderCntMsb;
-    /* POC mode 1 */
-    int     prevFrameNumOffset, FrameNumOffset;
-    uint    prevFrameNum;
-    int     absFrameNum;
-    int     picOrderCntCycleCnt, frameNumInPicOrderCntCycle;
-    int     expectedDeltaPerPicOrderCntCycle;
-    int     expectedPicOrderCnt;
-
-    /* FMO */
-    int *MbToSliceGroupMap;  /* to be re-calculate at the beginning */
-
-    /* ref pic list */
-    AVCPictureData  *RefPicList0[MAX_REF_PIC_LIST]; /* list 0 */
-    AVCPictureData  *RefPicList1[MAX_REF_PIC_LIST]; /* list 1 */
-    AVCFrameStore   *refFrameList0ShortTerm[32];
-    AVCFrameStore   *refFrameList1ShortTerm[32];
-    AVCFrameStore   *refFrameListLongTerm[32];
-    int     refList0Size;
-    int     refList1Size;
-
-    /* slice data semantics*/
-    int mb_skip_run;    /* ue(v) */
-    /*uint  mb_skip_flag;*/ /* ae(v) */
-    /* uint end_of_slice_flag;*//* ae(v) */
-    /***********************************************/
-
-    /* function pointers */
-    int (*is_short_ref)(AVCPictureData *s);
-    int (*is_long_ref)(AVCPictureData *s);
-
-} AVCCommonObj;
-
-/**
-Commonly used constant arrays.
-@publishedAll
-*/
-/**
-Zigzag scan from 1-D to 2-D. */
-const static uint8 ZZ_SCAN[16] = {0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13, 10, 7, 11, 14, 15};
-/* Zigzag scan from 1-D to 2-D output to block[24][16]. */
-const static uint8 ZZ_SCAN_BLOCK[16] = {0, 1, 16, 32, 17, 2, 3, 18, 33, 48, 49, 34, 19, 35, 50, 51};
-
-/**
-From zigzag to raster for luma DC value */
-const static uint8 ZIGZAG2RASTERDC[16] = {0, 4, 64, 128, 68, 8, 12, 72, 132, 192, 196, 136, 76, 140, 200, 204};
-
-
-/**
-Mapping from coding scan block indx to raster scan block index */
-const static int blkIdx2blkX[16] = {0, 1, 0, 1, 2, 3, 2, 3, 0, 1, 0, 1, 2, 3, 2, 3};
-const static int blkIdx2blkY[16] = {0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 2, 2, 3, 3};
-/** from [blk8indx][blk4indx] to raster scan index */
-const static int blkIdx2blkXY[4][4] = {{0, 1, 4, 5}, {2, 3, 6, 7}, {8, 9, 12, 13}, {10, 11, 14, 15}};
-
-/*
-Availability of the neighboring top-right block relative to the current block. */
-const static int BlkTopRight[16] = {2, 2, 2, 3, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0};
-
-/**
-Table 8-13 Specification of QPc as a function of qPI. */
-const static uint8 mapQPi2QPc[52] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
-                                     21, 22, 23, 24, 25, 26, 27, 28, 29, 29, 30, 31, 32, 32, 33, 34, 34, 35, 35, 36, 36,
-                                     37, 37, 37, 38, 38, 38, 39, 39, 39, 39
-                                    };
-
-/**
-See 8.5.5 equation (8-252 and 8-253) the definition of v matrix. */
-/* in zigzag scan */
-const static int dequant_coefres[6][16] =
-{
-    {10, 13, 13, 10, 16, 10, 13, 13, 13, 13, 16, 10, 16, 13, 13, 16},
-    {11, 14, 14, 11, 18, 11, 14, 14, 14, 14, 18, 11, 18, 14, 14, 18},
-    {13, 16, 16, 13, 20, 13, 16, 16, 16, 16, 20, 13, 20, 16, 16, 20},
-    {14, 18, 18, 14, 23, 14, 18, 18, 18, 18, 23, 14, 23, 18, 18, 23},
-    {16, 20, 20, 16, 25, 16, 20, 20, 20, 20, 25, 16, 25, 20, 20, 25},
-    {18, 23, 23, 18, 29, 18, 23, 23, 23, 23, 29, 18, 29, 23, 23, 29}
-};
-
-/**
-From jm7.6 block.c. (in zigzag scan) */
-const static int quant_coef[6][16] =
-{
-    {13107, 8066,   8066,   13107,  5243,   13107,  8066,   8066,   8066,   8066,   5243,   13107,  5243,   8066,   8066,   5243},
-    {11916, 7490,   7490,   11916,  4660,   11916,  7490,   7490,   7490,   7490,   4660,   11916,  4660,   7490,   7490,   4660},
-    {10082, 6554,   6554,   10082,  4194,   10082,  6554,   6554,   6554,   6554,   4194,   10082,  4194,   6554,   6554,   4194},
-    {9362,  5825,   5825,   9362,   3647,   9362,   5825,   5825,   5825,   5825,   3647,   9362,   3647,   5825,   5825,   3647},
-    {8192,  5243,   5243,   8192,   3355,   8192,   5243,   5243,   5243,   5243,   3355,   8192,   3355,   5243,   5243,   3355},
-    {7282,  4559,   4559,   7282,   2893,   7282,   4559,   4559,   4559,   4559,   2893,   7282,   2893,   4559,   4559,   2893}
-};
-
-/**
-Convert scan from raster scan order to block decoding order and
-from block decoding order to raster scan order. Same table!!!
-*/
-const static uint8 ras2dec[16] = {0, 1, 4, 5, 2, 3, 6, 7, 8, 9, 12, 13, 10, 11, 14, 15};
-
-/* mapping from level_idc to index map */
-const static uint8 mapLev2Idx[61] = {255, 255, 255, 255, 255, 255, 255, 255, 255, 1,
-                                     0, 1, 2, 3, 255, 255, 255, 255, 255, 255,
-                                     4, 5, 6, 255, 255, 255, 255, 255, 255, 255,
-                                     7, 8, 9, 255, 255, 255, 255, 255, 255, 255,
-                                     10, 11, 12, 255, 255, 255, 255, 255, 255, 255,
-                                     13, 14, 255, 255, 255, 255, 255, 255, 255, 255
-                                    };
-/* map back from index to Level IDC */
-const static uint8 mapIdx2Lev[MAX_LEVEL_IDX] = {10, 11, 12, 13, 20, 21, 22, 30, 31, 32, 40, 41, 42, 50, 51};
-
-/**
-from the index map to the MaxDPB value times 2 */
-const static int32 MaxDPBX2[MAX_LEVEL_IDX] = {297, 675, 1782, 1782, 1782, 3564, 6075, 6075,
-        13500, 15360, 24576, 24576, 24576, 82620, 138240
-                                             };
-
-/* map index to the max frame size */
-const static int MaxFS[MAX_LEVEL_IDX] = {99, 396, 396, 396, 396, 792, 1620, 1620, 3600, 5120,
-                                        8192, 8192, 8192, 22080, 36864
-                                        };
-
-/* map index to max MB processing rate */
-const static int32 MaxMBPS[MAX_LEVEL_IDX] = {1485, 3000, 6000, 11880, 11880, 19800, 20250, 40500,
-        108000, 216000, 245760, 245760, 491520, 589824, 983040
-                                            };
-
-/* map index to max video bit rate */
-const static uint32 MaxBR[MAX_LEVEL_IDX] = {64, 192, 384, 768, 2000, 4000, 4000, 10000, 14000, 20000,
-        20000, 50000, 50000, 135000, 240000
-                                           };
-
-/* map index to max CPB size */
-const static uint32 MaxCPB[MAX_LEVEL_IDX] = {175, 500, 1000, 2000, 2000, 4000, 4000, 10000, 14000,
-        20000, 25000, 62500, 62500, 135000, 240000
-                                            };
-
-/* map index to max vertical MV range */
-const static int MaxVmvR[MAX_LEVEL_IDX] = {64, 128, 128, 128, 128, 256, 256, 256, 512, 512, 512, 512, 512, 512, 512};
-
-#endif /*  _AVCINT_COMMON_H_ */
diff --git a/media/libstagefright/codecs/avc/common/include/avclib_common.h b/media/libstagefright/codecs/avc/common/include/avclib_common.h
deleted file mode 100644
index cbbf0c6..0000000
--- a/media/libstagefright/codecs/avc/common/include/avclib_common.h
+++ /dev/null
@@ -1,557 +0,0 @@
-/* ------------------------------------------------------------------
- * 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 file contains declarations of internal functions for common encoder/decoder library.
-@publishedAll
-*/
-#ifndef AVCCOMMON_LIB_H_INCLUDED
-#define AVCCOMMON_LIB_H_INCLUDED
-
-#include <stdlib.h>
-
-#ifndef AVCINT_COMMON_H_INCLUDED
-#include "avcint_common.h"
-#endif
-
-/*----------- deblock.c --------------*/
-/**
-This function performs conditional deblocking on a complete picture.
-\param "video"  "Pointer to AVCCommonObj."
-\return "AVC_SUCCESS for success and AVC_FAIL otherwise."
-*/
-OSCL_IMPORT_REF AVCStatus DeblockPicture(AVCCommonObj *video);
-
-/**
-This function performs MB-based deblocking when MB_BASED_DEBLOCK
-is defined at compile time.
-\param "video"  "Pointer to AVCCommonObj."
-\return "AVC_SUCCESS for success and AVC_FAIL otherwise."
-*/
-void MBInLoopDeblock(AVCCommonObj *video);
-
-
-/*---------- dpb.c --------------------*/
-/**
-This function is called everytime a new sequence is detected.
-\param "avcHandle"  "Pointer to AVCHandle."
-\param "video" "Pointer to AVCCommonObj."
-\param "padding"    "Flag specifying whether padding in luma component is needed (used for encoding)."
-\return "AVC_SUCCESS or AVC_FAIL."
-*/
-OSCL_IMPORT_REF AVCStatus AVCConfigureSequence(AVCHandle *avcHandle, AVCCommonObj *video, bool padding);
-
-/**
-This function allocates and initializes the decoded picture buffer structure based on
-the profile and level for the first sequence parameter set. Currently,
-it does not allow changing in profile/level for subsequent SPS.
-\param "avcHandle"  "Pointer to AVCHandle."
-\param "video" "Pointer to AVCCommonObj."
-\param "FrameHeightInMbs"   "Height of the frame in the unit of MBs."
-\param "PicWidthInMbs"  "Width of the picture in the unit of MBs."
-\param "padding"    "Flag specifying whether padding in luma component is needed (used for encoding)."
-\return "AVC_SUCCESS or AVC_FAIL."
-*/
-AVCStatus InitDPB(AVCHandle *avcHandle, AVCCommonObj *video, int FrameHeightInMbs, int PicWidthInMbs, bool padding);
-
-/**
-This function frees the DPB memory.
-\param "avcHandle"  "Pointer to AVCHandle."
-\param "video" "Pointer to AVCCommonObj."
-\return "AVC_SUCCESS or AVC_FAIL."
-*/
-OSCL_IMPORT_REF AVCStatus CleanUpDPB(AVCHandle *avcHandle, AVCCommonObj *video);
-
-/**
-This function finds empty frame in the decoded picture buffer to be used for the
-current picture, initializes the corresponding picture structure with Sl, Scb, Scr,
-width, height and pitch.
-\param "avcHandle" "Pointer to the main handle object."
-\param "video"  "Pointer to AVCCommonObj."
-\return "AVC_SUCCESS or AVC_FAIL."
-*/
-OSCL_IMPORT_REF AVCStatus DPBInitBuffer(AVCHandle *avcHandle, AVCCommonObj *video);
-/**
-This function finds empty frame in the decoded picture buffer to be used for the
-current picture, initializes the corresponding picture structure with Sl, Scb, Scr,
-width, height and pitch.
-\param "video"  "Pointer to AVCCommonObj."
-\param "CurrPicNum" "Current picture number (only used in decoder)."
-\return "AVC_SUCCESS or AVC_FAIL."
-*/
-
-OSCL_IMPORT_REF void DPBInitPic(AVCCommonObj *video, int CurrPicNum);
-
-/**
-This function releases the current frame back to the available pool for skipped frame after encoding.
-\param "avcHandle" "Pointer to the main handle object."
-\param "video" "Pointer to the AVCCommonObj."
-\return "void."
-*/
-OSCL_IMPORT_REF void DPBReleaseCurrentFrame(AVCHandle *avcHandle, AVCCommonObj *video);
-
-/**
-This function performs decoded reference picture marking process and store the current picture to the
-corresponding frame storage in the decoded picture buffer.
-\param "avcHandle" "Pointer to the main handle object."
-\param "video" "Pointer to the AVCCommonObj."
-\return "AVC_SUCCESS or AVC_FAIL."
-*/
-OSCL_IMPORT_REF AVCStatus StorePictureInDPB(AVCHandle *avcHandle, AVCCommonObj *video);
-
-/**
-This function perform sliding window operation on the reference picture lists, see subclause 8.2.5.3.
-It removes short-term ref frames with smallest FrameNumWrap from the reference list.
-\param "avcHandle" "Pointer to the main handle object."
-\param "video" "Pointer to the AVCCommonObj."
-\param "dpb"  "Pointer to the AVCDecPicBuffer."
-\return "AVC_SUCCESS or AVC_FAIL (contradicting values or scenario as in the Note in the draft)."
-*/
-AVCStatus sliding_window_process(AVCHandle *avcHandle, AVCCommonObj *video, AVCDecPicBuffer *dpb);
-
-
-/**
-This function perform adaptive memory marking operation on the reference picture lists,
-see subclause 8.2.5.4. It calls other functions for specific operations.
-\param "video" "Pointer to the AVCCommonObj."
-\param "dpb"  "Pointer to the AVCDecPicBuffer."
-\param "sliceHdr"   "Pointer to the AVCSliceHeader."
-\return "AVC_SUCCESS or AVC_FAIL (contradicting values or scenario as in the Note in the draft)."
-*/
-AVCStatus adaptive_memory_marking(AVCHandle *avcHandle, AVCCommonObj *video, AVCDecPicBuffer *dpb, AVCSliceHeader *sliceHdr);
-
-/**
-This function performs memory management control operation 1, marking a short-term picture
-as unused for reference. See subclause 8.2.5.4.1.
-\param "video" "Pointer to the AVCCommonObj."
-\param "dpb"  "Pointer to the AVCDecPicBuffer."
-\param "difference_of_pic_nums_minus1"  "From the syntax in dec_ref_pic_marking()."
-*/
-void MemMgrCtrlOp1(AVCHandle *avcHandle, AVCCommonObj *video, AVCDecPicBuffer *dpb, int difference_of_pic_nums_minus1);
-
-/**
-This function performs memory management control operation 2, marking a long-term picture
-as unused for reference. See subclause 8.2.5.4.2.
-\param "dpb"  "Pointer to the AVCDecPicBuffer."
-\param "field_pic_flag"  "Flag whether the current picture is field or not."
-\param "long_term_pic_num"  "From the syntax in dec_ref_pic_marking()."
-*/
-void MemMgrCtrlOp2(AVCHandle *avcHandle, AVCDecPicBuffer *dpb, int long_term_pic_num);
-
-/**
-This function performs memory management control operation 3, assigning a LongTermFrameIdx to
-a short-term reference picture. See subclause 8.2.5.4.3.
-\param "video" "Pointer to the AVCCommonObj."
-\param "dpb"  "Pointer to the AVCDecPicBuffer."
-\param "difference_of_pic_nums_minus1"  "From the syntax in dec_ref_pic_marking()."
-\param "long_term_pic_num"  "From the syntax in dec_ref_pic_marking()."
-*/
-void MemMgrCtrlOp3(AVCHandle *avcHandle, AVCCommonObj *video, AVCDecPicBuffer *dpb, uint difference_of_pic_nums_minus1,
-                   uint long_term_frame_idx);
-
-/**
-This function performs memory management control operation 4, getting new MaxLongTermFrameIdx.
- See subclause 8.2.5.4.4.
-\param "video" "Pointer to the AVCCommonObj."
-\param "dpb"  "Pointer to the AVCDecPicBuffer."
-\param "max_long_term_frame_idx_plus1"  "From the syntax in dec_ref_pic_marking()."
-*/
-void MemMgrCtrlOp4(AVCHandle *avcHandle, AVCCommonObj *video, AVCDecPicBuffer *dpb, uint max_long_term_frame_idx_plus1);
-
-/**
-This function performs memory management control operation 5, marking all reference pictures
-as unused for reference and set MaxLongTermFrameIdx to no long-termframe indices.
- See subclause 8.2.5.4.5.
-\param "video" "Pointer to the AVCCommonObj."
-\param "dpb"  "Pointer to the AVCDecPicBuffer."
-*/
-void MemMgrCtrlOp5(AVCHandle *avcHandle, AVCCommonObj *video, AVCDecPicBuffer *dpb);
-
-/**
-This function performs memory management control operation 6, assigning a long-term frame index
-to the current picture. See subclause 8.2.5.4.6.
-\param "video" "Pointer to the AVCCommonObj."
-\param "dpb"  "Pointer to the AVCDecPicBuffer."
-\param "long_term_frame_idx"  "From the syntax in dec_ref_pic_marking()."
-*/
-void MemMgrCtrlOp6(AVCHandle *avcHandle, AVCCommonObj *video, AVCDecPicBuffer *dpb, uint long_term_frame_idx);
-
-/**
-This function mark a long-term ref frame with a specific frame index as unused for reference.
-\param "dpb"  "Pointer to the AVCDecPicBuffer."
-\param "long_term_frame_idx"  "To look for"
-*/
-void unmark_long_term_frame_for_reference_by_frame_idx(AVCHandle *avcHandle, AVCDecPicBuffer *dpb, uint long_term_frame_idx);
-
-/**
-This function mark a long-term ref field with a specific frame index as unused for reference except
-a frame that contains a picture with picNumX.
-\param "dpb"  "Pointer to the AVCDecPicBuffer."
-\param "long_term_frame_idx"  "To look for."
-\param "picNumX"    "To look for."
-*/
-void unmark_long_term_field_for_reference_by_frame_idx(AVCCommonObj *video, AVCDecPicBuffer *dpb, uint long_term_frame_indx, int picNumX);
-
-/**
-This function mark a frame to unused for reference.
-\param "fs" "Pointer to AVCFrameStore to be unmarked."
-*/
-void unmark_for_reference(AVCHandle *avcHandle, AVCDecPicBuffer *dpb, uint idx);
-
-void update_ref_list(AVCDecPicBuffer *dpb);
-
-
-/*---------- fmo.c --------------*/
-/**
-This function initializes flexible macroblock reordering.
-\param "video"  "Pointer to AVCCommonObj."
-\return "AVC_SUCCESS for success and AVC_FAIL otherwise."
-*/
-OSCL_IMPORT_REF AVCStatus FMOInit(AVCCommonObj *video);
-
-/**
-This function fills up an array that maps Map unit to the slice group
-following the interleaved slice group map type.
-\param "mapUnitToSliceGroupMap" "Array of slice group mapping."
-\param "run_length_minus1"  "Array of the run-length."
-\param "num_slice_groups_minus_1"   "Number of slice group minus 1."
-\param "PicSizeInMapUnit"   "Size of the picture in number Map units."
-\return "Void."
-*/
-void FmoGenerateType0MapUnitMap(int *mapUnitToSliceGroupMap, uint *run_length_minus1, uint num_slice_groups_minus1, uint PicSizeInMapUnits);
-
-/**
-This function fills up an array that maps Map unit to the slice group
-following the dispersed slice group map type.
-\param "mapUnitToSliceGroupMap" "Array of slice group mapping."
-\param "PicWidthInMbs"  "Width of the luma picture in macroblock unit."
-\param "num_slice_groups_minus_1"   "Number of slice group minus 1."
-\param "PicSizeInMapUnit"   "Size of the picture in number Map units."
-\return "Void."
-*/
-void FmoGenerateType1MapUnitMap(int *mapUnitToSliceGroupMap, int PicWidthInMbs, uint num_slice_groups_minus1, uint PicSizeInMapUnits);
-
-/**
-This function fills up an array that maps Map unit to the slice group
-following the foreground with left-over slice group map type.
-\param "pps"    "Pointer to AVCPicParamSets structure."
-\param "mapUnitToSliceGroupMap" "Array of slice group mapping."
-\param "PicWidthInMbs"  "Width of the luma picture in macroblock unit."
-\param "num_slice_groups_minus_1"   "Number of slice group minus 1."
-\param "PicSizeInMapUnit"   "Size of the picture in number Map units."
-\return "Void."
-*/
-void FmoGenerateType2MapUnitMap(AVCPicParamSet *pps, int *mapUnitToSliceGroupMap, int PicWidthInMbs,
-                                uint num_slice_groups_minus1, uint PicSizeInMapUnits);
-
-/**
-This function fills up an array that maps Map unit to the slice group
-following the box-out slice group map type.
-\param "pps"    "Pointer to AVCPicParamSets structure."
-\param "mapUnitToSliceGroupMap" "Array of slice group mapping."
-\param "PicWidthInMbs"  "Width of the luma picture in macroblock unit."
-\return "Void."
-*/
-void FmoGenerateType3MapUnitMap(AVCCommonObj *video, AVCPicParamSet* pps, int *mapUnitToSliceGroupMap,
-                                int PicWidthInMbs);
-
-/**
-This function fills up an array that maps Map unit to the slice group
-following the raster scan slice group map type.
-\param "mapUnitToSliceGroupMap" "Array of slice group mapping."
-\param "MapUnitsInSliceGroup0"  "Derived in subclause 7.4.3."
-\param "slice_group_change_direction_flag"  "A value from the slice header."
-\param "PicSizeInMapUnit"   "Size of the picture in number Map units."
-\return "void"
-*/
-void FmoGenerateType4MapUnitMap(int *mapUnitToSliceGroupMap, int MapUnitsInSliceGroup0,
-                                int slice_group_change_direction_flag, uint PicSizeInMapUnits);
-
-/**
-This function fills up an array that maps Map unit to the slice group
-following wipe slice group map type.
-\param "mapUnitToSliceGroupMap" "Array of slice group mapping."
-\param "video"  "Pointer to AVCCommonObj structure."
-\param "slice_group_change_direction_flag"  "A value from the slice header."
-\param "PicSizeInMapUnit"   "Size of the picture in number Map units."
-\return "void"
-*/
-void FmoGenerateType5MapUnitMap(int *mapUnitsToSliceGroupMap, AVCCommonObj *video,
-                                int slice_group_change_direction_flag, uint PicSizeInMapUnits);
-
-/**
-This function fills up an array that maps Map unit to the slice group
-following wipe slice group map type.
-\param "mapUnitToSliceGroupMap" "Array of slice group mapping."
-\param "slice_group_id" "Array of slice_group_id from AVCPicParamSet structure."
-\param "PicSizeInMapUnit"   "Size of the picture in number Map units."
-\return "void"
-*/
-void FmoGenerateType6MapUnitMap(int *mapUnitsToSliceGroupMap, int *slice_group_id, uint PicSizeInMapUnits);
-
-/*------------- itrans.c --------------*/
-/**
-This function performs transformation of the Intra16x16DC value according to
-subclause 8.5.6.
-\param "block"  "Pointer to the video->block[0][0][0]."
-\param "QPy"    "Quantization parameter."
-\return "void."
-*/
-void Intra16DCTrans(int16 *block, int Qq, int Rq);
-
-/**
-This function performs transformation of a 4x4 block according to
-subclause 8.5.8.
-\param "block"  "Pointer to the origin of transform coefficient area."
-\param "pred"   "Pointer to the origin of predicted area."
-\param "cur"    "Pointer to the origin of the output area."
-\param "width"  "Pitch of cur."
-\return "void."
-*/
-void itrans(int16 *block, uint8 *pred, uint8 *cur, int width);
-
-/*
-This function is the same one as itrans except for chroma.
-\param "block"  "Pointer to the origin of transform coefficient area."
-\param "pred"   "Pointer to the origin of predicted area."
-\param "cur"    "Pointer to the origin of the output area."
-\param "width"  "Pitch of cur."
-\return "void."
-*/
-void ictrans(int16 *block, uint8 *pred, uint8 *cur, int width);
-
-/**
-This function performs transformation of the DCChroma value according to
-subclause 8.5.7.
-\param "block"  "Pointer to the video->block[0][0][0]."
-\param "QPc"    "Quantization parameter."
-\return "void."
-*/
-void ChromaDCTrans(int16 *block, int Qq, int Rq);
-
-/**
-This function copies a block from pred to cur.
-\param "pred"   "Pointer to prediction block."
-\param "cur"    "Pointer to the current YUV block."
-\param "width"  "Pitch of cur memory."
-\param "pred_pitch" "Pitch for pred memory.
-\return "void."
-*/
-void copy_block(uint8 *pred, uint8 *cur, int width, int pred_pitch);
-
-/*--------- mb_access.c ----------------*/
-/**
-This function initializes the neighboring information before start macroblock decoding.
-\param "video"  "Pointer to AVCCommonObj."
-\param "mbNum"  "The current macroblock index."
-\param "currMB" "Pointer to the current AVCMacroblock structure."
-\return "void"
-*/
-OSCL_IMPORT_REF void InitNeighborAvailability(AVCCommonObj *video, int mbNum);
-
-/**
-This function checks whether the requested neighboring macroblock is available.
-\param "MbToSliceGroupMap"  "Array containing the slice group ID mapping to MB index."
-\param "PicSizeInMbs"   "Size of the picture in number of MBs."
-\param "mbAddr"     "Neighboring macroblock index to check."
-\param "currMbAddr" "Current macroblock index."
-\return "TRUE if the neighboring MB is available, FALSE otherwise."
-*/
-bool mb_is_available(AVCMacroblock *mblock, uint PicSizeInMbs, int mbAddr, int currMbAddr);
-
-/**
-This function performs prediction of the nonzero coefficient for a luma block (i,j).
-\param "video"  "Pointer to AVCCommonObj."
-\param "i"  "Block index, horizontal."
-\param "j"  "Block index, vertical."
-\return "Predicted number of nonzero coefficient."
-*/
-OSCL_IMPORT_REF int predict_nnz(AVCCommonObj *video, int i, int j);
-
-/**
-This function performs prediction of the nonzero coefficient for a chroma block (i,j).
-\param "video"  "Pointer to AVCCommonObj."
-\param "i"  "Block index, horizontal."
-\param "j"  "Block index, vertical."
-\return "Predicted number of nonzero coefficient."
-*/
-OSCL_IMPORT_REF int predict_nnz_chroma(AVCCommonObj *video, int i, int j);
-
-/**
-This function calculates the predicted motion vectors for the current macroblock.
-\param "video" "Pointer to AVCCommonObj."
-\param "encFlag"    "Boolean whether this function is used by encoder or decoder."
-\return "void."
-*/
-OSCL_IMPORT_REF void GetMotionVectorPredictor(AVCCommonObj *video, int encFlag);
-
-/*---------- reflist.c -----------------*/
-/**
-This function initializes reference picture list used in INTER prediction
-at the beginning of each slice decoding. See subclause 8.2.4.
-\param "video"  "Pointer to AVCCommonObj."
-\return "void"
-Output is video->RefPicList0, video->RefPicList1, video->refList0Size and video->refList1Size.
-*/
-OSCL_IMPORT_REF void RefListInit(AVCCommonObj *video);
-
-/**
-This function generates picture list from frame list. Used when current picture is field.
-see subclause 8.2.4.2.5.
-\param "video"  "Pointer to AVCCommonObj."
-\param "IsL1"   "Is L1 list?"
-\param "long_term"  "Is long-term prediction?"
-\return "void"
-*/
-void    GenPicListFromFrameList(AVCCommonObj *video, int IsL1, int long_term);
-
-/**
-This function performs reference picture list reordering according to the
-ref_pic_list_reordering() syntax. See subclause 8.2.4.3.
-\param "video"  "Pointer to AVCCommonObj."
-\return "AVC_SUCCESS or AVC_FAIL"
-Output is video->RefPicList0, video->RefPicList1, video->refList0Size and video->refList1Size.
-*/
-OSCL_IMPORT_REF AVCStatus ReOrderList(AVCCommonObj *video);
-
-/**
-This function performs reference picture list reordering according to the
-ref_pic_list_reordering() syntax regardless of list 0 or list 1. See subclause 8.2.4.3.
-\param "video"  "Pointer to AVCCommonObj."
-\param "isL1"   "Is list 1 or not."
-\return "AVC_SUCCESS or AVC_FAIL"
-Output is video->RefPicList0 and video->refList0Size or video->RefPicList1 and video->refList1Size.
-*/
-AVCStatus ReorderRefPicList(AVCCommonObj *video, int isL1);
-
-/**
-This function performs reordering process of reference picture list for short-term pictures.
-See subclause 8.2.4.3.1.
-\param "video"  "Pointer to AVCCommonObj."
-\param "picNumLX"   "picNumLX of an entry in the reference list."
-\param "refIdxLX"   "Pointer to the current entry index in the reference."
-\param "isL1"       "Is list 1 or not."
-\return "AVC_SUCCESS or AVC_FAIL"
-*/
-AVCStatus ReorderShortTerm(AVCCommonObj *video, int picNumLX, int *refIdxLX, int isL1);
-
-/**
-This function performs reordering process of reference picture list for long-term pictures.
-See subclause 8.2.4.3.2.
-\param "video"  "Pointer to AVCCommonObj."
-\param "LongTermPicNum" "LongTermPicNum of an entry in the reference list."
-\param "refIdxLX"   "Pointer to the current entry index in the reference."
-\param "isL1"       "Is list 1 or not."
-\return "AVC_SUCCESS or AVC_FAIL"
-*/
-AVCStatus ReorderLongTerm(AVCCommonObj *video, int LongTermPicNum, int *refIdxLX, int isL1);
-
-/**
-This function gets the pictures in DPB according to the PicNum.
-\param "video"  "Pointer to AVCCommonObj."
-\param "picNum" "PicNum of the picture we are looking for."
-\return "Pointer to the AVCPictureData or NULL if not found"
-*/
-AVCPictureData*  GetShortTermPic(AVCCommonObj *video, int picNum);
-
-/**
-This function gets the pictures in DPB according to the LongtermPicNum.
-\param "video"  "Pointer to AVCCommonObj."
-\param "LongtermPicNum" "LongtermPicNum of the picture we are looking for."
-\return "Pointer to the AVCPictureData."
-*/
-AVCPictureData*  GetLongTermPic(AVCCommonObj *video, int LongtermPicNum);
-
-/**
-This function indicates whether the picture is used for short-term reference or not.
-\param "s"  "Pointer to AVCPictureData."
-\return "1 if it is used for short-term, 0 otherwise."
-*/
-int is_short_ref(AVCPictureData *s);
-
-/**
-This function indicates whether the picture is used for long-term reference or not.
-\param "s"  "Pointer to AVCPictureData."
-\return "1 if it is used for long-term, 0 otherwise."
-*/
-int is_long_ref(AVCPictureData *s);
-
-/**
-This function sorts array of pointers to AVCPictureData in descending order of
-the PicNum value.
-\param "data"   "Array of pointers to AVCPictureData."
-\param "num"    "Size of the array."
-\return "void"
-*/
-void SortPicByPicNum(AVCPictureData *data[], int num);
-
-/**
-This function sorts array of pointers to AVCPictureData in ascending order of
-the PicNum value.
-\param "data"   "Array of pointers to AVCPictureData."
-\param "num"    "Size of the array."
-\return "void"
-*/
-void SortPicByPicNumLongTerm(AVCPictureData *data[], int num);
-
-/**
-This function sorts array of pointers to AVCFrameStore in descending order of
-the FrameNumWrap value.
-\param "data"   "Array of pointers to AVCFrameStore."
-\param "num"    "Size of the array."
-\return "void"
-*/
-void SortFrameByFrameNumWrap(AVCFrameStore *data[], int num);
-
-/**
-This function sorts array of pointers to AVCFrameStore in ascending order of
-the LongTermFrameIdx value.
-\param "data"   "Array of pointers to AVCFrameStore."
-\param "num"    "Size of the array."
-\return "void"
-*/
-void SortFrameByLTFrameIdx(AVCFrameStore *data[], int num);
-
-/**
-This function sorts array of pointers to AVCPictureData in descending order of
-the PicOrderCnt value.
-\param "data"   "Array of pointers to AVCPictureData."
-\param "num"    "Size of the array."
-\return "void"
-*/
-void SortPicByPOC(AVCPictureData *data[], int num, int descending);
-
-/**
-This function sorts array of pointers to AVCPictureData in ascending order of
-the LongTermPicNum value.
-\param "data"   "Array of pointers to AVCPictureData."
-\param "num"    "Size of the array."
-\return "void"
-*/
-void SortPicByLTPicNum(AVCPictureData *data[], int num);
-
-/**
-This function sorts array of pointers to AVCFrameStore in descending order of
-the PicOrderCnt value.
-\param "data"   "Array of pointers to AVCFrameStore."
-\param "num"    "Size of the array."
-\return "void"
-*/
-void SortFrameByPOC(AVCFrameStore *data[], int num, int descending);
-
-
-#endif /* _AVCCOMMON_LIB_H_ */
diff --git a/media/libstagefright/codecs/avc/common/src/deblock.cpp b/media/libstagefright/codecs/avc/common/src/deblock.cpp
deleted file mode 100644
index 5f8b693..0000000
--- a/media/libstagefright/codecs/avc/common/src/deblock.cpp
+++ /dev/null
@@ -1,1667 +0,0 @@
-/* ------------------------------------------------------------------
- * 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 <string.h>
-
-#include "avclib_common.h"
-
-#define MAX_QP 51
-#define MB_BLOCK_SIZE 16
-
-// NOTE: these 3 tables are for funtion GetStrength() only
-const static int ININT_STRENGTH[4] = {0x04040404, 0x03030303, 0x03030303, 0x03030303};
-
-
-// NOTE: these 3 tables are for funtion EdgeLoop() only
-// NOTE: to change the tables below for instance when the QP doubling is changed from 6 to 8 values
-
-const static int ALPHA_TABLE[52]  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 5, 6,  7, 8, 9, 10, 12, 13, 15, 17,  20, 22, 25, 28, 32, 36, 40, 45,  50, 56, 63, 71, 80, 90, 101, 113,  127, 144, 162, 182, 203, 226, 255, 255} ;
-const static int BETA_TABLE[52]   = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 3,  3, 3, 3, 4, 4, 4, 6, 6,   7, 7, 8, 8, 9, 9, 10, 10,  11, 11, 12, 12, 13, 13, 14, 14,   15, 15, 16, 16, 17, 17, 18, 18} ;
-const static int CLIP_TAB[52][5]  =
-{
-    { 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, 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, 1, 1}, { 0, 0, 0, 1, 1}, { 0, 0, 0, 1, 1}, { 0, 0, 0, 1, 1}, { 0, 0, 1, 1, 1}, { 0, 0, 1, 1, 1}, { 0, 1, 1, 1, 1},
-    { 0, 1, 1, 1, 1}, { 0, 1, 1, 1, 1}, { 0, 1, 1, 1, 1}, { 0, 1, 1, 2, 2}, { 0, 1, 1, 2, 2}, { 0, 1, 1, 2, 2}, { 0, 1, 1, 2, 2}, { 0, 1, 2, 3, 3},
-    { 0, 1, 2, 3, 3}, { 0, 2, 2, 3, 3}, { 0, 2, 2, 4, 4}, { 0, 2, 3, 4, 4}, { 0, 2, 3, 4, 4}, { 0, 3, 3, 5, 5}, { 0, 3, 4, 6, 6}, { 0, 3, 4, 6, 6},
-    { 0, 4, 5, 7, 7}, { 0, 4, 5, 8, 8}, { 0, 4, 6, 9, 9}, { 0, 5, 7, 10, 10}, { 0, 6, 8, 11, 11}, { 0, 6, 8, 13, 13}, { 0, 7, 10, 14, 14}, { 0, 8, 11, 16, 16},
-    { 0, 9, 12, 18, 18}, { 0, 10, 13, 20, 20}, { 0, 11, 15, 23, 23}, { 0, 13, 17, 25, 25}
-};
-
-// NOTE: this table is only QP clipping, index = QP + video->FilterOffsetA/B, clipped to [0, 51]
-//       video->FilterOffsetA/B is in {-12, 12]
-const static int QP_CLIP_TAB[76] =
-{
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,              // [-12, 0]
-    1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
-    13, 14, 15, 16, 17, 18, 19, 20, 21,
-    22, 23, 24, 25, 26, 27, 28, 29, 30,
-    31, 32, 33, 34, 35, 36, 37, 38, 39,
-    40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, // [1, 51]
-    51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51      // [52,63]
-};
-
-static void DeblockMb(AVCCommonObj *video, int mb_x, int mb_y, uint8 *SrcY, uint8 *SrcU, uint8 *SrcV);
-//static void GetStrength(AVCCommonObj *video, uint8 *Strength, AVCMacroblock* MbP, AVCMacroblock* MbQ, int dir, int edge);
-static void GetStrength_Edge0(uint8 *Strength, AVCMacroblock* MbP, AVCMacroblock* MbQ, int dir);
-static void GetStrength_VerticalEdges(uint8 *Strength, AVCMacroblock* MbQ);
-static void GetStrength_HorizontalEdges(uint8 Strength[12], AVCMacroblock* MbQ);
-static void EdgeLoop_Luma_vertical(uint8* SrcPtr, uint8 *Strength, int Alpha, int Beta, int *clipTable, int pitch);
-static void EdgeLoop_Luma_horizontal(uint8* SrcPtr, uint8 *Strength, int Alpha, int Beta, int *clipTable, int pitch);
-static void EdgeLoop_Chroma_vertical(uint8* SrcPtr, uint8 *Strength, int Alpha, int Beta, int *clipTable, int pitch);
-static void EdgeLoop_Chroma_horizontal(uint8* SrcPtr, uint8 *Strength, int Alpha, int Beta, int *clipTable, int pitch);
-
-/*
- *****************************************************************************************
- * \brief Filter all macroblocks in order of increasing macroblock address.
- *****************************************************************************************
-*/
-
-OSCL_EXPORT_REF AVCStatus DeblockPicture(AVCCommonObj *video)
-{
-    uint   i, j;
-    int   pitch = video->currPic->pitch, pitch_c, width;
-    uint8 *SrcY, *SrcU, *SrcV;
-
-    SrcY = video->currPic->Sl;      // pointers to source
-    SrcU = video->currPic->Scb;
-    SrcV = video->currPic->Scr;
-    pitch_c = pitch >> 1;
-    width = video->currPic->width;
-
-    for (i = 0; i < video->PicHeightInMbs; i++)
-    {
-        for (j = 0; j < video->PicWidthInMbs; j++)
-        {
-            DeblockMb(video, j, i, SrcY, SrcU, SrcV);
-            // update SrcY, SrcU, SrcV
-            SrcY += MB_BLOCK_SIZE;
-            SrcU += (MB_BLOCK_SIZE >> 1);
-            SrcV += (MB_BLOCK_SIZE >> 1);
-        }
-
-        SrcY += ((pitch << 4) - width);
-        SrcU += ((pitch_c << 3) - (width >> 1));
-        SrcV += ((pitch_c << 3) - (width >> 1));
-    }
-
-    return AVC_SUCCESS;
-}
-
-#ifdef MB_BASED_DEBLOCK
-/*
- *****************************************************************************************
- * \brief Filter one macroblocks in a fast macroblock memory and copy it to frame
- *****************************************************************************************
-*/
-void MBInLoopDeblock(AVCCommonObj *video)
-{
-    AVCPictureData *currPic = video->currPic;
-#ifdef USE_PRED_BLOCK
-    uint8 *predCb, *predCr, *pred_block;
-    int i, j, dst_width, dst_height, dst_widthc, dst_heightc;
-#endif
-    int pitch = currPic->pitch;
-    int x_pos = video->mb_x;
-    int y_pos = video->mb_y;
-    uint8 *curL, *curCb, *curCr;
-    int offset;
-
-    offset = (y_pos << 4) * pitch;
-
-    curL = currPic->Sl + offset + (x_pos << 4);
-
-    offset >>= 2;
-    offset += (x_pos << 3);
-
-    curCb = currPic->Scb + offset;
-    curCr = currPic->Scr + offset;
-
-#ifdef USE_PRED_BLOCK
-    pred_block = video->pred;
-
-    /* 1. copy neighboring pixels from frame to the video->pred_block */
-    if (y_pos) /* not the 0th row */
-    {
-        /* copy to the top 4 lines of the macroblock */
-        curL -= (pitch << 2); /* go back 4 lines */
-
-        memcpy(pred_block + 4, curL, 16);
-        curL += pitch;
-        memcpy(pred_block + 24, curL, 16);
-        curL += pitch;
-        memcpy(pred_block + 44, curL, 16);
-        curL += pitch;
-        memcpy(pred_block + 64, curL, 16);
-        curL += pitch;
-
-        curCb -= (pitch << 1); /* go back 4 lines chroma */
-        curCr -= (pitch << 1);
-
-        pred_block += 400;
-
-        memcpy(pred_block + 4, curCb, 8);
-        curCb += (pitch >> 1);
-        memcpy(pred_block + 16, curCb, 8);
-        curCb += (pitch >> 1);
-        memcpy(pred_block + 28, curCb, 8);
-        curCb += (pitch >> 1);
-        memcpy(pred_block + 40, curCb, 8);
-        curCb += (pitch >> 1);
-
-        pred_block += 144;
-        memcpy(pred_block + 4, curCr, 8);
-        curCr += (pitch >> 1);
-        memcpy(pred_block + 16, curCr, 8);
-        curCr += (pitch >> 1);
-        memcpy(pred_block + 28, curCr, 8);
-        curCr += (pitch >> 1);
-        memcpy(pred_block + 40, curCr, 8);
-        curCr += (pitch >> 1);
-
-        pred_block = video->pred;
-    }
-
-    /* 2. perform deblocking. */
-    DeblockMb(video, x_pos, y_pos, pred_block + 84, pred_block + 452, pred_block + 596);
-
-    /* 3. copy it back to the frame and update pred_block */
-    predCb = pred_block + 400;
-    predCr = predCb + 144;
-
-    /* find the range of the block inside pred_block to be copied back */
-    if (y_pos)  /* the first row */
-    {
-        curL -= (pitch << 2);
-        curCb -= (pitch << 1);
-        curCr -= (pitch << 1);
-
-        dst_height = 20;
-        dst_heightc = 12;
-    }
-    else
-    {
-        pred_block += 80;
-        predCb += 48;
-        predCr += 48;
-        dst_height = 16;
-        dst_heightc = 8;
-    }
-
-    if (x_pos) /* find the width */
-    {
-        curL -= 4;
-        curCb -= 4;
-        curCr -= 4;
-        if (x_pos == (int)(video->PicWidthInMbs - 1))
-        {
-            dst_width = 20;
-            dst_widthc = 12;
-        }
-        else
-        {
-            dst_width = 16;
-            dst_widthc = 8;
-        }
-    }
-    else
-    {
-        pred_block += 4;
-        predCb += 4;
-        predCr += 4;
-        dst_width = 12;
-        dst_widthc = 4;
-    }
-
-    /* perform copy */
-    for (j = 0; j < dst_height; j++)
-    {
-        memcpy(curL, pred_block, dst_width);
-        curL += pitch;
-        pred_block += 20;
-    }
-    for (j = 0; j < dst_heightc; j++)
-    {
-        memcpy(curCb, predCb, dst_widthc);
-        memcpy(curCr, predCr, dst_widthc);
-        curCb += (pitch >> 1);
-        curCr += (pitch >> 1);
-        predCb += 12;
-        predCr += 12;
-    }
-
-    if (x_pos != (int)(video->PicWidthInMbs - 1)) /* now copy from the right-most 4 columns to the left-most 4 columns */
-    {
-        pred_block = video->pred;
-        for (i = 0; i < 20; i += 4)
-        {
-            *((uint32*)pred_block) = *((uint32*)(pred_block + 16));
-            pred_block += 20;
-            *((uint32*)pred_block) = *((uint32*)(pred_block + 16));
-            pred_block += 20;
-            *((uint32*)pred_block) = *((uint32*)(pred_block + 16));
-            pred_block += 20;
-            *((uint32*)pred_block) = *((uint32*)(pred_block + 16));
-            pred_block += 20;
-        }
-
-        for (i = 0; i < 24; i += 4)
-        {
-            *((uint32*)pred_block) = *((uint32*)(pred_block + 8));
-            pred_block += 12;
-            *((uint32*)pred_block) = *((uint32*)(pred_block + 8));
-            pred_block += 12;
-            *((uint32*)pred_block) = *((uint32*)(pred_block + 8));
-            pred_block += 12;
-            *((uint32*)pred_block) = *((uint32*)(pred_block + 8));
-            pred_block += 12;
-        }
-
-    }
-#else
-    DeblockMb(video, x_pos, y_pos, curL, curCb, curCr);
-#endif
-
-    return ;
-}
-#endif
-
-/*
- *****************************************************************************************
- * \brief Deblocking filter for one macroblock.
- *****************************************************************************************
- */
-
-void DeblockMb(AVCCommonObj *video, int mb_x, int mb_y, uint8 *SrcY, uint8 *SrcU, uint8 *SrcV)
-{
-    AVCMacroblock *MbP, *MbQ;
-    int     edge, QP, QPC;
-    int     filterLeftMbEdgeFlag = (mb_x != 0);
-    int     filterTopMbEdgeFlag  = (mb_y != 0);
-    int     pitch = video->currPic->pitch;
-    int     indexA, indexB;
-    int     *tmp;
-    int     Alpha, Beta, Alpha_c, Beta_c;
-    int     mbNum = mb_y * video->PicWidthInMbs + mb_x;
-    int     *clipTable, *clipTable_c, *qp_clip_tab;
-    uint8   Strength[16];
-    void*     str;
-
-    MbQ = &(video->mblock[mbNum]);      // current Mb
-
-
-    // If filter is disabled, return
-    if (video->sliceHdr->disable_deblocking_filter_idc == 1) return;
-
-    if (video->sliceHdr->disable_deblocking_filter_idc == 2)
-    {
-        // don't filter at slice boundaries
-        filterLeftMbEdgeFlag = mb_is_available(video->mblock, video->PicSizeInMbs, mbNum - 1, mbNum);
-        filterTopMbEdgeFlag  = mb_is_available(video->mblock, video->PicSizeInMbs, mbNum - video->PicWidthInMbs, mbNum);
-    }
-
-    /* NOTE: edge=0 and edge=1~3 are separate cases because of the difference of MbP, index A and indexB calculation */
-    /*       for edge = 1~3, MbP, indexA and indexB remain the same, and thus there is no need to re-calculate them for each edge */
-
-    qp_clip_tab = (int *)QP_CLIP_TAB + 12;
-
-    /* 1.VERTICAL EDGE + MB BOUNDARY (edge = 0) */
-    if (filterLeftMbEdgeFlag)
-    {
-        MbP = MbQ - 1;
-        //GetStrength(video, Strength, MbP, MbQ, 0, 0); // Strength for 4 blks in 1 stripe, 0 => vertical edge
-        GetStrength_Edge0(Strength, MbP, MbQ, 0);
-
-        str = (void*)Strength; //de-ref type-punned pointer fix
-        if (*((uint32*)str))    // only if one of the 4 Strength bytes is != 0
-        {
-            QP = (MbP->QPy + MbQ->QPy + 1) >> 1; // Average QP of the two blocks;
-            indexA = QP + video->FilterOffsetA;
-            indexB = QP + video->FilterOffsetB;
-            indexA = qp_clip_tab[indexA]; // IClip(0, MAX_QP, QP+video->FilterOffsetA)
-            indexB = qp_clip_tab[indexB]; // IClip(0, MAX_QP, QP+video->FilterOffsetB)
-
-            Alpha  = ALPHA_TABLE[indexA];
-            Beta = BETA_TABLE[indexB];
-            clipTable = (int *) CLIP_TAB[indexA];
-
-            if (Alpha > 0 && Beta > 0)
-#ifdef USE_PRED_BLOCK
-                EdgeLoop_Luma_vertical(SrcY, Strength,  Alpha, Beta, clipTable, 20);
-#else
-                EdgeLoop_Luma_vertical(SrcY, Strength,  Alpha, Beta, clipTable, pitch);
-#endif
-
-            QPC = (MbP->QPc + MbQ->QPc + 1) >> 1;
-            indexA = QPC + video->FilterOffsetA;
-            indexB = QPC + video->FilterOffsetB;
-            indexA = qp_clip_tab[indexA]; // IClip(0, MAX_QP, QP+video->FilterOffsetA)
-            indexB = qp_clip_tab[indexB]; // IClip(0, MAX_QP, QP+video->FilterOffsetB)
-
-            Alpha  = ALPHA_TABLE[indexA];
-            Beta = BETA_TABLE[indexB];
-            clipTable = (int *) CLIP_TAB[indexA];
-            if (Alpha > 0 && Beta > 0)
-            {
-#ifdef USE_PRED_BLOCK
-                EdgeLoop_Chroma_vertical(SrcU, Strength, Alpha, Beta, clipTable, 12);
-                EdgeLoop_Chroma_vertical(SrcV, Strength, Alpha, Beta, clipTable, 12);
-#else
-                EdgeLoop_Chroma_vertical(SrcU, Strength, Alpha, Beta, clipTable, pitch >> 1);
-                EdgeLoop_Chroma_vertical(SrcV, Strength, Alpha, Beta, clipTable, pitch >> 1);
-#endif
-            }
-        }
-
-    } /* end of: if(filterLeftMbEdgeFlag) */
-
-    /* 2.VERTICAL EDGE (no boundary), the edges are all inside a MB */
-    /* First calculate the necesary parameters all at once, outside the loop */
-    MbP = MbQ;
-
-    indexA = MbQ->QPy + video->FilterOffsetA;
-    indexB = MbQ->QPy + video->FilterOffsetB;
-    //  index
-    indexA = qp_clip_tab[indexA]; // IClip(0, MAX_QP, QP+video->FilterOffsetA)
-    indexB = qp_clip_tab[indexB]; // IClip(0, MAX_QP, QP+video->FilterOffsetB)
-
-    Alpha = ALPHA_TABLE[indexA];
-    Beta = BETA_TABLE[indexB];
-    clipTable = (int *)CLIP_TAB[indexA];
-
-    /* Save Alpha,  Beta and clipTable for future use, with the obselete variables filterLeftMbEdgeFlag, mbNum amd tmp */
-    filterLeftMbEdgeFlag = Alpha;
-    mbNum = Beta;
-    tmp = clipTable;
-
-    indexA = MbQ->QPc + video->FilterOffsetA;
-    indexB = MbQ->QPc + video->FilterOffsetB;
-    indexA = qp_clip_tab[indexA]; // IClip(0, MAX_QP, QP+video->FilterOffsetA)
-    indexB = qp_clip_tab[indexB]; // IClip(0, MAX_QP, QP+video->FilterOffsetB)
-
-    Alpha_c  = ALPHA_TABLE[indexA];
-    Beta_c = BETA_TABLE[indexB];
-    clipTable_c = (int *)CLIP_TAB[indexA];
-
-    GetStrength_VerticalEdges(Strength + 4, MbQ); // Strength for 4 blks in 1 stripe, 0 => vertical edge
-
-    for (edge = 1; edge < 4; edge++)  // 4 vertical strips of 16 pel
-    {
-        //GetStrength_VerticalEdges(video, Strength, MbP, MbQ, 0, edge); // Strength for 4 blks in 1 stripe, 0 => vertical edge
-        if (*((int*)(Strength + (edge << 2))))   // only if one of the 4 Strength bytes is != 0
-        {
-            if (Alpha > 0 && Beta > 0)
-#ifdef USE_PRED_BLOCK
-                EdgeLoop_Luma_vertical(SrcY + (edge << 2), Strength + (edge << 2),  Alpha, Beta, clipTable, 20);
-#else
-                EdgeLoop_Luma_vertical(SrcY + (edge << 2), Strength + (edge << 2),  Alpha, Beta, clipTable, pitch);
-#endif
-
-            if (!(edge & 1) && Alpha_c > 0 && Beta_c > 0)
-            {
-#ifdef USE_PRED_BLOCK
-                EdgeLoop_Chroma_vertical(SrcU + (edge << 1), Strength + (edge << 2), Alpha_c, Beta_c, clipTable_c, 12);
-                EdgeLoop_Chroma_vertical(SrcV + (edge << 1), Strength + (edge << 2), Alpha_c, Beta_c, clipTable_c, 12);
-#else
-                EdgeLoop_Chroma_vertical(SrcU + (edge << 1), Strength + (edge << 2), Alpha_c, Beta_c, clipTable_c, pitch >> 1);
-                EdgeLoop_Chroma_vertical(SrcV + (edge << 1), Strength + (edge << 2), Alpha_c, Beta_c, clipTable_c, pitch >> 1);
-#endif
-            }
-        }
-
-    } //end edge
-
-
-
-    /* 3.HORIZONTAL EDGE + MB BOUNDARY (edge = 0) */
-    if (filterTopMbEdgeFlag)
-    {
-        MbP = MbQ - video->PicWidthInMbs;
-        //GetStrength(video, Strength, MbP, MbQ, 1, 0); // Strength for 4 blks in 1 stripe, 0 => vertical edge
-        GetStrength_Edge0(Strength, MbP, MbQ, 1);
-        str = (void*)Strength; //de-ref type-punned pointer fix
-        if (*((uint32*)str))    // only if one of the 4 Strength bytes is != 0
-        {
-            QP = (MbP->QPy + MbQ->QPy + 1) >> 1; // Average QP of the two blocks;
-            indexA = QP + video->FilterOffsetA;
-            indexB = QP + video->FilterOffsetB;
-            indexA = qp_clip_tab[indexA]; // IClip(0, MAX_QP, QP+video->FilterOffsetA)
-            indexB = qp_clip_tab[indexB]; // IClip(0, MAX_QP, QP+video->FilterOffsetB)
-
-            Alpha  = ALPHA_TABLE[indexA];
-            Beta = BETA_TABLE[indexB];
-            clipTable = (int *)CLIP_TAB[indexA];
-
-            if (Alpha > 0 && Beta > 0)
-            {
-#ifdef USE_PRED_BLOCK
-                EdgeLoop_Luma_horizontal(SrcY, Strength,  Alpha, Beta, clipTable, 20);
-#else
-                EdgeLoop_Luma_horizontal(SrcY, Strength,  Alpha, Beta, clipTable, pitch);
-#endif
-            }
-
-            QPC = (MbP->QPc + MbQ->QPc + 1) >> 1;
-            indexA = QPC + video->FilterOffsetA;
-            indexB = QPC + video->FilterOffsetB;
-            indexA = qp_clip_tab[indexA]; // IClip(0, MAX_QP, QP+video->FilterOffsetA)
-            indexB = qp_clip_tab[indexB]; // IClip(0, MAX_QP, QP+video->FilterOffsetB)
-
-            Alpha  = ALPHA_TABLE[indexA];
-            Beta = BETA_TABLE[indexB];
-            clipTable = (int *)CLIP_TAB[indexA];
-            if (Alpha > 0 && Beta > 0)
-            {
-#ifdef USE_PRED_BLOCK
-                EdgeLoop_Chroma_horizontal(SrcU, Strength, Alpha, Beta, clipTable, 12);
-                EdgeLoop_Chroma_horizontal(SrcV, Strength, Alpha, Beta, clipTable, 12);
-#else
-                EdgeLoop_Chroma_horizontal(SrcU, Strength, Alpha, Beta, clipTable, pitch >> 1);
-                EdgeLoop_Chroma_horizontal(SrcV, Strength, Alpha, Beta, clipTable, pitch >> 1);
-#endif
-            }
-        }
-
-    } /* end of: if(filterTopMbEdgeFlag) */
-
-
-    /* 4.HORIZONTAL EDGE (no boundary), the edges are inside a MB */
-    MbP = MbQ;
-
-    /* Recover Alpha,  Beta and clipTable for edge!=0 with the variables filterLeftMbEdgeFlag, mbNum and tmp */
-    /* Note that Alpha_c, Beta_c and clipTable_c for chroma is already calculated */
-    Alpha = filterLeftMbEdgeFlag;
-    Beta = mbNum;
-    clipTable = tmp;
-
-    GetStrength_HorizontalEdges(Strength + 4, MbQ); // Strength for 4 blks in 1 stripe, 0 => vertical edge
-
-    for (edge = 1; edge < 4; edge++)  // 4 horicontal strips of 16 pel
-    {
-        //GetStrength(video, Strength, MbP, MbQ, 1, edge); // Strength for 4 blks in 1 stripe   1 => horizontal edge
-        if (*((int*)(Strength + (edge << 2)))) // only if one of the 4 Strength bytes is != 0
-        {
-            if (Alpha > 0 && Beta > 0)
-            {
-#ifdef USE_PRED_BLOCK
-                EdgeLoop_Luma_horizontal(SrcY + (edge << 2)*20, Strength + (edge << 2),  Alpha, Beta, clipTable, 20);
-#else
-                EdgeLoop_Luma_horizontal(SrcY + (edge << 2)*pitch, Strength + (edge << 2),  Alpha, Beta, clipTable, pitch);
-#endif
-            }
-
-            if (!(edge & 1) && Alpha_c > 0 && Beta_c > 0)
-            {
-#ifdef USE_PRED_BLOCK
-                EdgeLoop_Chroma_horizontal(SrcU + (edge << 1)*12, Strength + (edge << 2), Alpha_c, Beta_c, clipTable_c, 12);
-                EdgeLoop_Chroma_horizontal(SrcV + (edge << 1)*12, Strength + (edge << 2), Alpha_c, Beta_c, clipTable_c, 12);
-#else
-                EdgeLoop_Chroma_horizontal(SrcU + (edge << 1)*(pitch >> 1), Strength + (edge << 2), Alpha_c, Beta_c, clipTable_c, pitch >> 1);
-                EdgeLoop_Chroma_horizontal(SrcV + (edge << 1)*(pitch >> 1), Strength + (edge << 2), Alpha_c, Beta_c, clipTable_c, pitch >> 1);
-#endif
-            }
-        }
-
-    } //end edge
-
-    return;
-}
-
-/*
- *****************************************************************************************************
- * \brief   returns a buffer of 4 Strength values for one stripe in a mb (for different Frame types)
- *****************************************************************************************************
-*/
-
-void GetStrength_Edge0(uint8 *Strength, AVCMacroblock* MbP, AVCMacroblock* MbQ, int dir)
-{
-    int tmp;
-    int16 *ptrQ, *ptrP;
-    void* vptr;
-    uint8 *pStrength;
-    void* refIdx;
-
-    if (MbP->mbMode == AVC_I4 || MbP->mbMode == AVC_I16 ||
-            MbQ->mbMode == AVC_I4 || MbQ->mbMode == AVC_I16)
-    {
-
-        *((int*)Strength) = ININT_STRENGTH[0];      // Start with Strength=3. or Strength=4 for Mb-edge
-
-    }
-    else // if not intra or SP-frame
-    {
-        *((int*)Strength) = 0;
-
-        if (dir == 0)  // Vertical Edge 0
-        {
-
-            //1. Check the ref_frame_id
-            refIdx = (void*) MbQ->RefIdx; //de-ref type-punned pointer fix
-            ptrQ = (int16*)refIdx;
-            refIdx = (void*)MbP->RefIdx; //de-ref type-punned pointer fix
-            ptrP = (int16*)refIdx;
-            pStrength = Strength;
-            if (ptrQ[0] != ptrP[1]) pStrength[0] = 1;
-            if (ptrQ[2] != ptrP[3]) pStrength[2] = 1;
-            pStrength[1] = pStrength[0];
-            pStrength[3] = pStrength[2];
-
-            //2. Check the non-zero coeff blocks (4x4)
-            if (MbQ->nz_coeff[0] != 0 || MbP->nz_coeff[3] != 0) pStrength[0] = 2;
-            if (MbQ->nz_coeff[4] != 0 || MbP->nz_coeff[7] != 0) pStrength[1] = 2;
-            if (MbQ->nz_coeff[8] != 0 || MbP->nz_coeff[11] != 0) pStrength[2] = 2;
-            if (MbQ->nz_coeff[12] != 0 || MbP->nz_coeff[15] != 0) pStrength[3] = 2;
-
-            //3. Only need to check the mv difference
-            vptr = (void*)MbQ->mvL0;  // for deref type-punned pointer
-            ptrQ = (int16*)vptr;
-            ptrP = (int16*)(MbP->mvL0 + 3); // points to 4x4 block #3 (the 4th column)
-
-            // 1st blk
-            if (*pStrength == 0)
-            {
-                // check |mv difference| >= 4
-                tmp = *ptrQ++ - *ptrP++;
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStrength = 1;
-
-                tmp = *ptrQ-- - *ptrP--;
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStrength = 1;
-            }
-
-            pStrength++;
-            ptrQ += 8;
-            ptrP += 8;
-
-            // 2nd blk
-            if (*pStrength == 0)
-            {
-                // check |mv difference| >= 4
-                tmp = *ptrQ++ - *ptrP++;
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStrength = 1;
-
-                tmp = *ptrQ-- - *ptrP--;
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStrength = 1;
-            }
-
-            pStrength++;
-            ptrQ += 8;
-            ptrP += 8;
-
-            // 3rd blk
-            if (*pStrength == 0)
-            {
-                // check |mv difference| >= 4
-                tmp = *ptrQ++ - *ptrP++;
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStrength = 1;
-
-                tmp = *ptrQ-- - *ptrP--;
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStrength = 1;
-            }
-
-            pStrength++;
-            ptrQ += 8;
-            ptrP += 8;
-
-            // 4th blk
-            if (*pStrength == 0)
-            {
-                // check |mv difference| >= 4
-                tmp = *ptrQ++ - *ptrP++;
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStrength = 1;
-
-                tmp = *ptrQ-- - *ptrP--;
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStrength = 1;
-            }
-        }
-        else   // Horizontal Edge 0
-        {
-
-            //1. Check the ref_frame_id
-            refIdx = (void*)MbQ->RefIdx;  //de-ref type-punned pointer
-            ptrQ = (int16*)refIdx;
-            refIdx = (void*)MbP->RefIdx;  //de-ref type-punned pointer
-            ptrP = (int16*)refIdx;
-            pStrength = Strength;
-            if (ptrQ[0] != ptrP[2]) pStrength[0] = 1;
-            if (ptrQ[1] != ptrP[3]) pStrength[2] = 1;
-            pStrength[1] = pStrength[0];
-            pStrength[3] = pStrength[2];
-
-            //2. Check the non-zero coeff blocks (4x4)
-            if (MbQ->nz_coeff[0] != 0 || MbP->nz_coeff[12] != 0) pStrength[0] = 2;
-            if (MbQ->nz_coeff[1] != 0 || MbP->nz_coeff[13] != 0) pStrength[1] = 2;
-            if (MbQ->nz_coeff[2] != 0 || MbP->nz_coeff[14] != 0) pStrength[2] = 2;
-            if (MbQ->nz_coeff[3] != 0 || MbP->nz_coeff[15] != 0) pStrength[3] = 2;
-
-            //3. Only need to check the mv difference
-            vptr = (void*)MbQ->mvL0;
-            ptrQ = (int16*)vptr;
-            ptrP = (int16*)(MbP->mvL0 + 12); // points to 4x4 block #12 (the 4th row)
-
-            // 1st blk
-            if (*pStrength == 0)
-            {
-                // check |mv difference| >= 4
-                tmp = *ptrQ++ - *ptrP++;
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStrength = 1;
-
-                tmp = *ptrQ-- - *ptrP--;
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStrength = 1;
-            }
-
-            pStrength++;
-            ptrQ += 2;
-            ptrP += 2;
-
-            // 2nd blk
-            if (*pStrength  == 0)
-            {
-                // check |mv difference| >= 4
-                tmp = *ptrQ++ - *ptrP++;
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStrength = 1;
-
-                tmp = *ptrQ-- - *ptrP--;
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStrength = 1;
-            }
-
-            pStrength++;
-            ptrQ += 2;
-            ptrP += 2;
-
-            // 3rd blk
-            if (*pStrength  == 0)
-            {
-                // check |mv difference| >= 4
-                tmp = *ptrQ++ - *ptrP++;
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStrength = 1;
-
-                tmp = *ptrQ-- - *ptrP--;
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStrength = 1;
-            }
-
-            pStrength++;
-            ptrQ += 2;
-            ptrP += 2;
-
-            // 4th blk
-            if (*pStrength  == 0)
-            {
-                // check |mv difference| >= 4
-                tmp = *ptrQ++ - *ptrP++;
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStrength = 1;
-
-                tmp = *ptrQ-- - *ptrP--;
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStrength = 1;
-            }
-
-        } /* end of: else if(dir == 0) */
-
-    } /* end of: if( !(MbP->mbMode == AVC_I4 ...) */
-}
-
-
-void GetStrength_VerticalEdges(uint8 *Strength, AVCMacroblock* MbQ)
-{
-    int     idx, tmp;
-    int16   *ptr, *pmvx, *pmvy;
-    uint8   *pnz;
-    uint8   *pStrength, *pStr;
-    void* refIdx;
-
-    if (MbQ->mbMode == AVC_I4 || MbQ->mbMode == AVC_I16)
-    {
-        *((int*)Strength)     = ININT_STRENGTH[1];      // Start with Strength=3. or Strength=4 for Mb-edge
-        *((int*)(Strength + 4)) = ININT_STRENGTH[2];
-        *((int*)(Strength + 8)) = ININT_STRENGTH[3];
-    }
-    else   // Not intra or SP-frame
-    {
-
-        *((int*)Strength)     = 0; // for non-intra MB, strength = 0, 1 or 2.
-        *((int*)(Strength + 4)) = 0;
-        *((int*)(Strength + 8)) = 0;
-
-        //1. Check the ref_frame_id
-        refIdx = (void*)MbQ->RefIdx;  //de-ref type-punned pointer fix
-        ptr = (int16*)refIdx;
-        pStrength = Strength;
-        if (ptr[0] != ptr[1]) pStrength[4] = 1;
-        if (ptr[2] != ptr[3]) pStrength[6] = 1;
-        pStrength[5] = pStrength[4];
-        pStrength[7] = pStrength[6];
-
-        //2. Check the nz_coeff block and mv difference
-        pmvx = (int16*)(MbQ->mvL0 + 1); // points to 4x4 block #1,not #0
-        pmvy = pmvx + 1;
-        for (idx = 0; idx < 4; idx += 2) // unroll the loop, make 4 iterations to 2
-        {
-            // first/third row : 1,2,3 or 9,10,12
-            // Strength = 2 for a whole row
-            pnz = MbQ->nz_coeff + (idx << 2);
-            if (*pnz++ != 0) *pStrength = 2;
-            if (*pnz++ != 0)
-            {
-                *pStrength = 2;
-                *(pStrength + 4) = 2;
-            }
-            if (*pnz++ != 0)
-            {
-                *(pStrength + 4) = 2;
-                *(pStrength + 8) = 2;
-            }
-            if (*pnz != 0) *(pStrength + 8) = 2;
-
-            // Then Strength = 1
-            if (*pStrength == 0)
-            {
-                //within the same 8x8 block, no need to check the reference id
-                //only need to check the |mv difference| >= 4
-                tmp = *pmvx - *(pmvx - 2);
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStrength = 1;
-
-                tmp = *pmvy - *(pmvy - 2);
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStrength = 1;
-            }
-
-            pmvx += 2;
-            pmvy += 2;
-            pStr = pStrength + 4;
-
-            if (*pStr == 0)
-            {
-                //check the |mv difference| >= 4
-                tmp = *pmvx - *(pmvx - 2);
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStr = 1;
-
-                tmp = *pmvy - *(pmvy - 2);
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStr = 1;
-            }
-
-            pmvx += 2;
-            pmvy += 2;
-            pStr = pStrength + 8;
-
-            if (*pStr == 0)
-            {
-                //within the same 8x8 block, no need to check the reference id
-                //only need to check the |mv difference| >= 4
-                tmp = *pmvx - *(pmvx - 2);
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStr = 1;
-
-                tmp = *pmvy - *(pmvy - 2);
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStr = 1;
-            }
-
-            // Second/fourth row: 5,6,7 or 14,15,16
-            // Strength = 2 for a whole row
-            pnz = MbQ->nz_coeff + ((idx + 1) << 2);
-            if (*pnz++ != 0) *(pStrength + 1) = 2;
-            if (*pnz++ != 0)
-            {
-                *(pStrength + 1) = 2;
-                *(pStrength + 5) = 2;
-            }
-            if (*pnz++ != 0)
-            {
-                *(pStrength + 5) = 2;
-                *(pStrength + 9) = 2;
-            }
-            if (*pnz != 0) *(pStrength + 9) = 2;
-
-            // Then Strength = 1
-            pmvx += 4;
-            pmvy += 4;
-            pStr = pStrength + 1;
-            if (*pStr == 0)
-            {
-                //within the same 8x8 block, no need to check the reference id
-                //only need to check the |mv difference| >= 4
-                tmp = *pmvx - *(pmvx - 2);
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStr = 1;
-
-                tmp = *pmvy - *(pmvy - 2);
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStr = 1;
-            }
-
-            pmvx += 2;
-            pmvy += 2;
-            pStr = pStrength + 5;
-
-            if (*pStr == 0)
-            {
-                //check the |mv difference| >= 4
-                tmp = *pmvx - *(pmvx - 2);
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStr = 1;
-
-                tmp = *pmvy - *(pmvy - 2);
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStr = 1;
-            }
-
-            pmvx += 2;
-            pmvy += 2;
-            pStr = pStrength + 9;
-
-            if (*pStr == 0)
-            {
-                //within the same 8x8 block, no need to check the reference id
-                //only need to check the |mv difference| >= 4
-                tmp = *pmvx - *(pmvx - 2);
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStr = 1;
-
-                tmp = *pmvy - *(pmvy - 2);
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStr = 1;
-            }
-
-            // update some variables for the next two rows
-            pmvx += 4;
-            pmvy += 4;
-            pStrength += 2;
-
-        } /* end of: for(idx=0; idx<2; idx++) */
-
-    } /* end of: else if( MbQ->mbMode == AVC_I4 ...) */
-}
-
-
-void GetStrength_HorizontalEdges(uint8 Strength[12], AVCMacroblock* MbQ)
-{
-    int     idx, tmp;
-    int16   *ptr, *pmvx, *pmvy;
-    uint8   *pStrength, *pStr;
-    void* refIdx;
-
-    if (MbQ->mbMode == AVC_I4 || MbQ->mbMode == AVC_I16)
-    {
-        *((int*)Strength)     = ININT_STRENGTH[1];      // Start with Strength=3. or Strength=4 for Mb-edge
-        *((int*)(Strength + 4)) = ININT_STRENGTH[2];
-        *((int*)(Strength + 8)) = ININT_STRENGTH[3];
-    }
-    else   // Not intra or SP-frame
-    {
-
-        *((int*)Strength)     = 0; // for non-intra MB, strength = 0, 1 or 2.
-        *((int*)(Strength + 4)) = 0; // for non-intra MB, strength = 0, 1 or 2.
-        *((int*)(Strength + 8)) = 0; // for non-intra MB, strength = 0, 1 or 2.
-
-
-        //1. Check the ref_frame_id
-        refIdx = (void*) MbQ->RefIdx; // de-ref type-punned fix
-        ptr = (int16*) refIdx;
-        pStrength = Strength;
-        if (ptr[0] != ptr[2]) pStrength[4] = 1;
-        if (ptr[1] != ptr[3]) pStrength[6] = 1;
-        pStrength[5] = pStrength[4];
-        pStrength[7] = pStrength[6];
-
-        //2. Check the nz_coeff block and mv difference
-        pmvx = (int16*)(MbQ->mvL0 + 4); // points to 4x4 block #4,not #0
-        pmvy = pmvx + 1;
-        for (idx = 0; idx < 4; idx += 2) // unroll the loop, make 4 iterations to 2
-        {
-            // first/third row : 1,2,3 or 9,10,12
-            // Strength = 2 for a whole row
-            if (MbQ->nz_coeff[idx] != 0) *pStrength = 2;
-            if (MbQ->nz_coeff[4+idx] != 0)
-            {
-                *pStrength = 2;
-                *(pStrength + 4) = 2;
-            }
-            if (MbQ->nz_coeff[8+idx] != 0)
-            {
-                *(pStrength + 4) = 2;
-                *(pStrength + 8) = 2;
-            }
-            if (MbQ->nz_coeff[12+idx] != 0) *(pStrength + 8) = 2;
-
-            // Then Strength = 1
-            if (*pStrength == 0)
-            {
-                //within the same 8x8 block, no need to check the reference id
-                //only need to check the |mv difference| >= 4
-                tmp = *pmvx - *(pmvx - 8);
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStrength = 1;
-
-                tmp = *pmvy - *(pmvy - 8);
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStrength = 1;
-            }
-
-            pmvx += 8;
-            pmvy += 8;
-            pStr = pStrength + 4;
-
-            if (*pStr == 0)
-            {
-                //check the |mv difference| >= 4
-                tmp = *pmvx - *(pmvx - 8);
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStr = 1;
-
-                tmp = *pmvy - *(pmvy - 8);
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStr = 1;
-            }
-
-            pmvx += 8;
-            pmvy += 8;
-            pStr = pStrength + 8;
-
-            if (*pStr == 0)
-            {
-                //within the same 8x8 block, no need to check the reference id
-                //only need to check the |mv difference| >= 4
-                tmp = *pmvx - *(pmvx - 8);
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStr = 1;
-
-                tmp = *pmvy - *(pmvy - 8);
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStr = 1;
-            }
-
-            // Second/fourth row: 5,6,7 or 14,15,16
-            // Strength = 2 for a whole row
-            if (MbQ->nz_coeff[idx+1] != 0) *(pStrength + 1) = 2;
-            if (MbQ->nz_coeff[4+idx+1] != 0)
-            {
-                *(pStrength + 1) = 2;
-                *(pStrength + 5) = 2;
-            }
-            if (MbQ->nz_coeff[8+idx+1] != 0)
-            {
-                *(pStrength + 5) = 2;
-                *(pStrength + 9) = 2;
-            }
-            if (MbQ->nz_coeff[12+idx+1] != 0) *(pStrength + 9) = 2;
-
-            // Then Strength = 1
-            pmvx -= 14;
-            pmvy -= 14; // -14 = -16 + 2
-            pStr = pStrength + 1;
-            if (*pStr == 0)
-            {
-                //within the same 8x8 block, no need to check the reference id
-                //only need to check the |mv difference| >= 4
-                tmp = *pmvx - *(pmvx - 8);
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStr = 1;
-
-                tmp = *pmvy - *(pmvy - 8);
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStr = 1;
-            }
-
-            pmvx += 8;
-            pmvy += 8;
-            pStr = pStrength + 5;
-
-            if (*pStr == 0)
-            {
-                //check the |mv difference| >= 4
-                tmp = *pmvx - *(pmvx - 8);
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStr = 1;
-
-                tmp = *pmvy - *(pmvy - 8);
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStr = 1;
-            }
-
-            pmvx += 8;
-            pmvy += 8;
-            pStr = pStrength + 9;
-
-            if (*pStr == 0)
-            {
-                //within the same 8x8 block, no need to check the reference id
-                //only need to check the |mv difference| >= 4
-                tmp = *pmvx - *(pmvx - 8);
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStr = 1;
-
-                tmp = *pmvy - *(pmvy - 8);
-                if (tmp < 0) tmp = -tmp;
-                if (tmp >= 4) *pStr = 1;
-            }
-
-            // update some variables for the next two rows
-            pmvx -= 14;
-            pmvy -= 14; // -14 = -16 + 2
-            pStrength += 2;
-
-        } /* end of: for(idx=0; idx<2; idx++) */
-
-    } /* end of: else if( MbQ->mbMode == AVC_I4 ...) */
-}
-
-/*
- *****************************************************************************************
- * \brief  Filters one edge of 16 (luma) or 8 (chroma) pel
- *****************************************************************************************
-*/
-
-void EdgeLoop_Luma_horizontal(uint8* SrcPtr, uint8 *Strength, int Alpha, int Beta, int *clipTable, int pitch)
-{
-    int  pel, ap = 0, aq = 0, Strng;
-    int  C0, c0, dif, AbsDelta, tmp, tmp1;
-    int  L2 = 0, L1, L0, R0, R1, R2 = 0, RL0;
-
-
-    if (Strength[0] == 4)  /* INTRA strong filtering */
-    {
-        for (pel = 0; pel < 16; pel++)
-        {
-            R0  = SrcPtr[0];
-            R1  = SrcPtr[pitch];
-            L0  = SrcPtr[-pitch];
-            L1  = SrcPtr[-(pitch<<1)];
-
-            // |R0 - R1| < Beta
-            tmp1 = R0 - R1;
-            if (tmp1 < 0) tmp1 = -tmp1;
-            tmp = (tmp1 - Beta);
-
-            //|L0 - L1| < Beta
-            tmp1 = L0 - L1;
-            if (tmp1 < 0) tmp1 = -tmp1;
-            tmp &= (tmp1 - Beta);
-
-            //|R0 - L0| < Alpha
-            AbsDelta = R0 - L0;
-            if (AbsDelta < 0) AbsDelta = -AbsDelta;
-            tmp &= (AbsDelta - Alpha);
-
-            if (tmp < 0)
-            {
-                AbsDelta -= ((Alpha >> 2) + 2);
-                R2 = SrcPtr[pitch<<1]; //inc2
-                L2 = SrcPtr[-(pitch+(pitch<<1))]; // -inc3
-
-                // |R0 - R2| < Beta && |R0 - L0| < (Alpha/4 + 2)
-                tmp = R0 - R2;
-                if (tmp < 0) tmp = -tmp;
-                aq = AbsDelta & (tmp - Beta);
-
-                // |L0 - L2| < Beta && |R0 - L0| < (Alpha/4 + 2)
-                tmp = L0 - L2;
-                if (tmp < 0) tmp = -tmp;
-                ap = AbsDelta & (tmp - Beta);
-
-                if (aq < 0)
-                {
-                    tmp = R1 + R0 + L0;
-                    SrcPtr[0] = (L1 + (tmp << 1) +  R2 + 4) >> 3;
-                    tmp += R2;
-                    SrcPtr[pitch]  = (tmp + 2) >> 2;
-                    SrcPtr[pitch<<1] = (((SrcPtr[(pitch+(pitch<<1))] + R2) << 1) + tmp + 4) >> 3;
-                }
-                else
-                    SrcPtr[0] = ((R1 << 1) + R0 + L1 + 2) >> 2;
-
-                if (ap < 0)
-                {
-                    tmp = L1 + R0 + L0;
-                    SrcPtr[-pitch]  = (R1 + (tmp << 1) +  L2 + 4) >> 3;
-                    tmp += L2;
-                    SrcPtr[-(pitch<<1)] = (tmp + 2) >> 2;
-                    SrcPtr[-(pitch+(pitch<<1))] = (((SrcPtr[-(pitch<<2)] + L2) << 1) + tmp + 4) >> 3;
-                }
-                else
-                    SrcPtr[-pitch] = ((L1 << 1) + L0 + R1 + 2) >> 2;
-
-            } /* if(tmp < 0) */
-
-            SrcPtr ++; // Increment to next set of pixel
-
-        } /* end of: for(pel=0; pel<16; pel++) */
-
-    } /* if(Strength[0] == 4) */
-
-    else   /* Normal filtering */
-    {
-        for (pel = 0; pel < 16; pel++)
-        {
-            Strng = Strength[pel >> 2];
-            if (Strng)
-            {
-                R0  = SrcPtr[0];
-                R1  = SrcPtr[pitch];
-                L0  = SrcPtr[-pitch];
-                L1  = SrcPtr[-(pitch<<1)]; // inc2
-
-                //|R0 - L0| < Alpha
-                tmp1 = R0 - L0;
-                if (tmp1 < 0) tmp1 = -tmp1;
-                tmp = (tmp1 - Alpha);
-
-                // |R0 - R1| < Beta
-                tmp1 = R0 - R1;
-                if (tmp1 < 0) tmp1 = -tmp1;
-                tmp &= (tmp1 - Beta);
-
-                //|L0 - L1| < Beta
-                tmp1 = L0 - L1;
-                if (tmp1 < 0) tmp1 = -tmp1;
-                tmp &= (tmp1 - Beta);
-
-                if (tmp < 0)
-                {
-                    R2 = SrcPtr[pitch<<1]; //inc2
-                    L2 = SrcPtr[-(pitch+(pitch<<1))]; // -inc3
-
-                    // |R0 - R2| < Beta
-                    tmp = R0 - R2;
-                    if (tmp < 0) tmp = -tmp;
-                    aq = tmp - Beta;
-
-                    // |L0 - L2| < Beta
-                    tmp = L0 - L2;
-                    if (tmp < 0) tmp = -tmp;
-                    ap = tmp - Beta;
-
-
-                    c0 = C0 = clipTable[Strng];
-                    if (ap < 0) c0++;
-                    if (aq < 0) c0++;
-
-                    //dif = IClip(-c0, c0, ((Delta << 2) + (L1 - R1) + 4) >> 3);
-                    dif = (((R0 - L0) << 2) + (L1 - R1) + 4) >> 3;
-                    tmp = dif + c0;
-                    if ((uint)tmp > (uint)c0 << 1)
-                    {
-                        tmp = ~(tmp >> 31);
-                        dif = (tmp & (c0 << 1)) - c0;
-                    }
-
-                    //SrcPtr[0]    = (uint8)IClip(0, 255, R0 - dif);
-                    //SrcPtr[-inc] = (uint8)IClip(0, 255, L0 + dif);
-                    RL0 = R0 + L0;
-                    R0 -= dif;
-                    L0 += dif;
-                    if ((uint)R0 > 255)
-                    {
-                        tmp = ~(R0 >> 31);
-                        R0 = tmp & 255;
-                    }
-                    if ((uint)L0 > 255)
-                    {
-                        tmp = ~(L0 >> 31);
-                        L0 = tmp & 255;
-                    }
-                    SrcPtr[-pitch] = L0;
-                    SrcPtr[0] = R0;
-
-                    if (C0 != 0) /* Multiple zeros in the clip tables */
-                    {
-                        if (aq < 0)  // SrcPtr[inc]   += IClip(-C0, C0,(R2 + ((RL0 + 1) >> 1) - (R1<<1)) >> 1);
-                        {
-                            R2 = (R2 + ((RL0 + 1) >> 1) - (R1 << 1)) >> 1;
-                            tmp = R2 + C0;
-                            if ((uint)tmp > (uint)C0 << 1)
-                            {
-                                tmp = ~(tmp >> 31);
-                                R2 = (tmp & (C0 << 1)) - C0;
-                            }
-                            SrcPtr[pitch] += R2;
-                        }
-
-                        if (ap < 0)  //SrcPtr[-inc2] += IClip(-C0, C0,(L2 + ((RL0 + 1) >> 1) - (L1<<1)) >> 1);
-                        {
-                            L2 = (L2 + ((RL0 + 1) >> 1) - (L1 << 1)) >> 1;
-                            tmp = L2 + C0;
-                            if ((uint)tmp > (uint)C0 << 1)
-                            {
-                                tmp = ~(tmp >> 31);
-                                L2 = (tmp & (C0 << 1)) - C0;
-                            }
-                            SrcPtr[-(pitch<<1)] += L2;
-                        }
-                    }
-
-                } /* if(tmp < 0) */
-
-            } /* end of:  if((Strng = Strength[pel >> 2])) */
-
-            SrcPtr ++; // Increment to next set of pixel
-
-        } /* for(pel=0; pel<16; pel++) */
-
-    } /* else if(Strength[0] == 4) */
-}
-
-void EdgeLoop_Luma_vertical(uint8* SrcPtr, uint8 *Strength, int Alpha, int Beta, int *clipTable, int pitch)
-{
-    int  pel, ap = 1, aq = 1;
-    int  C0, c0, dif, AbsDelta, Strng, tmp, tmp1;
-    int  L2 = 0, L1, L0, R0, R1, R2 = 0;
-    uint8 *ptr, *ptr1;
-    uint R_in, L_in;
-    uint R_out, L_out;
-
-
-    if (Strength[0] == 4)  /* INTRA strong filtering */
-    {
-
-        for (pel = 0; pel < 16; pel++)
-        {
-
-            // Read 8 pels
-            R_in = *((uint *)SrcPtr);       // R_in = {R3, R2, R1, R0}
-            L_in = *((uint *)(SrcPtr - 4)); // L_in = {L0, L1, L2, L3}
-            R1   = (R_in >> 8) & 0xff;
-            R0   = R_in & 0xff;
-            L0   = L_in >> 24;
-            L1   = (L_in >> 16) & 0xff;
-
-            // |R0 - R1| < Beta
-            tmp1 = (R_in & 0xff) - R1;
-            if (tmp1 < 0) tmp1 = -tmp1;
-            tmp = (tmp1 - Beta);
-
-
-            //|L0 - L1| < Beta
-            tmp1 = (L_in >> 24) - L1;
-            if (tmp1 < 0) tmp1 = -tmp1;
-            tmp &= (tmp1 - Beta);
-
-            //|R0 - L0| < Alpha
-            AbsDelta = (R_in & 0xff) - (L_in >> 24);
-            if (AbsDelta < 0) AbsDelta = -AbsDelta;
-            tmp &= (AbsDelta - Alpha);
-
-            if (tmp < 0)
-            {
-                AbsDelta -= ((Alpha >> 2) + 2);
-                R2   = (R_in >> 16) & 0xff;
-                L2   = (L_in >> 8) & 0xff;
-
-                // |R0 - R2| < Beta && |R0 - L0| < (Alpha/4 + 2)
-                tmp1 = (R_in & 0xff) - R2;
-                if (tmp1 < 0) tmp1 = -tmp1;
-                aq = AbsDelta & (tmp1 - Beta);
-
-                // |L0 - L2| < Beta && |R0 - L0| < (Alpha/4 + 2)
-                tmp1 = (L_in >> 24) - L2;
-                if (tmp1 < 0) tmp1 = -tmp1;
-                ap = AbsDelta & (tmp1 - Beta);
-
-
-                ptr = SrcPtr;
-                if (aq < 0)
-                {
-                    R_out = (R_in >> 24) << 24; // Keep R3 at the fourth byte
-
-                    tmp  = R0 + L0 + R1;
-                    R_out |= (((tmp << 1) +  L1 + R2 + 4) >> 3);
-                    tmp += R2;
-                    R_out |= (((tmp + 2) >> 2) << 8);
-                    tmp1 = ((R_in >> 24) + R2) << 1;
-                    R_out |= (((tmp1 + tmp + 4) >> 3) << 16);
-
-                    *((uint *)SrcPtr) = R_out;
-                }
-                else
-                    *ptr = ((R1 << 1) + R0 + L1 + 2) >> 2;
-
-
-                if (ap < 0)
-                {
-                    L_out = (L_in << 24) >> 24; // Keep L3 at the first byte
-
-                    tmp  = R0 + L0 + L1;
-                    L_out |= ((((tmp << 1) + R1 + L2 + 4) >> 3) << 24);
-                    tmp += L2;
-                    L_out |= (((tmp + 2) >> 2) << 16);
-                    tmp1 = ((L_in & 0xff) + L2) << 1;
-                    L_out |= (((tmp1 + tmp + 4) >> 3) << 8);
-
-                    *((uint *)(SrcPtr - 4)) = L_out;
-                }
-                else
-                    *(--ptr) = ((L1 << 1) + L0 + R1 + 2) >> 2;
-
-            } /* if(tmp < 0) */
-
-            SrcPtr += pitch;    // Increment to next set of pixel
-
-        } /* end of: for(pel=0; pel<16; pel++) */
-
-    } /* if(Strength[0] == 4) */
-
-    else   /* Normal filtering */
-    {
-
-        for (pel = 0; pel < 16; pel++)
-        {
-            Strng = Strength[pel >> 2];
-            if (Strng)
-            {
-                // Read 8 pels
-                R_in = *((uint *)SrcPtr);       // R_in = {R3, R2, R1, R0}
-                L_in = *((uint *)(SrcPtr - 4)); // L_in = {L0, L1, L2, L3}
-                R1   = (R_in >> 8) & 0xff;
-                R0   = R_in & 0xff;
-                L0   = L_in >> 24;
-                L1   = (L_in >> 16) & 0xff;
-
-                //|R0 - L0| < Alpha
-                tmp = R0 - L0;
-                if (tmp < 0) tmp = -tmp;
-                tmp -= Alpha;
-
-                // |R0 - R1| < Beta
-                tmp1 = R0 - R1;
-                if (tmp1 < 0) tmp1 = -tmp1;
-                tmp &= (tmp1 - Beta);
-
-                //|L0 - L1| < Beta
-                tmp1 = L0 - L1;
-                if (tmp1 < 0) tmp1 = -tmp1;
-                tmp &= (tmp1 - Beta);
-
-                if (tmp < 0)
-                {
-                    L2 = SrcPtr[-3];
-                    R2 = SrcPtr[2];
-
-                    // |R0 - R2| < Beta
-                    tmp = R0 - R2;
-                    if (tmp < 0) tmp = -tmp;
-                    aq = tmp - Beta;
-
-                    // |L0 - L2| < Beta
-                    tmp = L0 - L2;
-                    if (tmp < 0) tmp = -tmp;
-                    ap = tmp - Beta;
-
-
-                    c0 = C0 = clipTable[Strng];
-                    if (ap < 0) c0++;
-                    if (aq < 0) c0++;
-
-                    //dif = IClip(-c0, c0, ((Delta << 2) + (L1 - R1) + 4) >> 3);
-                    dif = (((R0 - L0) << 2) + (L1 - R1) + 4) >> 3;
-                    tmp = dif + c0;
-                    if ((uint)tmp > (uint)c0 << 1)
-                    {
-                        tmp = ~(tmp >> 31);
-                        dif = (tmp & (c0 << 1)) - c0;
-                    }
-
-                    ptr = SrcPtr;
-                    ptr1 = SrcPtr - 1;
-                    //SrcPtr[0]    = (uint8)IClip(0, 255, R0 - dif);
-                    //SrcPtr[-inc] = (uint8)IClip(0, 255, L0 + dif);
-                    R_in = R0 - dif;
-                    L_in = L0 + dif; /* cannot re-use R0 and L0 here */
-                    if ((uint)R_in > 255)
-                    {
-                        tmp = ~((int)R_in >> 31);
-                        R_in = tmp & 255;
-                    }
-                    if ((uint)L_in > 255)
-                    {
-                        tmp = ~((int)L_in >> 31);
-                        L_in = tmp & 255;
-                    }
-                    *ptr1-- = L_in;
-                    *ptr++  = R_in;
-
-                    if (C0 != 0) // Multiple zeros in the clip tables
-                    {
-                        if (ap < 0)  //SrcPtr[-inc2] += IClip(-C0, C0,(L2 + ((RL0 + 1) >> 1) - (L1<<1)) >> 1);
-                        {
-                            L2 = (L2 + ((R0 + L0 + 1) >> 1) - (L1 << 1)) >> 1;
-                            tmp = L2 + C0;
-                            if ((uint)tmp > (uint)C0 << 1)
-                            {
-                                tmp = ~(tmp >> 31);
-                                L2 = (tmp & (C0 << 1)) - C0;
-                            }
-                            *ptr1 += L2;
-                        }
-
-                        if (aq < 0)  // SrcPtr[inc] += IClip(-C0, C0,(R2 + ((RL0 + 1) >> 1) - (R1<<1)) >> 1);
-                        {
-                            R2 = (R2 + ((R0 + L0 + 1) >> 1) - (R1 << 1)) >> 1;
-                            tmp = R2 + C0;
-                            if ((uint)tmp > (uint)C0 << 1)
-                            {
-                                tmp = ~(tmp >> 31);
-                                R2 = (tmp & (C0 << 1)) - C0;
-                            }
-                            *ptr += R2;
-                        }
-                    }
-
-                } /* if(tmp < 0) */
-
-            } /* end of:  if((Strng = Strength[pel >> 2])) */
-
-            SrcPtr += pitch;    // Increment to next set of pixel
-
-        } /* for(pel=0; pel<16; pel++) */
-
-    } /* else if(Strength[0] == 4) */
-
-}
-
-void EdgeLoop_Chroma_vertical(uint8* SrcPtr, uint8 *Strength, int Alpha, int Beta, int *clipTable, int pitch)
-{
-    int     pel, Strng;
-    int     c0, dif;
-    int     L1, L0, R0, R1, tmp, tmp1;
-    uint8   *ptr;
-    uint    R_in, L_in;
-
-
-    for (pel = 0; pel < 16; pel++)
-    {
-        Strng = Strength[pel>>2];
-        if (Strng)
-        {
-            // Read 8 pels
-            R_in = *((uint *)SrcPtr);       // R_in = {R3, R2, R1, R0}
-            L_in = *((uint *)(SrcPtr - 4)); // L_in = {L0, L1, L2, L3}
-            R1   = (R_in >> 8) & 0xff;
-            R0   = R_in & 0xff;
-            L0   = L_in >> 24;
-            L1   = (L_in >> 16) & 0xff;
-
-            // |R0 - R1| < Beta
-            tmp1 = R0 - R1;
-            if (tmp1 < 0) tmp1 = -tmp1;
-            tmp = (tmp1 - Beta);
-
-            //|L0 - L1| < Beta
-            tmp1 = L0 - L1;
-            if (tmp1 < 0) tmp1 = -tmp1;
-            tmp &= (tmp1 - Beta);
-
-            //|R0 - L0| < Alpha
-            tmp1 = R0 - L0;
-            if (tmp1 < 0) tmp1 = -tmp1;
-            tmp &= (tmp1 - Alpha);
-
-            if (tmp < 0)
-            {
-                ptr = SrcPtr;
-                if (Strng == 4) /* INTRA strong filtering */
-                {
-                    *ptr-- = ((R1 << 1) + R0 + L1 + 2) >> 2;
-                    *ptr   = ((L1 << 1) + L0 + R1 + 2) >> 2;
-                }
-                else  /* normal filtering */
-                {
-                    c0  = clipTable[Strng] + 1;
-                    //dif = IClip(-c0, c0, ((Delta << 2) + (L1 - R1) + 4) >> 3);
-                    dif = (((R0 - L0) << 2) + (L1 - R1) + 4) >> 3;
-                    tmp = dif + c0;
-                    if ((uint)tmp > (uint)c0 << 1)
-                    {
-                        tmp = ~(tmp >> 31);
-                        dif = (tmp & (c0 << 1)) - c0;
-                    }
-
-                    //SrcPtr[0]    = (uint8)IClip(0, 255, R0 - dif);
-                    //SrcPtr[-inc] = (uint8)IClip(0, 255, L0 + dif);
-                    L0 += dif;
-                    R0 -= dif;
-                    if ((uint)L0 > 255)
-                    {
-                        tmp = ~(L0 >> 31);
-                        L0 = tmp & 255;
-                    }
-                    if ((uint)R0 > 255)
-                    {
-                        tmp = ~(R0 >> 31);
-                        R0 = tmp & 255;
-                    }
-
-                    *ptr-- = R0;
-                    *ptr = L0;
-                }
-            }
-            pel ++;
-            SrcPtr += pitch;   // Increment to next set of pixel
-
-        } /* end of: if((Strng = Strength[pel >> 2])) */
-        else
-        {
-            pel += 3;
-            SrcPtr += (pitch << 1); //PtrInc << 1;
-        }
-
-    } /* end of: for(pel=0; pel<16; pel++) */
-}
-
-
-void EdgeLoop_Chroma_horizontal(uint8* SrcPtr, uint8 *Strength, int Alpha, int Beta, int *clipTable, int pitch)
-{
-    int  pel, Strng;
-    int  c0, dif;
-    int  L1, L0, R0, R1, tmp, tmp1;
-
-    for (pel = 0; pel < 16; pel++)
-    {
-        Strng = Strength[pel>>2];
-        if (Strng)
-        {
-            R0  = SrcPtr[0];
-            L0  = SrcPtr[-pitch];
-            L1  = SrcPtr[-(pitch<<1)]; //inc2
-            R1  = SrcPtr[pitch];
-
-            // |R0 - R1| < Beta
-            tmp1 = R0 - R1;
-            if (tmp1 < 0) tmp1 = -tmp1;
-            tmp = (tmp1 - Beta);
-
-            //|L0 - L1| < Beta
-            tmp1 = L0 - L1;
-            if (tmp1 < 0) tmp1 = -tmp1;
-            tmp &= (tmp1 - Beta);
-
-            //|R0 - L0| < Alpha
-            tmp1 = R0 - L0;
-            if (tmp1 < 0) tmp1 = -tmp1;
-            tmp &= (tmp1 - Alpha);
-
-            if (tmp < 0)
-            {
-                if (Strng == 4) /* INTRA strong filtering */
-                {
-                    SrcPtr[0]      = ((R1 << 1) + R0 + L1 + 2) >> 2;
-                    SrcPtr[-pitch] = ((L1 << 1) + L0 + R1 + 2) >> 2;
-                }
-                else  /* normal filtering */
-                {
-                    c0  = clipTable[Strng] + 1;
-                    //dif = IClip(-c0, c0, ((Delta << 2) + (L1 - R1) + 4) >> 3);
-                    dif = (((R0 - L0) << 2) + (L1 - R1) + 4) >> 3;
-                    tmp = dif + c0;
-                    if ((uint)tmp > (uint)c0 << 1)
-                    {
-                        tmp = ~(tmp >> 31);
-                        dif = (tmp & (c0 << 1)) - c0;
-                    }
-
-                    //SrcPtr[-inc] = (uint8)IClip(0, 255, L0 + dif);
-                    //SrcPtr[0]    = (uint8)IClip(0, 255, R0 - dif);
-                    L0 += dif;
-                    R0 -= dif;
-                    if ((uint)L0 > 255)
-                    {
-                        tmp = ~(L0 >> 31);
-                        L0 = tmp & 255;
-                    }
-                    if ((uint)R0 > 255)
-                    {
-                        tmp = ~(R0 >> 31);
-                        R0 = tmp & 255;
-                    }
-                    SrcPtr[0] = R0;
-                    SrcPtr[-pitch] = L0;
-                }
-            }
-
-            pel ++;
-            SrcPtr ++; // Increment to next set of pixel
-
-        } /* end of: if((Strng = Strength[pel >> 2])) */
-        else
-        {
-            pel += 3;
-            SrcPtr += 2;
-        }
-
-    } /* end of: for(pel=0; pel<16; pel++) */
-}
-
-
-
-
diff --git a/media/libstagefright/codecs/avc/common/src/dpb.cpp b/media/libstagefright/codecs/avc/common/src/dpb.cpp
deleted file mode 100644
index b5d0dfe..0000000
--- a/media/libstagefright/codecs/avc/common/src/dpb.cpp
+++ /dev/null
@@ -1,724 +0,0 @@
-/* ------------------------------------------------------------------
- * 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 "avclib_common.h"
-
-#define DPB_MEM_ATTR 0
-
-AVCStatus InitDPB(AVCHandle *avcHandle, AVCCommonObj *video, int FrameHeightInMbs, int PicWidthInMbs, bool padding)
-{
-    AVCDecPicBuffer *dpb = video->decPicBuf;
-    int level, framesize, num_fs;
-    void *userData = avcHandle->userData;
-#ifndef PV_MEMORY_POOL
-    uint32 addr;
-#endif
-    uint16 refIdx = 0;
-    level = video->currSeqParams->level_idc;
-
-    for (num_fs = 0; num_fs < MAX_FS; num_fs++)
-    {
-        dpb->fs[num_fs] = NULL;
-    }
-
-    framesize = (int)(((FrameHeightInMbs * PicWidthInMbs) << 7) * 3);
-    if (padding)
-    {
-        video->padded_size = (int)((((FrameHeightInMbs + 2) * (PicWidthInMbs + 2)) << 7) * 3) - framesize;
-    }
-    else
-    {
-        video->padded_size = 0;
-    }
-
-#ifndef PV_MEMORY_POOL
-    if (dpb->decoded_picture_buffer)
-    {
-        avcHandle->CBAVC_Free(userData, (int)dpb->decoded_picture_buffer);
-        dpb->decoded_picture_buffer = NULL;
-    }
-#endif
-    /* need to allocate one extra frame for current frame, DPB only defines for reference frames */
-
-    dpb->num_fs = (uint32)(MaxDPBX2[mapLev2Idx[level]] << 2) / (3 * FrameHeightInMbs * PicWidthInMbs) + 1;
-    if (dpb->num_fs > MAX_FS)
-    {
-        dpb->num_fs = MAX_FS;
-    }
-
-    if (video->currSeqParams->num_ref_frames + 1 > (uint32)dpb->num_fs)
-    {
-        dpb->num_fs = video->currSeqParams->num_ref_frames + 1;
-    }
-
-    dpb->dpb_size = dpb->num_fs * (framesize + video->padded_size);
-//  dpb->dpb_size = (uint32)MaxDPBX2[mapLev2Idx[level]]*512 + framesize;
-
-#ifndef PV_MEMORY_POOL
-    dpb->decoded_picture_buffer = (uint8*) avcHandle->CBAVC_Malloc(userData, dpb->dpb_size, 100/*DPB_MEM_ATTR*/);
-
-    if (dpb->decoded_picture_buffer == NULL || dpb->decoded_picture_buffer&0x3) // not word aligned
-        return AVC_MEMORY_FAIL;
-#endif
-    dpb->used_size = 0;
-    num_fs = 0;
-
-    while (num_fs < dpb->num_fs)
-    {
-        /*  fs is an array pointers to AVCDecPicture */
-        dpb->fs[num_fs] = (AVCFrameStore*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCFrameStore), 101/*DEFAULT_ATTR*/);
-        if (dpb->fs[num_fs] == NULL)
-        {
-            return AVC_MEMORY_FAIL;
-        }
-#ifndef PV_MEMORY_POOL
-        /* assign the actual memory for Sl, Scb, Scr */
-        dpb->fs[num_fs]->base_dpb = dpb->decoded_picture_buffer + dpb->used_size;
-#endif
-        dpb->fs[num_fs]->IsReference = 0;
-        dpb->fs[num_fs]->IsLongTerm = 0;
-        dpb->fs[num_fs]->IsOutputted = 3;
-        dpb->fs[num_fs]->frame.RefIdx = refIdx++; /* this value will remain unchanged through out the encoding session */
-        dpb->fs[num_fs]->frame.picType = AVC_FRAME;
-        dpb->fs[num_fs]->frame.isLongTerm = 0;
-        dpb->fs[num_fs]->frame.isReference = 0;
-        video->RefPicList0[num_fs] = &(dpb->fs[num_fs]->frame);
-        dpb->fs[num_fs]->frame.padded = 0;
-        dpb->used_size += (framesize + video->padded_size);
-        num_fs++;
-    }
-
-    return AVC_SUCCESS;
-}
-
-OSCL_EXPORT_REF AVCStatus AVCConfigureSequence(AVCHandle *avcHandle, AVCCommonObj *video, bool padding)
-{
-    void *userData = avcHandle->userData;
-    AVCDecPicBuffer *dpb = video->decPicBuf;
-    int framesize, ii; /* size of one frame */
-    uint PicWidthInMbs, PicHeightInMapUnits, FrameHeightInMbs, PicSizeInMapUnits;
-    uint num_fs;
-    /* derived variables from SPS */
-    PicWidthInMbs = video->currSeqParams->pic_width_in_mbs_minus1 + 1;
-    PicHeightInMapUnits = video->currSeqParams->pic_height_in_map_units_minus1 + 1 ;
-    FrameHeightInMbs = (2 - video->currSeqParams->frame_mbs_only_flag) * PicHeightInMapUnits ;
-    PicSizeInMapUnits = PicWidthInMbs * PicHeightInMapUnits ;
-
-    if (video->PicSizeInMapUnits != PicSizeInMapUnits || video->currSeqParams->level_idc != video->level_idc)
-    {
-        /* make sure you mark all the frames as unused for reference for flushing*/
-        for (ii = 0; ii < dpb->num_fs; ii++)
-        {
-            dpb->fs[ii]->IsReference = 0;
-            dpb->fs[ii]->IsOutputted |= 0x02;
-        }
-
-        num_fs = (uint32)(MaxDPBX2[(uint32)mapLev2Idx[video->currSeqParams->level_idc]] << 2) / (3 * PicSizeInMapUnits) + 1;
-        if (num_fs >= MAX_FS)
-        {
-            num_fs = MAX_FS;
-        }
-#ifdef PV_MEMORY_POOL
-        if (padding)
-        {
-            avcHandle->CBAVC_DPBAlloc(avcHandle->userData,
-                                      PicSizeInMapUnits + ((PicWidthInMbs + 2) << 1) + (PicHeightInMapUnits << 1), num_fs);
-        }
-        else
-        {
-            avcHandle->CBAVC_DPBAlloc(avcHandle->userData, PicSizeInMapUnits, num_fs);
-        }
-#endif
-        CleanUpDPB(avcHandle, video);
-        if (InitDPB(avcHandle, video, FrameHeightInMbs, PicWidthInMbs, padding) != AVC_SUCCESS)
-        {
-            return AVC_FAIL;
-        }
-        /*  Allocate video->mblock upto PicSizeInMbs and populate the structure  such as the neighboring MB pointers.   */
-        framesize = (FrameHeightInMbs * PicWidthInMbs);
-        if (video->mblock)
-        {
-            avcHandle->CBAVC_Free(userData, video->mblock);
-            video->mblock = NULL;
-        }
-        video->mblock = (AVCMacroblock*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCMacroblock) * framesize, DEFAULT_ATTR);
-        if (video->mblock == NULL)
-        {
-            return AVC_FAIL;
-        }
-        for (ii = 0; ii < framesize; ii++)
-        {
-            video->mblock[ii].slice_id = -1;
-        }
-        /* Allocate memory for intra prediction */
-#ifdef MB_BASED_DEBLOCK
-        video->intra_pred_top = (uint8*) avcHandle->CBAVC_Malloc(userData, PicWidthInMbs << 4, FAST_MEM_ATTR);
-        if (video->intra_pred_top == NULL)
-        {
-            return AVC_FAIL;
-        }
-        video->intra_pred_top_cb = (uint8*) avcHandle->CBAVC_Malloc(userData, PicWidthInMbs << 3, FAST_MEM_ATTR);
-        if (video->intra_pred_top_cb == NULL)
-        {
-            return AVC_FAIL;
-        }
-        video->intra_pred_top_cr = (uint8*) avcHandle->CBAVC_Malloc(userData, PicWidthInMbs << 3, FAST_MEM_ATTR);
-        if (video->intra_pred_top_cr == NULL)
-        {
-            return AVC_FAIL;
-        }
-
-#endif
-        /*  Allocate slice group MAP map */
-
-        if (video->MbToSliceGroupMap)
-        {
-            avcHandle->CBAVC_Free(userData, video->MbToSliceGroupMap);
-            video->MbToSliceGroupMap = NULL;
-        }
-        video->MbToSliceGroupMap = (int*) avcHandle->CBAVC_Malloc(userData, sizeof(uint) * PicSizeInMapUnits * 2, 7/*DEFAULT_ATTR*/);
-        if (video->MbToSliceGroupMap == NULL)
-        {
-            return AVC_FAIL;
-        }
-        video->PicSizeInMapUnits = PicSizeInMapUnits;
-        video->level_idc = video->currSeqParams->level_idc;
-
-    }
-    return AVC_SUCCESS;
-}
-
-OSCL_EXPORT_REF AVCStatus CleanUpDPB(AVCHandle *avcHandle, AVCCommonObj *video)
-{
-    AVCDecPicBuffer *dpb = video->decPicBuf;
-    int ii;
-    void *userData = avcHandle->userData;
-
-    for (ii = 0; ii < MAX_FS; ii++)
-    {
-        if (dpb->fs[ii] != NULL)
-        {
-            avcHandle->CBAVC_Free(userData, dpb->fs[ii]);
-            dpb->fs[ii] = NULL;
-        }
-    }
-#ifndef PV_MEMORY_POOL
-    if (dpb->decoded_picture_buffer)
-    {
-        avcHandle->CBAVC_Free(userData, dpb->decoded_picture_buffer);
-        dpb->decoded_picture_buffer = NULL;
-    }
-#endif
-    dpb->used_size = 0;
-    dpb->dpb_size = 0;
-
-    return AVC_SUCCESS;
-}
-
-OSCL_EXPORT_REF AVCStatus DPBInitBuffer(AVCHandle *avcHandle, AVCCommonObj *video)
-{
-    AVCDecPicBuffer *dpb = video->decPicBuf;
-    int ii, status;
-
-    /* Before doing any decoding, check if there's a frame memory available */
-    /* look for next unused dpb->fs, or complementary field pair */
-    /* video->currPic is assigned to this */
-
-    /* There's also restriction on the frame_num, see page 59 of JVT-I1010.doc. */
-
-    for (ii = 0; ii < dpb->num_fs; ii++)
-    {
-        /* looking for the one not used or not reference and has been outputted */
-        if (dpb->fs[ii]->IsReference == 0 && dpb->fs[ii]->IsOutputted == 3)
-        {
-            video->currFS = dpb->fs[ii];
-#ifdef PV_MEMORY_POOL
-            status = avcHandle->CBAVC_FrameBind(avcHandle->userData, ii, &(video->currFS->base_dpb));
-            if (status == AVC_FAIL)
-            {
-                return AVC_NO_BUFFER; /* this should not happen */
-            }
-#endif
-            break;
-        }
-    }
-    if (ii == dpb->num_fs)
-    {
-        return AVC_PICTURE_OUTPUT_READY; /* no empty frame available */
-    }
-    return AVC_SUCCESS;
-}
-
-OSCL_EXPORT_REF void DPBInitPic(AVCCommonObj *video, int CurrPicNum)
-{
-    int offset = 0;
-    int offsetc = 0;
-    int luma_framesize;
-    /* this part has to be set here, assuming that slice header and POC have been decoded. */
-    /* used in GetOutput API */
-    video->currFS->PicOrderCnt = video->PicOrderCnt;
-    video->currFS->FrameNum = video->sliceHdr->frame_num;
-    video->currFS->FrameNumWrap = CurrPicNum;    // MC_FIX
-    /* initialize everything to zero */
-    video->currFS->IsOutputted = 0;
-    video->currFS->IsReference = 0;
-    video->currFS->IsLongTerm = 0;
-    video->currFS->frame.isReference = FALSE;
-    video->currFS->frame.isLongTerm = FALSE;
-
-    /* initialize the pixel pointer to NULL */
-    video->currFS->frame.Sl = video->currFS->frame.Scb = video->currFS->frame.Scr = NULL;
-
-    /* determine video->currPic */
-    /* assign dbp->base_dpb to fs[i]->frame.Sl, Scb, Scr .*/
-    /* For PicSizeInMbs, see DecodeSliceHeader() */
-
-    video->currPic = &(video->currFS->frame);
-
-    video->currPic->padded = 0; // reset this flag to not-padded
-
-    if (video->padded_size)
-    {
-        offset = ((video->PicWidthInSamplesL + 32) << 4) + 16; // offset to the origin
-        offsetc = (offset >> 2) + 4;
-        luma_framesize = (int)((((video->FrameHeightInMbs + 2) * (video->PicWidthInMbs + 2)) << 8));
-    }
-    else
-        luma_framesize = video->PicSizeInMbs << 8;
-
-
-    video->currPic->Sl = video->currFS->base_dpb + offset;
-    video->currPic->Scb = video->currFS->base_dpb  + luma_framesize + offsetc;
-    video->currPic->Scr = video->currPic->Scb + (luma_framesize >> 2);
-    video->currPic->pitch = video->PicWidthInSamplesL + (video->padded_size == 0 ? 0 : 32);
-
-
-    video->currPic->height = video->PicHeightInSamplesL;
-    video->currPic->width = video->PicWidthInSamplesL;
-    video->currPic->PicNum = CurrPicNum;
-}
-
-/* to release skipped frame after encoding */
-OSCL_EXPORT_REF void DPBReleaseCurrentFrame(AVCHandle *avcHandle, AVCCommonObj *video)
-{
-    AVCDecPicBuffer *dpb = video->decPicBuf;
-    int ii;
-
-    video->currFS->IsOutputted = 3; // return this buffer.
-
-#ifdef PV_MEMORY_POOL /* for non-memory pool, no need to do anything */
-
-    /* search for current frame index */
-    ii = dpb->num_fs;
-    while (ii--)
-    {
-        if (dpb->fs[ii] == video->currFS)
-        {
-            avcHandle->CBAVC_FrameUnbind(avcHandle->userData, ii);
-            break;
-        }
-    }
-#endif
-
-    return ;
-}
-
-/* see subclause 8.2.5.1 */
-OSCL_EXPORT_REF AVCStatus StorePictureInDPB(AVCHandle *avcHandle, AVCCommonObj *video)
-{
-    AVCStatus status;
-    AVCDecPicBuffer *dpb = video->decPicBuf;
-    AVCSliceHeader *sliceHdr = video->sliceHdr;
-    int ii, num_ref;
-
-    /* number 1 of 8.2.5.1, we handle gaps in frame_num differently without using the memory */
-    /* to be done!!!! */
-
-    /* number 3 of 8.2.5.1 */
-    if (video->nal_unit_type == AVC_NALTYPE_IDR)
-    {
-        for (ii = 0; ii < dpb->num_fs; ii++)
-        {
-            if (dpb->fs[ii] != video->currFS) /* not current frame */
-            {
-                dpb->fs[ii]->IsReference = 0; /* mark as unused for reference */
-                dpb->fs[ii]->IsLongTerm = 0;  /* but still used until output */
-                dpb->fs[ii]->IsOutputted |= 0x02;
-#ifdef PV_MEMORY_POOL
-                if (dpb->fs[ii]->IsOutputted == 3)
-                {
-                    avcHandle->CBAVC_FrameUnbind(avcHandle->userData, ii);
-                }
-#endif
-            }
-        }
-
-        video->currPic->isReference = TRUE;
-        video->currFS->IsReference = 3;
-
-        if (sliceHdr->long_term_reference_flag == 0)
-        {
-            video->currPic->isLongTerm = FALSE;
-            video->currFS->IsLongTerm = 0;
-            video->MaxLongTermFrameIdx = -1;
-        }
-        else
-        {
-            video->currPic->isLongTerm = TRUE;
-            video->currFS->IsLongTerm = 3;
-            video->currFS->LongTermFrameIdx = 0;
-            video->MaxLongTermFrameIdx = 0;
-        }
-        if (sliceHdr->no_output_of_prior_pics_flag)
-        {
-            for (ii = 0; ii < dpb->num_fs; ii++)
-            {
-                if (dpb->fs[ii] != video->currFS) /* not current frame */
-                {
-                    dpb->fs[ii]->IsOutputted = 3;
-#ifdef PV_MEMORY_POOL
-                    avcHandle->CBAVC_FrameUnbind(avcHandle->userData, ii);
-#endif
-                }
-            }
-        }
-        video->mem_mgr_ctrl_eq_5 = TRUE;    /* flush reference frames MC_FIX */
-    }
-    else
-    {
-        if (video->currPic->isReference == TRUE)
-        {
-            if (sliceHdr->adaptive_ref_pic_marking_mode_flag == 0)
-            {
-                status = sliding_window_process(avcHandle, video, dpb); /* we may have to do this after adaptive_memory_marking */
-            }
-            else
-            {
-                status = adaptive_memory_marking(avcHandle, video, dpb, sliceHdr);
-            }
-            if (status != AVC_SUCCESS)
-            {
-                return status;
-            }
-        }
-    }
-    /* number 4 of 8.2.5.1 */
-    /* This basically says every frame must be at least used for short-term ref. */
-    /* Need to be revisited!!! */
-    /* look at insert_picture_in_dpb() */
-
-
-
-    if (video->nal_unit_type != AVC_NALTYPE_IDR && video->currPic->isLongTerm == FALSE)
-    {
-        if (video->currPic->isReference)
-        {
-            video->currFS->IsReference = 3;
-        }
-        else
-        {
-            video->currFS->IsReference = 0;
-        }
-        video->currFS->IsLongTerm = 0;
-    }
-
-    /* check if number of reference frames doesn't exceed num_ref_frames */
-    num_ref = 0;
-    for (ii = 0; ii < dpb->num_fs; ii++)
-    {
-        if (dpb->fs[ii]->IsReference)
-        {
-            num_ref++;
-        }
-    }
-
-    if (num_ref > (int)video->currSeqParams->num_ref_frames)
-    {
-        return AVC_FAIL; /* out of range */
-    }
-
-    return AVC_SUCCESS;
-}
-
-
-AVCStatus sliding_window_process(AVCHandle *avcHandle, AVCCommonObj *video, AVCDecPicBuffer *dpb)
-{
-    int ii, numShortTerm, numLongTerm;
-    int32 MinFrameNumWrap;
-    int MinIdx;
-
-
-    numShortTerm = 0;
-    numLongTerm = 0;
-    for (ii = 0; ii < dpb->num_fs; ii++)
-    {
-        if (dpb->fs[ii] != video->currFS) /* do not count the current frame */
-        {
-            if (dpb->fs[ii]->IsLongTerm)
-            {
-                numLongTerm++;
-            }
-            else if (dpb->fs[ii]->IsReference)
-            {
-                numShortTerm++;
-            }
-        }
-    }
-
-    while (numShortTerm + numLongTerm >= (int)video->currSeqParams->num_ref_frames)
-    {
-        /* get short-term ref frame with smallest PicOrderCnt */
-        /* this doesn't work for all I-slice clip since PicOrderCnt will not be initialized */
-
-        MinFrameNumWrap = 0x7FFFFFFF;
-        MinIdx = -1;
-        for (ii = 0; ii < dpb->num_fs; ii++)
-        {
-            if (dpb->fs[ii]->IsReference && !dpb->fs[ii]->IsLongTerm)
-            {
-                if (dpb->fs[ii]->FrameNumWrap < MinFrameNumWrap)
-                {
-                    MinFrameNumWrap = dpb->fs[ii]->FrameNumWrap;
-                    MinIdx = ii;
-                }
-            }
-        }
-        if (MinIdx < 0) /* something wrong, impossible */
-        {
-            return AVC_FAIL;
-        }
-
-        /* mark the frame with smallest PicOrderCnt to be unused for reference */
-        dpb->fs[MinIdx]->IsReference = 0;
-        dpb->fs[MinIdx]->IsLongTerm = 0;
-        dpb->fs[MinIdx]->frame.isReference = FALSE;
-        dpb->fs[MinIdx]->frame.isLongTerm = FALSE;
-        dpb->fs[MinIdx]->IsOutputted |= 0x02;
-#ifdef PV_MEMORY_POOL
-        if (dpb->fs[MinIdx]->IsOutputted == 3)
-        {
-            avcHandle->CBAVC_FrameUnbind(avcHandle->userData, MinIdx);
-        }
-#endif
-        numShortTerm--;
-    }
-    return AVC_SUCCESS;
-}
-
-/* see subclause 8.2.5.4 */
-AVCStatus adaptive_memory_marking(AVCHandle *avcHandle, AVCCommonObj *video, AVCDecPicBuffer *dpb, AVCSliceHeader *sliceHdr)
-{
-    int ii;
-
-    ii = 0;
-    while (ii < MAX_DEC_REF_PIC_MARKING && sliceHdr->memory_management_control_operation[ii] != 0)
-    {
-        switch (sliceHdr->memory_management_control_operation[ii])
-        {
-            case 1:
-                MemMgrCtrlOp1(avcHandle, video, dpb, sliceHdr->difference_of_pic_nums_minus1[ii]);
-                //      update_ref_list(dpb);
-                break;
-            case 2:
-                MemMgrCtrlOp2(avcHandle, dpb, sliceHdr->long_term_pic_num[ii]);
-                break;
-            case 3:
-                MemMgrCtrlOp3(avcHandle, video, dpb, sliceHdr->difference_of_pic_nums_minus1[ii], sliceHdr->long_term_frame_idx[ii]);
-                break;
-            case 4:
-                MemMgrCtrlOp4(avcHandle, video, dpb, sliceHdr->max_long_term_frame_idx_plus1[ii]);
-                break;
-            case 5:
-                MemMgrCtrlOp5(avcHandle, video, dpb);
-                video->currFS->FrameNum = 0;    //
-                video->currFS->PicOrderCnt = 0;
-                break;
-            case 6:
-                MemMgrCtrlOp6(avcHandle, video, dpb, sliceHdr->long_term_frame_idx[ii]);
-                break;
-        }
-        ii++;
-    }
-
-    if (ii == MAX_DEC_REF_PIC_MARKING)
-    {
-        return AVC_FAIL; /* exceed the limit */
-    }
-
-    return AVC_SUCCESS;
-}
-
-
-/* see subclause 8.2.5.4.1, mark short-term picture as "unused for reference" */
-void MemMgrCtrlOp1(AVCHandle *avcHandle, AVCCommonObj *video, AVCDecPicBuffer *dpb, int difference_of_pic_nums_minus1)
-{
-    int picNumX, ii;
-
-    picNumX = video->CurrPicNum - (difference_of_pic_nums_minus1 + 1);
-
-    for (ii = 0; ii < dpb->num_fs; ii++)
-    {
-        if (dpb->fs[ii]->IsReference == 3 && dpb->fs[ii]->IsLongTerm == 0)
-        {
-            if (dpb->fs[ii]->frame.PicNum == picNumX)
-            {
-                unmark_for_reference(avcHandle, dpb, ii);
-                return ;
-            }
-        }
-    }
-
-    return ;
-}
-
-/* see subclause 8.2.5.4.2 mark long-term picture as "unused for reference" */
-void MemMgrCtrlOp2(AVCHandle *avcHandle, AVCDecPicBuffer *dpb, int long_term_pic_num)
-{
-    int ii;
-
-    for (ii = 0; ii < dpb->num_fs; ii++)
-    {
-        if (dpb->fs[ii]->IsLongTerm == 3)
-        {
-            if (dpb->fs[ii]->frame.LongTermPicNum == long_term_pic_num)
-            {
-                unmark_for_reference(avcHandle, dpb, ii);
-            }
-        }
-    }
-}
-
-/* see subclause 8.2.5.4.3 assign LongTermFrameIdx to a short-term ref picture */
-void MemMgrCtrlOp3(AVCHandle *avcHandle, AVCCommonObj *video, AVCDecPicBuffer *dpb, uint difference_of_pic_nums_minus1,
-                   uint long_term_frame_idx)
-{
-    int picNumX, ii;
-
-    picNumX = video->CurrPicNum - (difference_of_pic_nums_minus1 + 1);
-
-    /* look for fs[i] with long_term_frame_idx */
-
-    unmark_long_term_frame_for_reference_by_frame_idx(avcHandle, dpb, long_term_frame_idx);
-
-
-    /* now mark the picture with picNumX to long term frame idx */
-
-    for (ii = 0; ii < dpb->num_fs; ii++)
-    {
-        if (dpb->fs[ii]->IsReference == 3)
-        {
-            if ((dpb->fs[ii]->frame.isLongTerm == FALSE) && (dpb->fs[ii]->frame.PicNum == picNumX))
-            {
-                dpb->fs[ii]->LongTermFrameIdx = long_term_frame_idx;
-                dpb->fs[ii]->frame.LongTermPicNum = long_term_frame_idx;
-
-                dpb->fs[ii]->frame.isLongTerm = TRUE;
-
-                dpb->fs[ii]->IsLongTerm = 3;
-                return;
-            }
-        }
-    }
-
-}
-
-/* see subclause 8.2.5.4.4, MaxLongTermFrameIdx */
-void MemMgrCtrlOp4(AVCHandle *avcHandle, AVCCommonObj *video, AVCDecPicBuffer *dpb, uint max_long_term_frame_idx_plus1)
-{
-    int ii;
-
-    video->MaxLongTermFrameIdx = max_long_term_frame_idx_plus1 - 1;
-
-    /* then mark long term frame with exceeding LongTermFrameIdx to unused for reference. */
-    for (ii = 0; ii < dpb->num_fs; ii++)
-    {
-        if (dpb->fs[ii]->IsLongTerm && dpb->fs[ii] != video->currFS)
-        {
-            if (dpb->fs[ii]->LongTermFrameIdx > video->MaxLongTermFrameIdx)
-            {
-                unmark_for_reference(avcHandle, dpb, ii);
-            }
-        }
-    }
-}
-
-/* see subclause 8.2.5.4.5 mark all reference picture as "unused for reference" and setting
-MaxLongTermFrameIdx to "no long-term frame indices" */
-void MemMgrCtrlOp5(AVCHandle *avcHandle, AVCCommonObj *video, AVCDecPicBuffer *dpb)
-{
-    int ii;
-
-    video->MaxLongTermFrameIdx = -1;
-    for (ii = 0; ii < dpb->num_fs; ii++) /* including the current frame ??????*/
-    {
-        if (dpb->fs[ii] != video->currFS) // MC_FIX
-        {
-            unmark_for_reference(avcHandle, dpb, ii);
-        }
-    }
-
-    video->mem_mgr_ctrl_eq_5 = TRUE;
-}
-
-/* see subclause 8.2.5.4.6 assing long-term frame index to the current picture */
-void MemMgrCtrlOp6(AVCHandle *avcHandle, AVCCommonObj *video, AVCDecPicBuffer *dpb, uint long_term_frame_idx)
-{
-
-    unmark_long_term_frame_for_reference_by_frame_idx(avcHandle, dpb, long_term_frame_idx);
-    video->currFS->IsLongTerm = 3;
-    video->currFS->IsReference = 3;
-
-    video->currPic->isLongTerm = TRUE;
-    video->currPic->isReference = TRUE;
-    video->currFS->LongTermFrameIdx = long_term_frame_idx;
-}
-
-
-void unmark_for_reference(AVCHandle *avcHandle, AVCDecPicBuffer *dpb, uint idx)
-{
-
-    AVCFrameStore *fs = dpb->fs[idx];
-    fs->frame.isReference = FALSE;
-    fs->frame.isLongTerm = FALSE;
-
-    fs->IsLongTerm = 0;
-    fs->IsReference = 0;
-    fs->IsOutputted |= 0x02;
-#ifdef PV_MEMORY_POOL
-    if (fs->IsOutputted == 3)
-    {
-        avcHandle->CBAVC_FrameUnbind(avcHandle->userData, idx);
-    }
-#endif
-    return ;
-}
-
-void unmark_long_term_frame_for_reference_by_frame_idx(AVCHandle *avcHandle, AVCDecPicBuffer *dpb, uint long_term_frame_idx)
-{
-    int ii;
-    for (ii = 0; ii < dpb->num_fs; ii++)
-    {
-
-        if (dpb->fs[ii]->IsLongTerm && (dpb->fs[ii]->LongTermFrameIdx == (int)long_term_frame_idx))
-        {
-            unmark_for_reference(avcHandle, dpb, ii);
-        }
-
-    }
-}
-
-
diff --git a/media/libstagefright/codecs/avc/common/src/fmo.cpp b/media/libstagefright/codecs/avc/common/src/fmo.cpp
deleted file mode 100644
index d66eba3..0000000
--- a/media/libstagefright/codecs/avc/common/src/fmo.cpp
+++ /dev/null
@@ -1,249 +0,0 @@
-/* ------------------------------------------------------------------
- * 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 <string.h>
-
-#include "avclib_common.h"
-
-/* see subclause 8.2.2 Decoding process for macroblock to slice group map */
-OSCL_EXPORT_REF AVCStatus FMOInit(AVCCommonObj *video)
-{
-    AVCPicParamSet *currPPS = video->currPicParams;
-    int *MbToSliceGroupMap = video->MbToSliceGroupMap;
-    int PicSizeInMapUnits = video->PicSizeInMapUnits;
-    int PicWidthInMbs = video->PicWidthInMbs;
-
-    if (currPPS->num_slice_groups_minus1 == 0)
-    {
-        memset(video->MbToSliceGroupMap, 0, video->PicSizeInMapUnits*sizeof(uint));
-    }
-    else
-    {
-        switch (currPPS->slice_group_map_type)
-        {
-            case 0:
-                FmoGenerateType0MapUnitMap(MbToSliceGroupMap, currPPS->run_length_minus1, currPPS->num_slice_groups_minus1, PicSizeInMapUnits);
-                break;
-            case 1:
-                FmoGenerateType1MapUnitMap(MbToSliceGroupMap, PicWidthInMbs, currPPS->num_slice_groups_minus1, PicSizeInMapUnits);
-                break;
-            case 2:
-                FmoGenerateType2MapUnitMap(currPPS, MbToSliceGroupMap, PicWidthInMbs, currPPS->num_slice_groups_minus1, PicSizeInMapUnits);
-                break;
-            case 3:
-                FmoGenerateType3MapUnitMap(video, currPPS, MbToSliceGroupMap, PicWidthInMbs);
-                break;
-            case 4:
-                FmoGenerateType4MapUnitMap(MbToSliceGroupMap, video->MapUnitsInSliceGroup0, currPPS->slice_group_change_direction_flag, PicSizeInMapUnits);
-                break;
-            case 5:
-                FmoGenerateType5MapUnitMap(MbToSliceGroupMap, video, currPPS->slice_group_change_direction_flag, PicSizeInMapUnits);
-                break;
-            case 6:
-                FmoGenerateType6MapUnitMap(MbToSliceGroupMap, (int*)currPPS->slice_group_id, PicSizeInMapUnits);
-                break;
-            default:
-                return AVC_FAIL; /* out of range, shouldn't come this far */
-        }
-    }
-
-    return AVC_SUCCESS;
-}
-
-/* see subclause 8.2.2.1 interleaved slice group map type*/
-void FmoGenerateType0MapUnitMap(int *mapUnitToSliceGroupMap, uint *run_length_minus1, uint num_slice_groups_minus1, uint PicSizeInMapUnits)
-{
-    uint iGroup, j;
-    uint i = 0;
-    do
-    {
-        for (iGroup = 0;
-                (iGroup <= num_slice_groups_minus1) && (i < PicSizeInMapUnits);
-                i += run_length_minus1[iGroup++] + 1)
-        {
-            for (j = 0; j <= run_length_minus1[ iGroup ] && i + j < PicSizeInMapUnits; j++)
-                mapUnitToSliceGroupMap[i+j] = iGroup;
-        }
-    }
-    while (i < PicSizeInMapUnits);
-}
-
-/* see subclause 8.2.2.2 dispersed slice group map type*/
-void FmoGenerateType1MapUnitMap(int *mapUnitToSliceGroupMap, int PicWidthInMbs, uint num_slice_groups_minus1, uint PicSizeInMapUnits)
-{
-    uint i;
-    for (i = 0; i < PicSizeInMapUnits; i++)
-    {
-        mapUnitToSliceGroupMap[i] = ((i % PicWidthInMbs) + (((i / PicWidthInMbs) * (num_slice_groups_minus1 + 1)) / 2))
-                                    % (num_slice_groups_minus1 + 1);
-    }
-}
-
-/* see subclause 8.2.2.3 foreground with left-over slice group map type */
-void FmoGenerateType2MapUnitMap(AVCPicParamSet *pps, int *mapUnitToSliceGroupMap, int PicWidthInMbs,
-                                uint num_slice_groups_minus1, uint PicSizeInMapUnits)
-{
-    int iGroup;
-    uint i, x, y;
-    uint yTopLeft, xTopLeft, yBottomRight, xBottomRight;
-
-    for (i = 0; i < PicSizeInMapUnits; i++)
-    {
-        mapUnitToSliceGroupMap[ i ] = num_slice_groups_minus1;
-    }
-
-    for (iGroup = num_slice_groups_minus1 - 1 ; iGroup >= 0; iGroup--)
-    {
-        yTopLeft = pps->top_left[ iGroup ] / PicWidthInMbs;
-        xTopLeft = pps->top_left[ iGroup ] % PicWidthInMbs;
-        yBottomRight = pps->bottom_right[ iGroup ] / PicWidthInMbs;
-        xBottomRight = pps->bottom_right[ iGroup ] % PicWidthInMbs;
-        for (y = yTopLeft; y <= yBottomRight; y++)
-        {
-            for (x = xTopLeft; x <= xBottomRight; x++)
-            {
-                mapUnitToSliceGroupMap[ y * PicWidthInMbs + x ] = iGroup;
-            }
-        }
-    }
-}
-
-
-/* see subclause 8.2.2.4 box-out slice group map type */
-/* follow the text rather than the JM, it's quite different. */
-void FmoGenerateType3MapUnitMap(AVCCommonObj *video, AVCPicParamSet* pps, int *mapUnitToSliceGroupMap,
-                                int PicWidthInMbs)
-{
-    uint i, k;
-    int leftBound, topBound, rightBound, bottomBound;
-    int x, y, xDir, yDir;
-    int mapUnitVacant;
-    uint PicSizeInMapUnits = video->PicSizeInMapUnits;
-    uint MapUnitsInSliceGroup0 = video->MapUnitsInSliceGroup0;
-
-    for (i = 0; i < PicSizeInMapUnits; i++)
-    {
-        mapUnitToSliceGroupMap[ i ] = 1;
-    }
-
-    x = (PicWidthInMbs - pps->slice_group_change_direction_flag) / 2;
-    y = (video->PicHeightInMapUnits - pps->slice_group_change_direction_flag) / 2;
-
-    leftBound   = x;
-    topBound    = y;
-    rightBound  = x;
-    bottomBound = y;
-
-    xDir =  pps->slice_group_change_direction_flag - 1;
-    yDir =  pps->slice_group_change_direction_flag;
-
-    for (k = 0; k < MapUnitsInSliceGroup0; k += mapUnitVacant)
-    {
-        mapUnitVacant = (mapUnitToSliceGroupMap[ y * PicWidthInMbs + x ]  ==  1);
-        if (mapUnitVacant)
-        {
-            mapUnitToSliceGroupMap[ y * PicWidthInMbs + x ] = 0;
-        }
-
-        if (xDir  ==  -1  &&  x  ==  leftBound)
-        {
-            leftBound = AVC_MAX(leftBound - 1, 0);
-            x = leftBound;
-            xDir = 0;
-            yDir = 2 * pps->slice_group_change_direction_flag - 1;
-        }
-        else if (xDir  ==  1  &&  x  ==  rightBound)
-        {
-            rightBound = AVC_MIN(rightBound + 1, (int)PicWidthInMbs - 1);
-            x = rightBound;
-            xDir = 0;
-            yDir = 1 - 2 * pps->slice_group_change_direction_flag;
-        }
-        else if (yDir  ==  -1  &&  y  ==  topBound)
-        {
-            topBound = AVC_MAX(topBound - 1, 0);
-            y = topBound;
-            xDir = 1 - 2 * pps->slice_group_change_direction_flag;
-            yDir = 0;
-        }
-        else  if (yDir  ==  1  &&  y  ==  bottomBound)
-        {
-            bottomBound = AVC_MIN(bottomBound + 1, (int)video->PicHeightInMapUnits - 1);
-            y = bottomBound;
-            xDir = 2 * pps->slice_group_change_direction_flag - 1;
-            yDir = 0;
-        }
-        else
-        {
-            x = x + xDir;
-            y = y + yDir;
-        }
-    }
-}
-
-/* see subclause 8.2.2.5 raster scan slice group map types */
-void FmoGenerateType4MapUnitMap(int *mapUnitToSliceGroupMap, int MapUnitsInSliceGroup0, int slice_group_change_direction_flag, uint PicSizeInMapUnits)
-{
-    uint sizeOfUpperLeftGroup = slice_group_change_direction_flag ? (PicSizeInMapUnits - MapUnitsInSliceGroup0) : MapUnitsInSliceGroup0;
-
-    uint i;
-
-    for (i = 0; i < PicSizeInMapUnits; i++)
-        if (i < sizeOfUpperLeftGroup)
-            mapUnitToSliceGroupMap[ i ] = 1 - slice_group_change_direction_flag;
-        else
-            mapUnitToSliceGroupMap[ i ] = slice_group_change_direction_flag;
-
-}
-
-/* see subclause 8.2.2.6, wipe slice group map type. */
-void FmoGenerateType5MapUnitMap(int *mapUnitToSliceGroupMap, AVCCommonObj *video,
-                                int slice_group_change_direction_flag, uint PicSizeInMapUnits)
-{
-    int PicWidthInMbs = video->PicWidthInMbs;
-    int PicHeightInMapUnits = video->PicHeightInMapUnits;
-    int MapUnitsInSliceGroup0 = video->MapUnitsInSliceGroup0;
-    int sizeOfUpperLeftGroup = slice_group_change_direction_flag ? (PicSizeInMapUnits - MapUnitsInSliceGroup0) : MapUnitsInSliceGroup0;
-    int i, j, k = 0;
-
-    for (j = 0; j < PicWidthInMbs; j++)
-    {
-        for (i = 0; i < PicHeightInMapUnits; i++)
-        {
-            if (k++ < sizeOfUpperLeftGroup)
-            {
-                mapUnitToSliceGroupMap[ i * PicWidthInMbs + j ] = 1 - slice_group_change_direction_flag;
-            }
-            else
-            {
-                mapUnitToSliceGroupMap[ i * PicWidthInMbs + j ] = slice_group_change_direction_flag;
-            }
-        }
-    }
-}
-
-/* see subclause 8.2.2.7, explicit slice group map */
-void FmoGenerateType6MapUnitMap(int *mapUnitToSliceGroupMap, int *slice_group_id, uint PicSizeInMapUnits)
-{
-    uint i;
-    for (i = 0; i < PicSizeInMapUnits; i++)
-    {
-        mapUnitToSliceGroupMap[i] = slice_group_id[i];
-    }
-}
-
-
diff --git a/media/libstagefright/codecs/avc/common/src/mb_access.cpp b/media/libstagefright/codecs/avc/common/src/mb_access.cpp
deleted file mode 100644
index 414b8f7..0000000
--- a/media/libstagefright/codecs/avc/common/src/mb_access.cpp
+++ /dev/null
@@ -1,471 +0,0 @@
-/* ------------------------------------------------------------------
- * 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 <string.h>
-
-#include "avclib_common.h"
-
-OSCL_EXPORT_REF void InitNeighborAvailability(AVCCommonObj *video, int mbNum)
-{
-    int PicWidthInMbs = video->PicWidthInMbs;
-
-    // do frame-only and postpone intraAvail calculattion
-    video->mbAddrA = mbNum - 1;
-    video->mbAddrB = mbNum - PicWidthInMbs;
-    video->mbAddrC = mbNum - PicWidthInMbs + 1;
-    video->mbAddrD = mbNum - PicWidthInMbs - 1;
-
-    video->mbAvailA = video->mbAvailB = video->mbAvailC = video->mbAvailD = 0;
-    if (video->mb_x)
-    {
-        video->mbAvailA = (video->mblock[video->mbAddrA].slice_id == video->currMB->slice_id);
-        if (video->mb_y)
-        {
-            video->mbAvailD = (video->mblock[video->mbAddrD].slice_id == video->currMB->slice_id);
-        }
-    }
-
-    if (video->mb_y)
-    {
-        video->mbAvailB = (video->mblock[video->mbAddrB].slice_id == video->currMB->slice_id);
-        if (video->mb_x < (PicWidthInMbs - 1))
-        {
-            video->mbAvailC = (video->mblock[video->mbAddrC].slice_id == video->currMB->slice_id);
-        }
-    }
-    return ;
-}
-
-bool mb_is_available(AVCMacroblock *mblock, uint PicSizeInMbs, int mbAddr, int currMbAddr)
-{
-    if (mbAddr < 0 || mbAddr >= (int)PicSizeInMbs)
-    {
-        return FALSE;
-    }
-
-    if (mblock[mbAddr].slice_id != mblock[currMbAddr].slice_id)
-    {
-        return FALSE;
-    }
-
-    return TRUE;
-}
-
-OSCL_EXPORT_REF int predict_nnz(AVCCommonObj *video, int i, int j)
-{
-    int pred_nnz = 0;
-    int cnt      = 1;
-    AVCMacroblock *tempMB;
-
-    /* left block */
-    /*getLuma4x4Neighbour(video, mb_nr, i, j, -1, 0, &pix);
-    leftMB = video->mblock + pix.mb_addr; */
-    /* replace the above with below (won't work for field decoding),  1/19/04 */
-
-    if (i)
-    {
-        pred_nnz = video->currMB->nz_coeff[(j<<2)+i-1];
-    }
-    else
-    {
-        if (video->mbAvailA)
-        {
-            tempMB = video->mblock + video->mbAddrA;
-            pred_nnz = tempMB->nz_coeff[(j<<2)+3];
-        }
-        else
-        {
-            cnt = 0;
-        }
-    }
-
-
-    /* top block */
-    /*getLuma4x4Neighbour(video, mb_nr, i, j, 0, -1, &pix);
-    topMB = video->mblock + pix.mb_addr;*/
-    /* replace the above with below (won't work for field decoding),  1/19/04 */
-
-    if (j)
-    {
-        pred_nnz += video->currMB->nz_coeff[((j-1)<<2)+i];
-        cnt++;
-    }
-    else
-    {
-        if (video->mbAvailB)
-        {
-            tempMB = video->mblock + video->mbAddrB;
-            pred_nnz += tempMB->nz_coeff[12+i];
-            cnt++;
-        }
-    }
-
-
-    if (cnt == 2)
-    {
-        pred_nnz = (pred_nnz + 1) >> 1;
-    }
-
-    return pred_nnz;
-
-}
-
-
-OSCL_EXPORT_REF int predict_nnz_chroma(AVCCommonObj *video, int i, int j)
-{
-    int pred_nnz = 0;
-    int cnt      = 1;
-    AVCMacroblock *tempMB;
-
-    /* left block */
-    /*getChroma4x4Neighbour(video, mb_nr, i%2, j-4, -1, 0, &pix);
-    leftMB = video->mblock + pix.mb_addr;*/
-    /* replace the above with below (won't work for field decoding),  1/19/04 */
-    if (i&1)
-    {
-        pred_nnz = video->currMB->nz_coeff[(j<<2)+i-1];
-
-    }
-    else
-    {
-        if (video->mbAvailA)
-        {
-            tempMB = video->mblock + video->mbAddrA;
-            pred_nnz = tempMB->nz_coeff[(j<<2)+i+1];
-        }
-        else
-        {
-            cnt = 0;
-        }
-    }
-
-
-    /* top block */
-    /*getChroma4x4Neighbour(video, mb_nr, i%2, j-4, 0, -1, &pix);
-    topMB = video->mblock + pix.mb_addr;*/
-    /* replace the above with below (won't work for field decoding),  1/19/04 */
-
-    if (j&1)
-    {
-        pred_nnz += video->currMB->nz_coeff[((j-1)<<2)+i];
-        cnt++;
-    }
-    else
-    {
-        if (video->mbAvailB)
-        {
-            tempMB = video->mblock + video->mbAddrB;
-            pred_nnz += tempMB->nz_coeff[20+i];
-            cnt++;
-        }
-
-    }
-
-    if (cnt == 2)
-    {
-        pred_nnz = (pred_nnz + 1) >> 1;
-    }
-
-    return pred_nnz;
-}
-
-OSCL_EXPORT_REF void GetMotionVectorPredictor(AVCCommonObj *video, int encFlag)
-{
-    AVCMacroblock *currMB = video->currMB;
-    AVCMacroblock *MB_A, *MB_B, *MB_C, *MB_D;
-    int block_x, block_y, block_x_1, block_y_1, new_block_x;
-    int mbPartIdx, subMbPartIdx, offset_indx;
-    int16 *mv, pmv_x, pmv_y;
-    int nmSubMbHeight, nmSubMbWidth, mbPartIdx_X, mbPartIdx_Y;
-    int avail_a, avail_b, avail_c;
-    const static uint32 C = 0x5750;
-    int i, j, offset_MbPart_indx, refIdxLXA, refIdxLXB, refIdxLXC = 0, curr_ref_idx;
-    int pmv_A_x, pmv_B_x, pmv_C_x = 0, pmv_A_y, pmv_B_y, pmv_C_y = 0;
-
-    /* we have to take care of Intra/skip blocks somewhere, i.e. set MV to  0 and set ref to -1! */
-    /* we have to populate refIdx as well */
-
-
-    MB_A = &video->mblock[video->mbAddrA];
-    MB_B = &video->mblock[video->mbAddrB];
-
-
-    if (currMB->mbMode == AVC_SKIP /* && !encFlag */) /* only for decoder */
-    {
-        currMB->ref_idx_L0[0] = currMB->ref_idx_L0[1] = currMB->ref_idx_L0[2] = currMB->ref_idx_L0[3] = 0;
-        if (video->mbAvailA && video->mbAvailB)
-        {
-            if ((MB_A->ref_idx_L0[1] == 0 && MB_A->mvL0[3] == 0) ||
-                    (MB_B->ref_idx_L0[2] == 0 && MB_B->mvL0[12] == 0))
-            {
-                memset(currMB->mvL0, 0, sizeof(int32)*16);
-                return;
-            }
-        }
-        else
-        {
-            memset(currMB->mvL0, 0, sizeof(int32)*16);
-            return;
-        }
-        video->mvd_l0[0][0][0] = 0;
-        video->mvd_l0[0][0][1] = 0;
-    }
-
-    MB_C = &video->mblock[video->mbAddrC];
-    MB_D = &video->mblock[video->mbAddrD];
-
-    offset_MbPart_indx = 0;
-    for (mbPartIdx = 0; mbPartIdx < currMB->NumMbPart; mbPartIdx++)
-    {
-        offset_indx = 0;
-        nmSubMbHeight = currMB->SubMbPartHeight[mbPartIdx] >> 2;
-        nmSubMbWidth = currMB->SubMbPartWidth[mbPartIdx] >> 2;
-        mbPartIdx_X = ((mbPartIdx + offset_MbPart_indx) & 1) << 1;
-        mbPartIdx_Y = (mbPartIdx + offset_MbPart_indx) & 2;
-
-        for (subMbPartIdx = 0; subMbPartIdx < currMB->NumSubMbPart[mbPartIdx]; subMbPartIdx++)
-        {
-            block_x = mbPartIdx_X + ((subMbPartIdx + offset_indx) & 1);
-            block_y = mbPartIdx_Y + (((subMbPartIdx + offset_indx) >> 1) & 1);
-
-            block_x_1 = block_x - 1;
-            block_y_1 = block_y - 1;
-            refIdxLXA = refIdxLXB = refIdxLXC = -1;
-            pmv_A_x = pmv_A_y = pmv_B_x = pmv_B_y = pmv_C_x = pmv_C_y = 0;
-
-            if (block_x)
-            {
-                avail_a = 1;
-                refIdxLXA = currMB->ref_idx_L0[(block_y & 2) + (block_x_1 >> 1)];
-                mv = (int16*)(currMB->mvL0 + (block_y << 2) + block_x_1);
-                pmv_A_x = *mv++;
-                pmv_A_y = *mv;
-            }
-            else
-            {
-                avail_a = video->mbAvailA;
-                if (avail_a)
-                {
-                    refIdxLXA = MB_A->ref_idx_L0[(block_y & 2) + 1];
-                    mv = (int16*)(MB_A->mvL0 + (block_y << 2) + 3);
-                    pmv_A_x = *mv++;
-                    pmv_A_y = *mv;
-                }
-            }
-
-            if (block_y)
-            {
-                avail_b = 1;
-                refIdxLXB = currMB->ref_idx_L0[(block_y_1 & 2) + (block_x >> 1)];
-                mv = (int16*)(currMB->mvL0 + (block_y_1 << 2) + block_x);
-                pmv_B_x = *mv++;
-                pmv_B_y = *mv;
-            }
-
-            else
-            {
-                avail_b = video->mbAvailB;
-                if (avail_b)
-                {
-                    refIdxLXB = MB_B->ref_idx_L0[2 + (block_x >> 1)];
-                    mv = (int16*)(MB_B->mvL0 + 12 + block_x);
-                    pmv_B_x = *mv++;
-                    pmv_B_y = *mv;
-                }
-            }
-
-            new_block_x = block_x + (currMB->SubMbPartWidth[mbPartIdx] >> 2) - 1;
-            avail_c = (C >> ((block_y << 2) + new_block_x)) & 0x1;
-
-            if (avail_c)
-            {
-                /* it guaranteed that block_y > 0 && new_block_x<3 ) */
-                refIdxLXC = currMB->ref_idx_L0[(block_y_1 & 2) + ((new_block_x+1) >> 1)];
-                mv = (int16*)(currMB->mvL0 + (block_y_1 << 2) + (new_block_x + 1));
-                pmv_C_x = *mv++;
-                pmv_C_y = *mv;
-            }
-            else
-            {
-                if (block_y == 0 && new_block_x < 3)
-                {
-                    avail_c = video->mbAvailB;
-                    if (avail_c)
-                    {
-                        refIdxLXC = MB_B->ref_idx_L0[2 + ((new_block_x+1)>>1)];
-                        mv = (int16*)(MB_B->mvL0 + 12 + (new_block_x + 1));
-                        pmv_C_x = *mv++;
-                        pmv_C_y = *mv;
-                    }
-                }
-                else if (block_y == 0 && new_block_x == 3)
-                {
-                    avail_c = video->mbAvailC;
-                    if (avail_c)
-                    {
-                        refIdxLXC = MB_C->ref_idx_L0[2];
-                        mv = (int16*)(MB_C->mvL0 + 12);
-                        pmv_C_x = *mv++;
-                        pmv_C_y = *mv;
-                    }
-                }
-
-                if (avail_c == 0)
-                {   /* check D */
-                    if (block_x && block_y)
-                    {
-                        avail_c = 1;
-                        refIdxLXC =  currMB->ref_idx_L0[(block_y_1 & 2) + (block_x_1 >> 1)];
-                        mv = (int16*)(currMB->mvL0 + (block_y_1 << 2) + block_x_1);
-                        pmv_C_x = *mv++;
-                        pmv_C_y = *mv;
-                    }
-                    else if (block_y)
-                    {
-                        avail_c = video->mbAvailA;
-                        if (avail_c)
-                        {
-                            refIdxLXC =  MB_A->ref_idx_L0[(block_y_1 & 2) + 1];
-                            mv = (int16*)(MB_A->mvL0 + (block_y_1 << 2) + 3);
-                            pmv_C_x = *mv++;
-                            pmv_C_y = *mv;
-                        }
-                    }
-                    else if (block_x)
-                    {
-                        avail_c = video->mbAvailB;
-                        if (avail_c)
-                        {
-                            refIdxLXC = MB_B->ref_idx_L0[2 + (block_x_1 >> 1)];
-                            mv = (int16*)(MB_B->mvL0 + 12 + block_x_1);
-                            pmv_C_x = *mv++;
-                            pmv_C_y = *mv;
-                        }
-                    }
-                    else
-                    {
-                        avail_c = video->mbAvailD;
-                        if (avail_c)
-                        {
-                            refIdxLXC = MB_D->ref_idx_L0[3];
-                            mv = (int16*)(MB_D->mvL0 + 15);
-                            pmv_C_x = *mv++;
-                            pmv_C_y = *mv;
-                        }
-                    }
-                }
-            }
-
-            offset_indx = currMB->SubMbPartWidth[mbPartIdx] >> 3;
-
-            curr_ref_idx = currMB->ref_idx_L0[(block_y & 2) + (block_x >> 1)];
-
-            if (avail_a && !(avail_b || avail_c))
-            {
-                pmv_x = pmv_A_x;
-                pmv_y = pmv_A_y;
-            }
-            else if (((curr_ref_idx == refIdxLXA) + (curr_ref_idx == refIdxLXB) + (curr_ref_idx == refIdxLXC)) == 1)
-            {
-                if (curr_ref_idx == refIdxLXA)
-                {
-                    pmv_x = pmv_A_x;
-                    pmv_y = pmv_A_y;
-                }
-                else if (curr_ref_idx == refIdxLXB)
-                {
-                    pmv_x = pmv_B_x;
-                    pmv_y = pmv_B_y;
-                }
-                else
-                {
-                    pmv_x = pmv_C_x;
-                    pmv_y = pmv_C_y;
-                }
-            }
-            else
-            {
-                pmv_x = AVC_MEDIAN(pmv_A_x, pmv_B_x, pmv_C_x);
-                pmv_y = AVC_MEDIAN(pmv_A_y, pmv_B_y, pmv_C_y);
-            }
-
-            /* overwrite if special case */
-            if (currMB->NumMbPart == 2)
-            {
-                if (currMB->MbPartWidth == 16)
-                {
-                    if (mbPartIdx == 0)
-                    {
-                        if (refIdxLXB == curr_ref_idx)
-                        {
-                            pmv_x = pmv_B_x;
-                            pmv_y = pmv_B_y;
-                        }
-                    }
-                    else if (refIdxLXA == curr_ref_idx)
-                    {
-                        pmv_x = pmv_A_x;
-                        pmv_y = pmv_A_y;
-                    }
-                }
-                else
-                {
-                    if (mbPartIdx == 0)
-                    {
-                        if (refIdxLXA == curr_ref_idx)
-                        {
-                            pmv_x = pmv_A_x;
-                            pmv_y = pmv_A_y;
-                        }
-                    }
-                    else if (refIdxLXC == curr_ref_idx)
-                    {
-                        pmv_x = pmv_C_x;
-                        pmv_y = pmv_C_y;
-                    }
-                }
-            }
-
-            mv = (int16*)(currMB->mvL0 + block_x + (block_y << 2));
-
-            if (encFlag) /* calculate residual MV video->mvd_l0 */
-            {
-                video->mvd_l0[mbPartIdx][subMbPartIdx][0] = *mv++ - pmv_x;
-                video->mvd_l0[mbPartIdx][subMbPartIdx][1] = *mv++ - pmv_y;
-            }
-            else    /* calculate original MV currMB->mvL0 */
-            {
-                pmv_x += video->mvd_l0[mbPartIdx][subMbPartIdx][0];
-                pmv_y += video->mvd_l0[mbPartIdx][subMbPartIdx][1];
-
-                for (i = 0; i < nmSubMbHeight; i++)
-                {
-                    for (j = 0; j < nmSubMbWidth; j++)
-                    {
-                        *mv++ = pmv_x;
-                        *mv++ = pmv_y;
-                    }
-                    mv += (8 - (j << 1));
-                }
-            }
-        }
-        offset_MbPart_indx = currMB->MbPartWidth >> 4;
-
-    }
-}
-
-
diff --git a/media/libstagefright/codecs/avc/common/src/reflist.cpp b/media/libstagefright/codecs/avc/common/src/reflist.cpp
deleted file mode 100644
index 4ddc7dd..0000000
--- a/media/libstagefright/codecs/avc/common/src/reflist.cpp
+++ /dev/null
@@ -1,596 +0,0 @@
-/* ------------------------------------------------------------------
- * 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 "avclib_common.h"
-
-/** see subclause 8.2.4 Decoding process for reference picture lists construction. */
-OSCL_EXPORT_REF void RefListInit(AVCCommonObj *video)
-{
-    AVCSliceHeader *sliceHdr = video->sliceHdr;
-    AVCDecPicBuffer *dpb = video->decPicBuf;
-    int slice_type = video->slice_type;
-    int i, list0idx;
-
-    AVCPictureData *tmp_s;
-
-    list0idx = 0;
-
-    if (slice_type == AVC_I_SLICE)
-    {
-        video->refList0Size = 0;
-        video->refList1Size = 0;
-
-        /* we still have to calculate FrameNumWrap to make sure that all I-slice clip
-        can perform sliding_window_operation properly. */
-
-        for (i = 0; i < dpb->num_fs; i++)
-        {
-            if ((dpb->fs[i]->IsReference == 3) && (!dpb->fs[i]->IsLongTerm))
-            {
-                /* subclause 8.2.4.1 Decoding process for picture numbers. */
-                if (dpb->fs[i]->FrameNum > (int)sliceHdr->frame_num)
-                {
-                    dpb->fs[i]->FrameNumWrap = dpb->fs[i]->FrameNum - video->MaxFrameNum;
-                }
-                else
-                {
-                    dpb->fs[i]->FrameNumWrap = dpb->fs[i]->FrameNum;
-                }
-                dpb->fs[i]->frame.PicNum = dpb->fs[i]->FrameNumWrap;
-            }
-        }
-
-
-        return ;
-    }
-    if (slice_type == AVC_P_SLICE)
-    {
-        /* Calculate FrameNumWrap and PicNum */
-
-        for (i = 0; i < dpb->num_fs; i++)
-        {
-            if ((dpb->fs[i]->IsReference == 3) && (!dpb->fs[i]->IsLongTerm))
-            {
-                /* subclause 8.2.4.1 Decoding process for picture numbers. */
-                if (dpb->fs[i]->FrameNum > (int)sliceHdr->frame_num)
-                {
-                    dpb->fs[i]->FrameNumWrap = dpb->fs[i]->FrameNum - video->MaxFrameNum;
-                }
-                else
-                {
-                    dpb->fs[i]->FrameNumWrap = dpb->fs[i]->FrameNum;
-                }
-                dpb->fs[i]->frame.PicNum = dpb->fs[i]->FrameNumWrap;
-                video->RefPicList0[list0idx++] = &(dpb->fs[i]->frame);
-            }
-        }
-
-        if (list0idx == 0)
-        {
-            dpb->fs[0]->IsReference = 3;
-            video->RefPicList0[0] = &(dpb->fs[0]->frame);
-            list0idx = 1;
-        }
-        /* order list 0 by PicNum from max to min, see subclause 8.2.4.2.1 */
-        SortPicByPicNum(video->RefPicList0, list0idx);
-        video->refList0Size = list0idx;
-
-        /* long term handling */
-        for (i = 0; i < dpb->num_fs; i++)
-        {
-            if (dpb->fs[i]->IsLongTerm == 3)
-            {
-                /* subclause 8.2.4.1 Decoding process for picture numbers. */
-                dpb->fs[i]->frame.LongTermPicNum = dpb->fs[i]->LongTermFrameIdx;
-                video->RefPicList0[list0idx++] = &(dpb->fs[i]->frame);
-            }
-        }
-
-        /* order PicNum from min to max, see subclause 8.2.4.2.1  */
-        SortPicByPicNumLongTerm(&(video->RefPicList0[video->refList0Size]), list0idx - video->refList0Size);
-        video->refList0Size = list0idx;
-
-
-        video->refList1Size = 0;
-    }
-
-
-    if ((video->refList0Size == video->refList1Size) && (video->refList0Size > 1))
-    {
-        /* check if lists are identical, if yes swap first two elements of listX[1] */
-        /* last paragraph of subclause 8.2.4.2.4 */
-
-        for (i = 0; i < video->refList0Size; i++)
-        {
-            if (video->RefPicList0[i] != video->RefPicList1[i])
-            {
-                break;
-            }
-        }
-        if (i == video->refList0Size)
-        {
-            tmp_s = video->RefPicList1[0];
-            video->RefPicList1[0] = video->RefPicList1[1];
-            video->RefPicList1[1] = tmp_s;
-        }
-    }
-
-    /* set max size */
-    video->refList0Size = AVC_MIN(video->refList0Size, (int)video->sliceHdr->num_ref_idx_l0_active_minus1 + 1);
-    video->refList1Size = AVC_MIN(video->refList1Size, (int)video->sliceHdr->num_ref_idx_l1_active_minus1 + 1);
-
-    return ;
-}
-/* see subclause 8.2.4.3 */
-OSCL_EXPORT_REF AVCStatus ReOrderList(AVCCommonObj *video)
-{
-    AVCSliceHeader *sliceHdr = video->sliceHdr;
-    AVCStatus status = AVC_SUCCESS;
-    int slice_type = video->slice_type;
-
-    if (slice_type != AVC_I_SLICE)
-    {
-        if (sliceHdr->ref_pic_list_reordering_flag_l0)
-        {
-            status = ReorderRefPicList(video, 0);
-            if (status != AVC_SUCCESS)
-                return status;
-        }
-        if (video->refList0Size == 0)
-        {
-            return AVC_FAIL;
-        }
-    }
-    return status;
-}
-
-AVCStatus ReorderRefPicList(AVCCommonObj *video, int isL1)
-{
-    AVCSliceHeader *sliceHdr = video->sliceHdr;
-    AVCStatus status;
-
-    int *list_size;
-    int num_ref_idx_lX_active_minus1;
-    uint *remapping_of_pic_nums_idc;
-    int *abs_diff_pic_num_minus1;
-    int *long_term_pic_idx;
-    int i;
-    int maxPicNum, currPicNum, picNumLXNoWrap, picNumLXPred, picNumLX;
-    int refIdxLX = 0;
-    void* tmp;
-
-    if (!isL1) /* list 0 */
-    {
-        list_size = &(video->refList0Size);
-        num_ref_idx_lX_active_minus1 = sliceHdr->num_ref_idx_l0_active_minus1;
-        remapping_of_pic_nums_idc = sliceHdr->reordering_of_pic_nums_idc_l0;
-        tmp = (void*)sliceHdr->abs_diff_pic_num_minus1_l0;
-        abs_diff_pic_num_minus1 = (int*) tmp;
-        tmp = (void*)sliceHdr->long_term_pic_num_l0;
-        long_term_pic_idx = (int*) tmp;
-    }
-    else
-    {
-        list_size = &(video->refList1Size);
-        num_ref_idx_lX_active_minus1 = sliceHdr->num_ref_idx_l1_active_minus1;
-        remapping_of_pic_nums_idc = sliceHdr->reordering_of_pic_nums_idc_l1;
-        tmp = (void*) sliceHdr->abs_diff_pic_num_minus1_l1;
-        abs_diff_pic_num_minus1 = (int*) tmp;
-        tmp = (void*) sliceHdr->long_term_pic_num_l1;
-        long_term_pic_idx = (int*)tmp;
-    }
-
-    maxPicNum = video->MaxPicNum;
-    currPicNum = video->CurrPicNum;
-
-    picNumLXPred = currPicNum; /* initial value */
-
-    for (i = 0; remapping_of_pic_nums_idc[i] != 3; i++)
-    {
-        if ((remapping_of_pic_nums_idc[i] > 3) || (i >= MAX_REF_PIC_LIST_REORDERING))
-        {
-            return AVC_FAIL; /* out of range */
-        }
-        /* see subclause 8.2.4.3.1 */
-        if (remapping_of_pic_nums_idc[i] < 2)
-        {
-            if (remapping_of_pic_nums_idc[i] == 0)
-            {
-                if (picNumLXPred - (abs_diff_pic_num_minus1[i] + 1) < 0)
-                    picNumLXNoWrap = picNumLXPred - (abs_diff_pic_num_minus1[i] + 1) + maxPicNum;
-                else
-                    picNumLXNoWrap = picNumLXPred - (abs_diff_pic_num_minus1[i] + 1);
-            }
-            else /* (remapping_of_pic_nums_idc[i] == 1) */
-            {
-                if (picNumLXPred + (abs_diff_pic_num_minus1[i] + 1)  >=  maxPicNum)
-                    picNumLXNoWrap = picNumLXPred + (abs_diff_pic_num_minus1[i] + 1) - maxPicNum;
-                else
-                    picNumLXNoWrap = picNumLXPred + (abs_diff_pic_num_minus1[i] + 1);
-            }
-            picNumLXPred = picNumLXNoWrap; /* prediction for the next one */
-
-            if (picNumLXNoWrap > currPicNum)
-                picNumLX = picNumLXNoWrap - maxPicNum;
-            else
-                picNumLX = picNumLXNoWrap;
-
-            status = ReorderShortTerm(video, picNumLX, &refIdxLX, isL1);
-            if (status != AVC_SUCCESS)
-            {
-                return status;
-            }
-        }
-        else /* (remapping_of_pic_nums_idc[i] == 2), subclause 8.2.4.3.2 */
-        {
-            status = ReorderLongTerm(video, long_term_pic_idx[i], &refIdxLX, isL1);
-            if (status != AVC_SUCCESS)
-            {
-                return status;
-            }
-        }
-    }
-    /* that's a definition */
-    *list_size = num_ref_idx_lX_active_minus1 + 1;
-
-    return AVC_SUCCESS;
-}
-
-/* see subclause 8.2.4.3.1 */
-AVCStatus ReorderShortTerm(AVCCommonObj *video, int picNumLX, int *refIdxLX, int isL1)
-{
-    int cIdx, nIdx;
-    int num_ref_idx_lX_active_minus1;
-    AVCPictureData *picLX, **RefPicListX;
-
-    if (!isL1) /* list 0 */
-    {
-        RefPicListX = video->RefPicList0;
-        num_ref_idx_lX_active_minus1 = video->sliceHdr->num_ref_idx_l0_active_minus1;
-    }
-    else
-    {
-        RefPicListX = video->RefPicList1;
-        num_ref_idx_lX_active_minus1 = video->sliceHdr->num_ref_idx_l1_active_minus1;
-    }
-
-    picLX = GetShortTermPic(video, picNumLX);
-
-    if (picLX == NULL)
-    {
-        return AVC_FAIL;
-    }
-    /* Note RefPicListX has to access element number num_ref_idx_lX_active */
-    /* There could be access violation here. */
-    if (num_ref_idx_lX_active_minus1 + 1 >= MAX_REF_PIC_LIST)
-    {
-        return AVC_FAIL;
-    }
-
-    for (cIdx = num_ref_idx_lX_active_minus1 + 1; cIdx > *refIdxLX; cIdx--)
-    {
-        RefPicListX[ cIdx ] = RefPicListX[ cIdx - 1];
-    }
-
-    RefPicListX[(*refIdxLX)++ ] = picLX;
-
-    nIdx = *refIdxLX;
-
-    for (cIdx = *refIdxLX; cIdx <= num_ref_idx_lX_active_minus1 + 1; cIdx++)
-    {
-        if (RefPicListX[ cIdx ])
-        {
-            if ((RefPicListX[ cIdx ]->isLongTerm) || ((int)RefPicListX[ cIdx ]->PicNum != picNumLX))
-            {
-                RefPicListX[ nIdx++ ] = RefPicListX[ cIdx ];
-            }
-        }
-    }
-    return AVC_SUCCESS;
-}
-
-/* see subclause 8.2.4.3.2 */
-AVCStatus ReorderLongTerm(AVCCommonObj *video, int LongTermPicNum, int *refIdxLX, int isL1)
-{
-    AVCPictureData **RefPicListX;
-    int num_ref_idx_lX_active_minus1;
-    int cIdx, nIdx;
-    AVCPictureData *picLX;
-
-    if (!isL1) /* list 0 */
-    {
-        RefPicListX = video->RefPicList0;
-        num_ref_idx_lX_active_minus1 = video->sliceHdr->num_ref_idx_l0_active_minus1;
-    }
-    else
-    {
-        RefPicListX = video->RefPicList1;
-        num_ref_idx_lX_active_minus1 = video->sliceHdr->num_ref_idx_l1_active_minus1;
-    }
-
-    picLX = GetLongTermPic(video, LongTermPicNum);
-    if (picLX == NULL)
-    {
-        return AVC_FAIL;
-    }
-    /* Note RefPicListX has to access element number num_ref_idx_lX_active */
-    /* There could be access violation here. */
-    if (num_ref_idx_lX_active_minus1 + 1 >= MAX_REF_PIC_LIST)
-    {
-        return AVC_FAIL;
-    }
-    for (cIdx = num_ref_idx_lX_active_minus1 + 1; cIdx > *refIdxLX; cIdx--)
-        RefPicListX[ cIdx ] = RefPicListX[ cIdx - 1];
-
-    RefPicListX[(*refIdxLX)++ ] = picLX;
-
-    nIdx = *refIdxLX;
-
-    for (cIdx = *refIdxLX; cIdx <= num_ref_idx_lX_active_minus1 + 1; cIdx++)
-    {
-        if ((!RefPicListX[ cIdx ]->isLongTerm) || ((int)RefPicListX[ cIdx ]->LongTermPicNum != LongTermPicNum))
-        {
-            RefPicListX[ nIdx++ ] = RefPicListX[ cIdx ];
-        }
-    }
-    return AVC_SUCCESS;
-}
-
-
-AVCPictureData*  GetShortTermPic(AVCCommonObj *video, int picNum)
-{
-    int i;
-    AVCDecPicBuffer *dpb = video->decPicBuf;
-
-    for (i = 0; i < dpb->num_fs; i++)
-    {
-
-        if (dpb->fs[i]->IsReference == 3)
-        {
-            if ((dpb->fs[i]->frame.isLongTerm == FALSE) && (dpb->fs[i]->frame.PicNum == picNum))
-            {
-                return &(dpb->fs[i]->frame);
-            }
-        }
-
-    }
-
-    return NULL;
-}
-
-AVCPictureData*  GetLongTermPic(AVCCommonObj *video, int LongtermPicNum)
-{
-    AVCDecPicBuffer *dpb = video->decPicBuf;
-    int i;
-
-    for (i = 0; i < dpb->num_fs; i++)
-    {
-
-        if (dpb->fs[i]->IsReference == 3)
-        {
-            if ((dpb->fs[i]->frame.isLongTerm == TRUE) && (dpb->fs[i]->frame.LongTermPicNum == LongtermPicNum))
-            {
-                return &(dpb->fs[i]->frame);
-            }
-        }
-
-    }
-    return NULL;
-}
-
-int is_short_ref(AVCPictureData *s)
-{
-    return ((s->isReference) && !(s->isLongTerm));
-}
-
-int is_long_ref(AVCPictureData *s)
-{
-    return ((s->isReference) && (s->isLongTerm));
-}
-
-
-/* sort by PicNum, descending order */
-void SortPicByPicNum(AVCPictureData *data[], int num)
-{
-    int i, j;
-    AVCPictureData *temp;
-
-    for (i = 0; i < num - 1; i++)
-    {
-        for (j = i + 1; j < num; j++)
-        {
-            if (data[j]->PicNum > data[i]->PicNum)
-            {
-                temp = data[j];
-                data[j] = data[i];
-                data[i] = temp;
-            }
-        }
-    }
-
-    return ;
-}
-
-/* sort by PicNum, ascending order */
-void SortPicByPicNumLongTerm(AVCPictureData *data[], int num)
-{
-    int i, j;
-    AVCPictureData *temp;
-
-    for (i = 0; i < num - 1; i++)
-    {
-        for (j = i + 1; j < num; j++)
-        {
-            if (data[j]->LongTermPicNum < data[i]->LongTermPicNum)
-            {
-                temp = data[j];
-                data[j] = data[i];
-                data[i] = temp;
-            }
-        }
-    }
-
-    return ;
-}
-
-
-/* sort by FrameNumWrap, descending order */
-void SortFrameByFrameNumWrap(AVCFrameStore *data[], int num)
-{
-    int i, j;
-    AVCFrameStore *temp;
-
-    for (i = 0; i < num - 1; i++)
-    {
-        for (j = i + 1; j < num; j++)
-        {
-            if (data[j]->FrameNumWrap > data[i]->FrameNumWrap)
-            {
-                temp = data[j];
-                data[j] = data[i];
-                data[i] = temp;
-            }
-        }
-    }
-
-    return ;
-}
-
-/* sort frames by LongTermFrameIdx, ascending order */
-void SortFrameByLTFrameIdx(AVCFrameStore *data[], int num)
-{
-    int i, j;
-    AVCFrameStore *temp;
-
-    for (i = 0; i < num - 1; i++)
-    {
-        for (j = i + 1; j < num; j++)
-        {
-            if (data[j]->LongTermFrameIdx < data[i]->LongTermFrameIdx)
-            {
-                temp = data[j];
-                data[j] = data[i];
-                data[i] = temp;
-            }
-        }
-    }
-
-    return ;
-}
-
-/* sort PictureData by POC in descending order */
-void SortPicByPOC(AVCPictureData *data[], int num, int descending)
-{
-    int i, j;
-    AVCPictureData *temp;
-
-    if (descending)
-    {
-        for (i = 0; i < num - 1; i++)
-        {
-            for (j = i + 1; j < num; j++)
-            {
-                if (data[j]->PicOrderCnt > data[i]->PicOrderCnt)
-                {
-                    temp = data[j];
-                    data[j] = data[i];
-                    data[i] = temp;
-                }
-            }
-        }
-    }
-    else
-    {
-        for (i = 0; i < num - 1; i++)
-        {
-            for (j = i + 1; j < num; j++)
-            {
-                if (data[j]->PicOrderCnt < data[i]->PicOrderCnt)
-                {
-                    temp = data[j];
-                    data[j] = data[i];
-                    data[i] = temp;
-                }
-            }
-        }
-    }
-    return ;
-}
-
-/* sort PictureData by LongTermPicNum in ascending order */
-void SortPicByLTPicNum(AVCPictureData *data[], int num)
-{
-    int i, j;
-    AVCPictureData *temp;
-
-    for (i = 0; i < num - 1; i++)
-    {
-        for (j = i + 1; j < num; j++)
-        {
-            if (data[j]->LongTermPicNum < data[i]->LongTermPicNum)
-            {
-                temp = data[j];
-                data[j] = data[i];
-                data[i] = temp;
-            }
-        }
-    }
-
-    return ;
-}
-
-/* sort by PicOrderCnt, descending order */
-void SortFrameByPOC(AVCFrameStore *data[], int num, int descending)
-{
-    int i, j;
-    AVCFrameStore *temp;
-
-    if (descending)
-    {
-        for (i = 0; i < num - 1; i++)
-        {
-            for (j = i + 1; j < num; j++)
-            {
-                if (data[j]->PicOrderCnt > data[i]->PicOrderCnt)
-                {
-                    temp = data[j];
-                    data[j] = data[i];
-                    data[i] = temp;
-                }
-            }
-        }
-    }
-    else
-    {
-        for (i = 0; i < num - 1; i++)
-        {
-            for (j = i + 1; j < num; j++)
-            {
-                if (data[j]->PicOrderCnt < data[i]->PicOrderCnt)
-                {
-                    temp = data[j];
-                    data[j] = data[i];
-                    data[i] = temp;
-                }
-            }
-        }
-    }
-
-    return ;
-}
-
-
diff --git a/media/libstagefright/codecs/avc/enc/Android.mk b/media/libstagefright/codecs/avc/enc/Android.mk
deleted file mode 100644
index e451f30..0000000
--- a/media/libstagefright/codecs/avc/enc/Android.mk
+++ /dev/null
@@ -1,106 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES := \
-    src/avcenc_api.cpp \
-    src/bitstream_io.cpp \
-    src/block.cpp \
-    src/findhalfpel.cpp \
-    src/header.cpp \
-    src/init.cpp \
-    src/intra_est.cpp \
-    src/motion_comp.cpp \
-    src/motion_est.cpp \
-    src/rate_control.cpp \
-    src/residual.cpp \
-    src/sad.cpp \
-    src/sad_halfpel.cpp \
-    src/slice.cpp \
-    src/vlc_encode.cpp
-
-
-LOCAL_MODULE := libstagefright_avcenc
-
-LOCAL_C_INCLUDES := \
-    $(LOCAL_PATH)/src \
-    $(LOCAL_PATH)/../common/include \
-    $(TOP)/frameworks/av/media/libstagefright/include \
-    $(TOP)/frameworks/native/include/media/openmax
-
-LOCAL_CFLAGS := \
-    -DOSCL_IMPORT_REF= -D"OSCL_UNUSED_ARG(x)=(void)(x)" -DOSCL_EXPORT_REF=
-
-LOCAL_CFLAGS += -Werror
-LOCAL_SANITIZE := signed-integer-overflow
-
-include $(BUILD_STATIC_LIBRARY)
-
-################################################################################
-
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES := \
-        SoftAVCEncoder.cpp
-
-LOCAL_C_INCLUDES := \
-        frameworks/av/media/libstagefright/include \
-        frameworks/native/include/media/hardware \
-        frameworks/native/include/media/openmax \
-        $(LOCAL_PATH)/src \
-        $(LOCAL_PATH)/include \
-        $(LOCAL_PATH)/../common/include \
-        $(LOCAL_PATH)/../common
-
-LOCAL_CFLAGS := \
-    -DOSCL_IMPORT_REF= -D"OSCL_UNUSED_ARG(x)=(void)(x)" -DOSCL_EXPORT_REF=
-
-
-LOCAL_STATIC_LIBRARIES := \
-        libstagefright_avcenc
-
-LOCAL_SHARED_LIBRARIES := \
-        libmedia \
-        libstagefright_avc_common \
-        libstagefright_foundation \
-        libstagefright_omx \
-        libutils \
-        liblog \
-
-
-LOCAL_MODULE := libstagefright_soft_h264enc
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_CFLAGS += -Werror
-LOCAL_SANITIZE := signed-integer-overflow cfi
-LOCAL_SANITIZE_DIAG := cfi
-
-include $(BUILD_SHARED_LIBRARY)
-
-################################################################################
-
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES := \
-        test/h264_enc_test.cpp
-
-LOCAL_C_INCLUDES := \
-        $(LOCAL_PATH)/src \
-        $(LOCAL_PATH)/include \
-        $(LOCAL_PATH)/../common/include \
-        $(LOCAL_PATH)/../common
-
-LOCAL_CFLAGS := \
-    -DOSCL_IMPORT_REF= -DOSCL_UNUSED_ARG= -DOSCL_EXPORT_REF=
-LOCAL_SANITIZE := signed-integer-overflow
-
-LOCAL_STATIC_LIBRARIES := \
-        libstagefright_avcenc
-
-LOCAL_SHARED_LIBRARIES := \
-        libstagefright_avc_common
-
-LOCAL_MODULE := libstagefright_h264enc_test
-
-LOCAL_MODULE_TAGS := tests
-
-include $(BUILD_EXECUTABLE)
diff --git a/media/libstagefright/codecs/avc/enc/MODULE_LICENSE_APACHE2 b/media/libstagefright/codecs/avc/enc/MODULE_LICENSE_APACHE2
deleted file mode 100644
index e69de29..0000000
--- a/media/libstagefright/codecs/avc/enc/MODULE_LICENSE_APACHE2
+++ /dev/null
diff --git a/media/libstagefright/codecs/avc/enc/NOTICE b/media/libstagefright/codecs/avc/enc/NOTICE
deleted file mode 100644
index c5b1efa..0000000
--- a/media/libstagefright/codecs/avc/enc/NOTICE
+++ /dev/null
@@ -1,190 +0,0 @@
-
-   Copyright (c) 2005-2008, 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.
-
-   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.
-
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
diff --git a/media/libstagefright/codecs/avc/enc/SoftAVCEncoder.cpp b/media/libstagefright/codecs/avc/enc/SoftAVCEncoder.cpp
deleted file mode 100644
index cce6d15..0000000
--- a/media/libstagefright/codecs/avc/enc/SoftAVCEncoder.cpp
+++ /dev/null
@@ -1,734 +0,0 @@
-/*
- * Copyright (C) 2012 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 "SoftAVCEncoder"
-#include <utils/Log.h>
-#include <utils/misc.h>
-
-#include "avcenc_api.h"
-#include "avcenc_int.h"
-#include "OMX_Video.h"
-
-#include <HardwareAPI.h>
-#include <MetadataBufferType.h>
-#include <media/stagefright/foundation/ADebug.h>
-#include <media/stagefright/foundation/AUtils.h>
-#include <media/stagefright/MediaDefs.h>
-#include <media/stagefright/MediaErrors.h>
-#include <media/stagefright/MetaData.h>
-#include <media/stagefright/Utils.h>
-#include <ui/Rect.h>
-#include <ui/GraphicBufferMapper.h>
-
-#include "SoftAVCEncoder.h"
-
-#if LOG_NDEBUG
-#define UNUSED_UNLESS_VERBOSE(x) (void)(x)
-#else
-#define UNUSED_UNLESS_VERBOSE(x)
-#endif
-
-namespace android {
-
-template<class T>
-static void InitOMXParams(T *params) {
-    params->nSize = sizeof(T);
-    params->nVersion.s.nVersionMajor = 1;
-    params->nVersion.s.nVersionMinor = 0;
-    params->nVersion.s.nRevision = 0;
-    params->nVersion.s.nStep = 0;
-}
-
-static const CodecProfileLevel kProfileLevels[] = {
-    { OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel2  },
-};
-
-typedef struct LevelConversion {
-    OMX_U32 omxLevel;
-    AVCLevel avcLevel;
-    uint32_t maxMacroBlocks;
-} LevelConcersion;
-
-static LevelConversion ConversionTable[] = {
-    { OMX_VIDEO_AVCLevel1,  AVC_LEVEL1_B, 99 },
-    { OMX_VIDEO_AVCLevel1b, AVC_LEVEL1,   99 },
-    { OMX_VIDEO_AVCLevel11, AVC_LEVEL1_1, 396 },
-    { OMX_VIDEO_AVCLevel12, AVC_LEVEL1_2, 396 },
-    { OMX_VIDEO_AVCLevel13, AVC_LEVEL1_3, 396 },
-    { OMX_VIDEO_AVCLevel2,  AVC_LEVEL2,   396 },
-#if 0
-    // encoding speed is very poor if video resolution
-    // is higher than CIF or if level is higher than 2
-    { OMX_VIDEO_AVCLevel21, AVC_LEVEL2_1, 792 },
-    { OMX_VIDEO_AVCLevel22, AVC_LEVEL2_2, 1620 },
-    { OMX_VIDEO_AVCLevel3,  AVC_LEVEL3,   1620 },
-    { OMX_VIDEO_AVCLevel31, AVC_LEVEL3_1, 3600 },
-    { OMX_VIDEO_AVCLevel32, AVC_LEVEL3_2, 5120 },
-    { OMX_VIDEO_AVCLevel4,  AVC_LEVEL4,   8192 },
-    { OMX_VIDEO_AVCLevel41, AVC_LEVEL4_1, 8192 },
-    { OMX_VIDEO_AVCLevel42, AVC_LEVEL4_2, 8704 },
-    { OMX_VIDEO_AVCLevel5,  AVC_LEVEL5,   22080 },
-    { OMX_VIDEO_AVCLevel51, AVC_LEVEL5_1, 36864 },
-#endif
-};
-
-static status_t ConvertOmxAvcLevelToAvcSpecLevel(
-        OMX_U32 omxLevel, AVCLevel *avcLevel) {
-    for (size_t i = 0, n = sizeof(ConversionTable)/sizeof(ConversionTable[0]);
-        i < n; ++i) {
-        if (omxLevel == ConversionTable[i].omxLevel) {
-            *avcLevel = ConversionTable[i].avcLevel;
-            return OK;
-        }
-    }
-
-    ALOGE("ConvertOmxAvcLevelToAvcSpecLevel: %d level not supported",
-            (int32_t)omxLevel);
-
-    return BAD_VALUE;
-}
-
-static status_t ConvertAvcSpecLevelToOmxAvcLevel(
-    AVCLevel avcLevel, OMX_U32 *omxLevel) {
-    for (size_t i = 0, n = sizeof(ConversionTable)/sizeof(ConversionTable[0]);
-        i < n; ++i) {
-        if (avcLevel == ConversionTable[i].avcLevel) {
-            *omxLevel = ConversionTable[i].omxLevel;
-            return OK;
-        }
-    }
-
-    ALOGE("ConvertAvcSpecLevelToOmxAvcLevel: %d level not supported",
-            (int32_t) avcLevel);
-
-    return BAD_VALUE;
-}
-
-static void* MallocWrapper(
-        void * /* userData */, int32_t size, int32_t /* attrs */) {
-    void *ptr = malloc(size);
-    if (ptr)
-        memset(ptr, 0, size);
-    return ptr;
-}
-
-static void FreeWrapper(void * /* userData */, void* ptr) {
-    free(ptr);
-}
-
-static int32_t DpbAllocWrapper(void *userData,
-        unsigned int sizeInMbs, unsigned int numBuffers) {
-    SoftAVCEncoder *encoder = static_cast<SoftAVCEncoder *>(userData);
-    CHECK(encoder != NULL);
-    return encoder->allocOutputBuffers(sizeInMbs, numBuffers);
-}
-
-static int32_t BindFrameWrapper(
-        void *userData, int32_t index, uint8_t **yuv) {
-    SoftAVCEncoder *encoder = static_cast<SoftAVCEncoder *>(userData);
-    CHECK(encoder != NULL);
-    return encoder->bindOutputBuffer(index, yuv);
-}
-
-static void UnbindFrameWrapper(void *userData, int32_t index) {
-    SoftAVCEncoder *encoder = static_cast<SoftAVCEncoder *>(userData);
-    CHECK(encoder != NULL);
-    return encoder->unbindOutputBuffer(index);
-}
-
-SoftAVCEncoder::SoftAVCEncoder(
-            const char *name,
-            const OMX_CALLBACKTYPE *callbacks,
-            OMX_PTR appData,
-            OMX_COMPONENTTYPE **component)
-    : SoftVideoEncoderOMXComponent(
-            name, "video_encoder.avc", OMX_VIDEO_CodingAVC,
-            kProfileLevels, NELEM(kProfileLevels),
-            176 /* width */, 144 /* height */,
-            callbacks, appData, component),
-      mIDRFrameRefreshIntervalInSec(1),
-      mAVCEncProfile(AVC_BASELINE),
-      mAVCEncLevel(AVC_LEVEL2),
-      mNumInputFrames(-1),
-      mPrevTimestampUs(-1),
-      mStarted(false),
-      mSawInputEOS(false),
-      mSignalledError(false),
-      mHandle(new tagAVCHandle),
-      mEncParams(new tagAVCEncParam),
-      mInputFrameData(NULL),
-      mSliceGroup(NULL) {
-
-    const size_t kOutputBufferSize =
-        320 * ConversionTable[NELEM(ConversionTable) - 1].maxMacroBlocks;
-
-    initPorts(
-            kNumBuffers, kNumBuffers, kOutputBufferSize,
-            MEDIA_MIMETYPE_VIDEO_AVC, 2 /* minCompressionRatio */);
-
-    ALOGI("Construct SoftAVCEncoder");
-}
-
-SoftAVCEncoder::~SoftAVCEncoder() {
-    ALOGV("Destruct SoftAVCEncoder");
-    releaseEncoder();
-    List<BufferInfo *> &outQueue = getPortQueue(1);
-    List<BufferInfo *> &inQueue = getPortQueue(0);
-    CHECK(outQueue.empty());
-    CHECK(inQueue.empty());
-}
-
-OMX_ERRORTYPE SoftAVCEncoder::initEncParams() {
-    CHECK(mHandle != NULL);
-    memset(mHandle, 0, sizeof(tagAVCHandle));
-    mHandle->AVCObject = NULL;
-    mHandle->userData = this;
-    mHandle->CBAVC_DPBAlloc = DpbAllocWrapper;
-    mHandle->CBAVC_FrameBind = BindFrameWrapper;
-    mHandle->CBAVC_FrameUnbind = UnbindFrameWrapper;
-    mHandle->CBAVC_Malloc = MallocWrapper;
-    mHandle->CBAVC_Free = FreeWrapper;
-
-    CHECK(mEncParams != NULL);
-    memset(mEncParams, 0, sizeof(*mEncParams));
-    mEncParams->rate_control = AVC_ON;
-    mEncParams->initQP = 0;
-    mEncParams->init_CBP_removal_delay = 1600;
-
-    mEncParams->intramb_refresh = 0;
-    mEncParams->auto_scd = AVC_ON;
-    mEncParams->out_of_band_param_set = AVC_ON;
-    mEncParams->poc_type = 2;
-    mEncParams->log2_max_poc_lsb_minus_4 = 12;
-    mEncParams->delta_poc_zero_flag = 0;
-    mEncParams->offset_poc_non_ref = 0;
-    mEncParams->offset_top_bottom = 0;
-    mEncParams->num_ref_in_cycle = 0;
-    mEncParams->offset_poc_ref = NULL;
-
-    mEncParams->num_ref_frame = 1;
-    mEncParams->num_slice_group = 1;
-    mEncParams->fmo_type = 0;
-
-    mEncParams->db_filter = AVC_ON;
-    mEncParams->disable_db_idc = 0;
-
-    mEncParams->alpha_offset = 0;
-    mEncParams->beta_offset = 0;
-    mEncParams->constrained_intra_pred = AVC_OFF;
-
-    mEncParams->data_par = AVC_OFF;
-    mEncParams->fullsearch = AVC_OFF;
-    mEncParams->search_range = 16;
-    mEncParams->sub_pel = AVC_OFF;
-    mEncParams->submb_pred = AVC_OFF;
-    mEncParams->rdopt_mode = AVC_OFF;
-    mEncParams->bidir_pred = AVC_OFF;
-
-    mEncParams->use_overrun_buffer = AVC_OFF;
-
-    if (mColorFormat != OMX_COLOR_FormatYUV420Planar || mInputDataIsMeta) {
-        // Color conversion is needed.
-        free(mInputFrameData);
-        if (((uint64_t)mWidth * mHeight) > ((uint64_t)INT32_MAX / 3)) {
-            ALOGE("Buffer size is too big.");
-            return OMX_ErrorUndefined;
-        }
-        mInputFrameData =
-            (uint8_t *) malloc((mWidth * mHeight * 3 ) >> 1);
-        CHECK(mInputFrameData != NULL);
-    }
-
-    // PV's AVC encoder requires the video dimension of multiple
-    if (mWidth % 16 != 0 || mHeight % 16 != 0) {
-        ALOGE("Video frame size %dx%d must be a multiple of 16",
-            mWidth, mHeight);
-        return OMX_ErrorBadParameter;
-    }
-
-    mEncParams->width = mWidth;
-    mEncParams->height = mHeight;
-    mEncParams->bitrate = mBitrate;
-    mEncParams->frame_rate = (1000 * mFramerate) >> 16;  // In frames/ms!, mFramerate is in Q16
-    mEncParams->CPB_size = (uint32_t) (mBitrate >> 1);
-
-    int32_t nMacroBlocks = divUp(mWidth, 16) * divUp(mHeight, 16);
-    CHECK(mSliceGroup == NULL);
-    if ((size_t)nMacroBlocks > SIZE_MAX / sizeof(uint32_t)) {
-        ALOGE("requested memory size is too big.");
-        return OMX_ErrorUndefined;
-    }
-    mSliceGroup = (uint32_t *) malloc(sizeof(uint32_t) * nMacroBlocks);
-    CHECK(mSliceGroup != NULL);
-    for (int ii = 0, idx = 0; ii < nMacroBlocks; ++ii) {
-        mSliceGroup[ii] = idx++;
-        if (idx >= mEncParams->num_slice_group) {
-            idx = 0;
-        }
-    }
-    mEncParams->slice_group = mSliceGroup;
-
-    // Set IDR frame refresh interval
-    if (mIDRFrameRefreshIntervalInSec < 0) {
-        mEncParams->idr_period = -1;
-    } else if (mIDRFrameRefreshIntervalInSec == 0) {
-        mEncParams->idr_period = 1;  // All I frames
-    } else {
-        mEncParams->idr_period =
-            (mIDRFrameRefreshIntervalInSec * mFramerate) >> 16; // mFramerate is in Q16
-    }
-
-    // Set profile and level
-    mEncParams->profile = mAVCEncProfile;
-    mEncParams->level = mAVCEncLevel;
-
-    return OMX_ErrorNone;
-}
-
-OMX_ERRORTYPE SoftAVCEncoder::initEncoder() {
-    CHECK(!mStarted);
-
-    OMX_ERRORTYPE errType = OMX_ErrorNone;
-    if (OMX_ErrorNone != (errType = initEncParams())) {
-        ALOGE("Failed to initialized encoder params");
-        mSignalledError = true;
-        notify(OMX_EventError, OMX_ErrorUndefined, 0, 0);
-        return errType;
-    }
-
-    AVCEnc_Status err;
-    err = PVAVCEncInitialize(mHandle, mEncParams, NULL, NULL);
-    if (err != AVCENC_SUCCESS) {
-        ALOGE("Failed to initialize the encoder: %d", err);
-        mSignalledError = true;
-        notify(OMX_EventError, OMX_ErrorUndefined, 0, 0);
-        return OMX_ErrorUndefined;
-    }
-
-    mNumInputFrames = -2;  // 1st two buffers contain SPS and PPS
-    mSpsPpsHeaderReceived = false;
-    mReadyForNextFrame = true;
-    mIsIDRFrame = false;
-    mStarted = true;
-
-    return OMX_ErrorNone;
-}
-
-OMX_ERRORTYPE SoftAVCEncoder::releaseEncoder() {
-    if (!mStarted) {
-        return OMX_ErrorNone;
-    }
-
-    PVAVCCleanUpEncoder(mHandle);
-    releaseOutputBuffers();
-
-    free(mInputFrameData);
-    mInputFrameData = NULL;
-
-    free(mSliceGroup);
-    mSliceGroup = NULL;
-
-    delete mEncParams;
-    mEncParams = NULL;
-
-    delete mHandle;
-    mHandle = NULL;
-
-    mStarted = false;
-
-    return OMX_ErrorNone;
-}
-
-void SoftAVCEncoder::releaseOutputBuffers() {
-    for (size_t i = 0; i < mOutputBuffers.size(); ++i) {
-        MediaBuffer *buffer = mOutputBuffers.editItemAt(i);
-        buffer->setObserver(NULL);
-        buffer->release();
-    }
-    mOutputBuffers.clear();
-}
-
-OMX_ERRORTYPE SoftAVCEncoder::internalGetParameter(
-        OMX_INDEXTYPE index, OMX_PTR params) {
-    switch (index) {
-        case OMX_IndexParamVideoBitrate:
-        {
-            OMX_VIDEO_PARAM_BITRATETYPE *bitRate =
-                (OMX_VIDEO_PARAM_BITRATETYPE *) params;
-
-            if (!isValidOMXParam(bitRate)) {
-                return OMX_ErrorBadParameter;
-            }
-
-            if (bitRate->nPortIndex != 1) {
-                return OMX_ErrorUndefined;
-            }
-
-            bitRate->eControlRate = OMX_Video_ControlRateVariable;
-            bitRate->nTargetBitrate = mBitrate;
-            return OMX_ErrorNone;
-        }
-
-        case OMX_IndexParamVideoAvc:
-        {
-            OMX_VIDEO_PARAM_AVCTYPE *avcParams =
-                (OMX_VIDEO_PARAM_AVCTYPE *)params;
-
-            if (!isValidOMXParam(avcParams)) {
-                return OMX_ErrorBadParameter;
-            }
-
-            if (avcParams->nPortIndex != 1) {
-                return OMX_ErrorUndefined;
-            }
-
-            avcParams->eProfile = OMX_VIDEO_AVCProfileBaseline;
-            OMX_U32 omxLevel = AVC_LEVEL2;
-            if (OMX_ErrorNone !=
-                ConvertAvcSpecLevelToOmxAvcLevel(mAVCEncLevel, &omxLevel)) {
-                return OMX_ErrorUndefined;
-            }
-
-            avcParams->eLevel = (OMX_VIDEO_AVCLEVELTYPE) omxLevel;
-            avcParams->nRefFrames = 1;
-            avcParams->nBFrames = 0;
-            avcParams->bUseHadamard = OMX_TRUE;
-            avcParams->nAllowedPictureTypes =
-                    (OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP);
-            avcParams->nRefIdx10ActiveMinus1 = 0;
-            avcParams->nRefIdx11ActiveMinus1 = 0;
-            avcParams->bWeightedPPrediction = OMX_FALSE;
-            avcParams->bEntropyCodingCABAC = OMX_FALSE;
-            avcParams->bconstIpred = OMX_FALSE;
-            avcParams->bDirect8x8Inference = OMX_FALSE;
-            avcParams->bDirectSpatialTemporal = OMX_FALSE;
-            avcParams->nCabacInitIdc = 0;
-            return OMX_ErrorNone;
-        }
-
-        default:
-            return SoftVideoEncoderOMXComponent::internalGetParameter(index, params);
-    }
-}
-
-OMX_ERRORTYPE SoftAVCEncoder::internalSetParameter(
-        OMX_INDEXTYPE index, const OMX_PTR params) {
-    int32_t indexFull = index;
-
-    switch (indexFull) {
-        case OMX_IndexParamVideoBitrate:
-        {
-            OMX_VIDEO_PARAM_BITRATETYPE *bitRate =
-                (OMX_VIDEO_PARAM_BITRATETYPE *) params;
-
-            if (!isValidOMXParam(bitRate)) {
-                return OMX_ErrorBadParameter;
-            }
-
-            if (bitRate->nPortIndex != 1 ||
-                bitRate->eControlRate != OMX_Video_ControlRateVariable) {
-                return OMX_ErrorUndefined;
-            }
-
-            mBitrate = bitRate->nTargetBitrate;
-            return OMX_ErrorNone;
-        }
-
-        case OMX_IndexParamVideoAvc:
-        {
-            OMX_VIDEO_PARAM_AVCTYPE *avcType =
-                (OMX_VIDEO_PARAM_AVCTYPE *)params;
-
-            if (!isValidOMXParam(avcType)) {
-                return OMX_ErrorBadParameter;
-            }
-
-            if (avcType->nPortIndex != 1) {
-                return OMX_ErrorUndefined;
-            }
-
-            // PV's AVC encoder only supports baseline profile
-            if (avcType->eProfile != OMX_VIDEO_AVCProfileBaseline ||
-                avcType->nRefFrames != 1 ||
-                avcType->nBFrames != 0 ||
-                avcType->bUseHadamard != OMX_TRUE ||
-                (avcType->nAllowedPictureTypes & OMX_VIDEO_PictureTypeB) != 0 ||
-                avcType->nRefIdx10ActiveMinus1 != 0 ||
-                avcType->nRefIdx11ActiveMinus1 != 0 ||
-                avcType->bWeightedPPrediction != OMX_FALSE ||
-                avcType->bEntropyCodingCABAC != OMX_FALSE ||
-                avcType->bconstIpred != OMX_FALSE ||
-                avcType->bDirect8x8Inference != OMX_FALSE ||
-                avcType->bDirectSpatialTemporal != OMX_FALSE ||
-                avcType->nCabacInitIdc != 0) {
-                return OMX_ErrorUndefined;
-            }
-
-            if (OK != ConvertOmxAvcLevelToAvcSpecLevel(avcType->eLevel, &mAVCEncLevel)) {
-                return OMX_ErrorUndefined;
-            }
-
-            return OMX_ErrorNone;
-        }
-
-        default:
-            return SoftVideoEncoderOMXComponent::internalSetParameter(index, params);
-    }
-}
-
-void SoftAVCEncoder::onQueueFilled(OMX_U32 /* portIndex */) {
-    if (mSignalledError || mSawInputEOS) {
-        return;
-    }
-
-    if (!mStarted) {
-        if (OMX_ErrorNone != initEncoder()) {
-            return;
-        }
-    }
-
-    List<BufferInfo *> &inQueue = getPortQueue(0);
-    List<BufferInfo *> &outQueue = getPortQueue(1);
-
-    while (!mSawInputEOS && !inQueue.empty() && !outQueue.empty()) {
-        BufferInfo *inInfo = *inQueue.begin();
-        OMX_BUFFERHEADERTYPE *inHeader = inInfo->mHeader;
-        BufferInfo *outInfo = *outQueue.begin();
-        OMX_BUFFERHEADERTYPE *outHeader = outInfo->mHeader;
-
-        outHeader->nTimeStamp = 0;
-        outHeader->nFlags = 0;
-        outHeader->nOffset = 0;
-        outHeader->nFilledLen = 0;
-        outHeader->nOffset = 0;
-
-        uint8_t *outPtr = (uint8_t *) outHeader->pBuffer;
-        uint32_t dataLength = outHeader->nAllocLen;
-
-        if (!mSpsPpsHeaderReceived && mNumInputFrames < 0) {
-            // 4 bytes are reserved for holding the start code 0x00000001
-            // of the sequence parameter set at the beginning.
-            outPtr += 4;
-            dataLength -= 4;
-        }
-
-        int32_t type;
-        AVCEnc_Status encoderStatus = AVCENC_SUCCESS;
-
-        // Combine SPS and PPS and place them in the very first output buffer
-        // SPS and PPS are separated by start code 0x00000001
-        // Assume that we have exactly one SPS and exactly one PPS.
-        while (!mSpsPpsHeaderReceived && mNumInputFrames <= 0) {
-            encoderStatus = PVAVCEncodeNAL(mHandle, outPtr, &dataLength, &type);
-            if (encoderStatus == AVCENC_WRONG_STATE) {
-                mSpsPpsHeaderReceived = true;
-                CHECK_EQ(0, mNumInputFrames);  // 1st video frame is 0
-                outHeader->nFlags = OMX_BUFFERFLAG_CODECCONFIG;
-                outQueue.erase(outQueue.begin());
-                outInfo->mOwnedByUs = false;
-                notifyFillBufferDone(outHeader);
-                return;
-            } else {
-                switch (type) {
-                    case AVC_NALTYPE_SPS:
-                        ++mNumInputFrames;
-                        memcpy((uint8_t *)outHeader->pBuffer, "\x00\x00\x00\x01", 4);
-                        outHeader->nFilledLen = 4 + dataLength;
-                        outPtr += (dataLength + 4);  // 4 bytes for next start code
-                        dataLength = outHeader->nAllocLen - outHeader->nFilledLen;
-                        break;
-                    default:
-                        CHECK_EQ(AVC_NALTYPE_PPS, type);
-                        ++mNumInputFrames;
-                        memcpy((uint8_t *) outHeader->pBuffer + outHeader->nFilledLen,
-                                "\x00\x00\x00\x01", 4);
-                        outHeader->nFilledLen += (dataLength + 4);
-                        outPtr += (dataLength + 4);
-                        break;
-                }
-            }
-        }
-
-        // Get next input video frame
-        if (mReadyForNextFrame) {
-            // Save the input buffer info so that it can be
-            // passed to an output buffer
-            InputBufferInfo info;
-            info.mTimeUs = inHeader->nTimeStamp;
-            info.mFlags = inHeader->nFlags;
-            mInputBufferInfoVec.push(info);
-            mPrevTimestampUs = inHeader->nTimeStamp;
-
-            if (inHeader->nFlags & OMX_BUFFERFLAG_EOS) {
-                mSawInputEOS = true;
-            }
-
-            if (inHeader->nFilledLen > 0) {
-                AVCFrameIO videoInput;
-                memset(&videoInput, 0, sizeof(videoInput));
-                videoInput.height = align(mHeight, 16);
-                videoInput.pitch = align(mWidth, 16);
-                videoInput.coding_timestamp = (inHeader->nTimeStamp + 500) / 1000;  // in ms
-                const uint8_t *inputData = NULL;
-                if (mInputDataIsMeta) {
-                    inputData =
-                        extractGraphicBuffer(
-                                mInputFrameData, (mWidth * mHeight * 3) >> 1,
-                                inHeader->pBuffer + inHeader->nOffset, inHeader->nFilledLen,
-                                mWidth, mHeight);
-                    if (inputData == NULL) {
-                        ALOGE("Unable to extract gralloc buffer in metadata mode");
-                        mSignalledError = true;
-                        notify(OMX_EventError, OMX_ErrorUndefined, 0, 0);
-                        return;
-                    }
-                    // TODO: Verify/convert pixel format enum
-                } else {
-                    inputData = (const uint8_t *)inHeader->pBuffer + inHeader->nOffset;
-                    if (mColorFormat != OMX_COLOR_FormatYUV420Planar) {
-                        ConvertYUV420SemiPlanarToYUV420Planar(
-                            inputData, mInputFrameData, mWidth, mHeight);
-                        inputData = mInputFrameData;
-                    }
-                }
-
-                CHECK(inputData != NULL);
-                videoInput.YCbCr[0] = (uint8_t *)inputData;
-                videoInput.YCbCr[1] = videoInput.YCbCr[0] + videoInput.height * videoInput.pitch;
-                videoInput.YCbCr[2] = videoInput.YCbCr[1] +
-                    ((videoInput.height * videoInput.pitch) >> 2);
-                videoInput.disp_order = mNumInputFrames;
-
-                encoderStatus = PVAVCEncSetInput(mHandle, &videoInput);
-                if (encoderStatus == AVCENC_SUCCESS || encoderStatus == AVCENC_NEW_IDR) {
-                    mReadyForNextFrame = false;
-                    ++mNumInputFrames;
-                    if (encoderStatus == AVCENC_NEW_IDR) {
-                        mIsIDRFrame = 1;
-                    }
-                } else {
-                    if (encoderStatus < AVCENC_SUCCESS) {
-                        ALOGE("encoderStatus = %d at line %d", encoderStatus, __LINE__);
-                        mSignalledError = true;
-                        notify(OMX_EventError, OMX_ErrorUndefined, 0, 0);
-                        return;
-                    } else {
-                        ALOGV("encoderStatus = %d at line %d", encoderStatus, __LINE__);
-                        inQueue.erase(inQueue.begin());
-                        inInfo->mOwnedByUs = false;
-                        notifyEmptyBufferDone(inHeader);
-                        return;
-                    }
-                }
-            }
-        }
-
-        // Encode an input video frame
-        CHECK(encoderStatus == AVCENC_SUCCESS || encoderStatus == AVCENC_NEW_IDR);
-        dataLength = outHeader->nAllocLen;  // Reset the output buffer length
-        if (inHeader->nFilledLen > 0) {
-            if (outHeader->nAllocLen >= 4) {
-                memcpy(outPtr, "\x00\x00\x00\x01", 4);
-                outPtr += 4;
-                dataLength -= 4;
-            }
-            encoderStatus = PVAVCEncodeNAL(mHandle, outPtr, &dataLength, &type);
-            dataLength = outPtr + dataLength - outHeader->pBuffer;
-            if (encoderStatus == AVCENC_SUCCESS) {
-                CHECK(NULL == PVAVCEncGetOverrunBuffer(mHandle));
-            } else if (encoderStatus == AVCENC_PICTURE_READY) {
-                CHECK(NULL == PVAVCEncGetOverrunBuffer(mHandle));
-                if (mIsIDRFrame) {
-                    outHeader->nFlags |= OMX_BUFFERFLAG_SYNCFRAME;
-                    mIsIDRFrame = false;
-                }
-                mReadyForNextFrame = true;
-                AVCFrameIO recon;
-                if (PVAVCEncGetRecon(mHandle, &recon) == AVCENC_SUCCESS) {
-                    PVAVCEncReleaseRecon(mHandle, &recon);
-                }
-            } else {
-                dataLength = 0;
-                mReadyForNextFrame = true;
-            }
-
-            if (encoderStatus < AVCENC_SUCCESS) {
-                ALOGE("encoderStatus = %d at line %d", encoderStatus, __LINE__);
-                mSignalledError = true;
-                notify(OMX_EventError, OMX_ErrorUndefined, 0, 0);
-                return;
-            }
-        } else {
-            dataLength = 0;
-        }
-
-        inQueue.erase(inQueue.begin());
-        inInfo->mOwnedByUs = false;
-        notifyEmptyBufferDone(inHeader);
-
-        outQueue.erase(outQueue.begin());
-        CHECK(!mInputBufferInfoVec.empty());
-        InputBufferInfo *inputBufInfo = mInputBufferInfoVec.begin();
-        outHeader->nTimeStamp = inputBufInfo->mTimeUs;
-        outHeader->nFlags |= (inputBufInfo->mFlags | OMX_BUFFERFLAG_ENDOFFRAME);
-        if (mSawInputEOS) {
-            outHeader->nFlags |= OMX_BUFFERFLAG_EOS;
-        }
-        outHeader->nFilledLen = dataLength;
-        outInfo->mOwnedByUs = false;
-        notifyFillBufferDone(outHeader);
-        mInputBufferInfoVec.erase(mInputBufferInfoVec.begin());
-    }
-}
-
-int32_t SoftAVCEncoder::allocOutputBuffers(
-        unsigned int sizeInMbs, unsigned int numBuffers) {
-    CHECK(mOutputBuffers.isEmpty());
-    size_t frameSize = (sizeInMbs << 7) * 3;
-    for (unsigned int i = 0; i <  numBuffers; ++i) {
-        MediaBuffer *buffer = new MediaBuffer(frameSize);
-        buffer->setObserver(this);
-        mOutputBuffers.push(buffer);
-    }
-
-    return 1;
-}
-
-void SoftAVCEncoder::unbindOutputBuffer(int32_t index) {
-    CHECK(index >= 0);
-}
-
-int32_t SoftAVCEncoder::bindOutputBuffer(int32_t index, uint8_t **yuv) {
-    CHECK(index >= 0);
-    CHECK(index < (int32_t) mOutputBuffers.size());
-    *yuv = (uint8_t *) mOutputBuffers[index]->data();
-
-    return 1;
-}
-
-void SoftAVCEncoder::signalBufferReturned(MediaBuffer *buffer) {
-    UNUSED_UNLESS_VERBOSE(buffer);
-    ALOGV("signalBufferReturned: %p", buffer);
-}
-
-}  // namespace android
-
-android::SoftOMXComponent *createSoftOMXComponent(
-        const char *name, const OMX_CALLBACKTYPE *callbacks,
-        OMX_PTR appData, OMX_COMPONENTTYPE **component) {
-    return new android::SoftAVCEncoder(name, callbacks, appData, component);
-}
diff --git a/media/libstagefright/codecs/avc/enc/SoftAVCEncoder.h b/media/libstagefright/codecs/avc/enc/SoftAVCEncoder.h
deleted file mode 100644
index 81de109..0000000
--- a/media/libstagefright/codecs/avc/enc/SoftAVCEncoder.h
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * Copyright (C) 2012 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 SOFT_AVC_ENCODER_H_
-#define SOFT_AVC_ENCODER_H_
-
-#include <media/stagefright/MediaBuffer.h>
-#include <media/stagefright/foundation/ABase.h>
-#include <utils/Vector.h>
-
-#include "avcenc_api.h"
-#include "SoftVideoEncoderOMXComponent.h"
-
-namespace android {
-
-struct SoftAVCEncoder : public MediaBufferObserver,
-                        public SoftVideoEncoderOMXComponent {
-    SoftAVCEncoder(
-            const char *name,
-            const OMX_CALLBACKTYPE *callbacks,
-            OMX_PTR appData,
-            OMX_COMPONENTTYPE **component);
-
-    // Override SimpleSoftOMXComponent methods
-    virtual OMX_ERRORTYPE internalGetParameter(
-            OMX_INDEXTYPE index, OMX_PTR params);
-
-    virtual OMX_ERRORTYPE internalSetParameter(
-            OMX_INDEXTYPE index, const OMX_PTR params);
-
-    virtual void onQueueFilled(OMX_U32 portIndex);
-
-    // Implement MediaBufferObserver
-    virtual void signalBufferReturned(MediaBuffer *buffer);
-
-
-    // Callbacks required by PV's encoder
-    int32_t allocOutputBuffers(unsigned int sizeInMbs, unsigned int numBuffers);
-    void    unbindOutputBuffer(int32_t index);
-    int32_t bindOutputBuffer(int32_t index, uint8_t **yuv);
-
-protected:
-    virtual ~SoftAVCEncoder();
-
-private:
-    enum {
-        kNumBuffers = 2,
-    };
-
-    // OMX input buffer's timestamp and flags
-    typedef struct {
-        int64_t mTimeUs;
-        int32_t mFlags;
-    } InputBufferInfo;
-
-    int32_t  mIDRFrameRefreshIntervalInSec;
-    AVCProfile mAVCEncProfile;
-    AVCLevel   mAVCEncLevel;
-
-    int64_t  mNumInputFrames;
-    int64_t  mPrevTimestampUs;
-    bool     mStarted;
-    bool     mSpsPpsHeaderReceived;
-    bool     mReadyForNextFrame;
-    bool     mSawInputEOS;
-    bool     mSignalledError;
-    bool     mIsIDRFrame;
-
-    tagAVCHandle          *mHandle;
-    tagAVCEncParam        *mEncParams;
-    uint8_t               *mInputFrameData;
-    uint32_t              *mSliceGroup;
-    Vector<MediaBuffer *> mOutputBuffers;
-    Vector<InputBufferInfo> mInputBufferInfoVec;
-
-    OMX_ERRORTYPE initEncParams();
-    OMX_ERRORTYPE initEncoder();
-    OMX_ERRORTYPE releaseEncoder();
-    void releaseOutputBuffers();
-
-    DISALLOW_EVIL_CONSTRUCTORS(SoftAVCEncoder);
-};
-
-}  // namespace android
-
-#endif  // SOFT_AVC_ENCODER_H_
diff --git a/media/libstagefright/codecs/avc/enc/src/avcenc_api.cpp b/media/libstagefright/codecs/avc/enc/src/avcenc_api.cpp
deleted file mode 100644
index cf14e10..0000000
--- a/media/libstagefright/codecs/avc/enc/src/avcenc_api.cpp
+++ /dev/null
@@ -1,736 +0,0 @@
-/* ------------------------------------------------------------------
- * 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 "avcenc_api.h"
-#include "avcenc_lib.h"
-
-/* ======================================================================== */
-/*  Function : PVAVCGetNALType()                                            */
-/*  Date     : 11/4/2003                                                    */
-/*  Purpose  : Sniff NAL type from the bitstream                            */
-/*  In/out   :                                                              */
-/*  Return   : AVCENC_SUCCESS if succeed, AVCENC_FAIL if fail.              */
-/*  Modified :                                                              */
-/* ======================================================================== */
-OSCL_EXPORT_REF AVCEnc_Status PVAVCEncGetNALType(unsigned char *bitstream, int size,
-        int *nal_type, int *nal_ref_idc)
-{
-    int forbidden_zero_bit;
-    if (size > 0)
-    {
-        forbidden_zero_bit = bitstream[0] >> 7;
-        if (forbidden_zero_bit != 0)
-            return AVCENC_FAIL;
-        *nal_ref_idc = (bitstream[0] & 0x60) >> 5;
-        *nal_type = bitstream[0] & 0x1F;
-        return AVCENC_SUCCESS;
-    }
-
-    return AVCENC_FAIL;
-}
-
-
-/* ======================================================================== */
-/*  Function : PVAVCEncInitialize()                                         */
-/*  Date     : 3/18/2004                                                    */
-/*  Purpose  : Initialize the encoder library, allocate memory and verify   */
-/*              the profile/level support/settings.                         */
-/*  In/out   : Encoding parameters.                                         */
-/*  Return   : AVCENC_SUCCESS for success.                                  */
-/*  Modified :                                                              */
-/* ======================================================================== */
-OSCL_EXPORT_REF AVCEnc_Status PVAVCEncInitialize(AVCHandle *avcHandle, AVCEncParams *encParam,
-        void* extSPS, void* extPPS)
-{
-    AVCEnc_Status status;
-    AVCEncObject *encvid;
-    AVCCommonObj *video;
-    uint32 *userData = (uint32*) avcHandle->userData;
-    int framesize;
-
-    if (avcHandle->AVCObject != NULL)
-    {
-        return AVCENC_ALREADY_INITIALIZED; /* It's already initialized, need to cleanup first */
-    }
-
-    /* not initialized */
-
-    /* allocate videoObject */
-    avcHandle->AVCObject = (void*)avcHandle->CBAVC_Malloc(userData, sizeof(AVCEncObject), DEFAULT_ATTR);
-    if (avcHandle->AVCObject == NULL)
-    {
-        return AVCENC_MEMORY_FAIL;
-    }
-
-    encvid = (AVCEncObject*) avcHandle->AVCObject;
-
-    encvid->enc_state = AVCEnc_Initializing;
-
-    encvid->avcHandle = avcHandle;
-
-    encvid->common = (AVCCommonObj*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCCommonObj), DEFAULT_ATTR);
-    if (encvid->common == NULL)
-    {
-        return AVCENC_MEMORY_FAIL;
-    }
-
-    video = encvid->common;
-
-    /* allocate bitstream structure */
-    encvid->bitstream = (AVCEncBitstream*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCEncBitstream), DEFAULT_ATTR);
-    if (encvid->bitstream == NULL)
-    {
-        return AVCENC_MEMORY_FAIL;
-    }
-    encvid->bitstream->encvid = encvid; /* to point back for reallocation */
-
-    /* allocate sequence parameter set structure */
-    video->currSeqParams = (AVCSeqParamSet*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCSeqParamSet), DEFAULT_ATTR);
-    if (video->currSeqParams == NULL)
-    {
-        return AVCENC_MEMORY_FAIL;
-    }
-
-    /* allocate picture parameter set structure */
-    video->currPicParams = (AVCPicParamSet*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCPicParamSet), DEFAULT_ATTR);
-    if (video->currPicParams == NULL)
-    {
-        return AVCENC_MEMORY_FAIL;
-    }
-
-    /* allocate slice header structure */
-    video->sliceHdr = (AVCSliceHeader*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCSliceHeader), DEFAULT_ATTR);
-    if (video->sliceHdr == NULL)
-    {
-        return AVCENC_MEMORY_FAIL;
-    }
-
-    /* allocate encoded picture buffer structure*/
-    video->decPicBuf = (AVCDecPicBuffer*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCDecPicBuffer), DEFAULT_ATTR);
-    if (video->decPicBuf == NULL)
-    {
-        return AVCENC_MEMORY_FAIL;
-    }
-
-    /* allocate rate control structure */
-    encvid->rateCtrl = (AVCRateControl*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCRateControl), DEFAULT_ATTR);
-    if (encvid->rateCtrl == NULL)
-    {
-        return AVCENC_MEMORY_FAIL;
-    }
-
-    /* reset frame list, not really needed */
-    video->currPic = NULL;
-    video->currFS = NULL;
-    encvid->currInput = NULL;
-    video->prevRefPic = NULL;
-
-    /* now read encParams, and allocate dimension-dependent variables */
-    /* such as mblock */
-    status = SetEncodeParam(avcHandle, encParam, extSPS, extPPS); /* initialized variables to be used in SPS*/
-    if (status != AVCENC_SUCCESS)
-    {
-        return status;
-    }
-
-    if (encParam->use_overrun_buffer == AVC_ON)
-    {
-        /* allocate overrun buffer */
-        encvid->oBSize = encvid->rateCtrl->cpbSize;
-        if (encvid->oBSize > DEFAULT_OVERRUN_BUFFER_SIZE)
-        {
-            encvid->oBSize = DEFAULT_OVERRUN_BUFFER_SIZE;
-        }
-        encvid->overrunBuffer = (uint8*) avcHandle->CBAVC_Malloc(userData, encvid->oBSize, DEFAULT_ATTR);
-        if (encvid->overrunBuffer == NULL)
-        {
-            return AVCENC_MEMORY_FAIL;
-        }
-    }
-    else
-    {
-        encvid->oBSize = 0;
-        encvid->overrunBuffer = NULL;
-    }
-
-    /* allocate frame size dependent structures */
-    framesize = video->FrameHeightInMbs * video->PicWidthInMbs;
-
-    video->mblock = (AVCMacroblock*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCMacroblock) * framesize, DEFAULT_ATTR);
-    if (video->mblock == NULL)
-    {
-        return AVCENC_MEMORY_FAIL;
-    }
-
-    video->MbToSliceGroupMap = (int*) avcHandle->CBAVC_Malloc(userData, sizeof(uint) * video->PicSizeInMapUnits * 2, DEFAULT_ATTR);
-    if (video->MbToSliceGroupMap == NULL)
-    {
-        return AVCENC_MEMORY_FAIL;
-    }
-
-    encvid->mot16x16 = (AVCMV*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCMV) * framesize, DEFAULT_ATTR);
-    if (encvid->mot16x16 == NULL)
-    {
-        return AVCENC_MEMORY_FAIL;
-    }
-
-    encvid->intraSearch = (uint8*) avcHandle->CBAVC_Malloc(userData, sizeof(uint8) * framesize, DEFAULT_ATTR);
-    if (encvid->intraSearch == NULL)
-    {
-        return AVCENC_MEMORY_FAIL;
-    }
-
-    encvid->min_cost = (int*) avcHandle->CBAVC_Malloc(userData, sizeof(int) * framesize, DEFAULT_ATTR);
-    if (encvid->min_cost == NULL)
-    {
-        return AVCENC_MEMORY_FAIL;
-    }
-
-    /* initialize motion search related memory */
-    if (AVCENC_SUCCESS != InitMotionSearchModule(avcHandle))
-    {
-        return AVCENC_MEMORY_FAIL;
-    }
-
-    if (AVCENC_SUCCESS != InitRateControlModule(avcHandle))
-    {
-        return AVCENC_MEMORY_FAIL;
-    }
-
-    /* intialize function pointers */
-    encvid->functionPointer = (AVCEncFuncPtr*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCEncFuncPtr), DEFAULT_ATTR);
-    if (encvid->functionPointer == NULL)
-    {
-        return AVCENC_MEMORY_FAIL;
-    }
-    encvid->functionPointer->SAD_Macroblock = &AVCSAD_Macroblock_C;
-    encvid->functionPointer->SAD_MB_HalfPel[0] = NULL;
-    encvid->functionPointer->SAD_MB_HalfPel[1] = &AVCSAD_MB_HalfPel_Cxh;
-    encvid->functionPointer->SAD_MB_HalfPel[2] = &AVCSAD_MB_HalfPel_Cyh;
-    encvid->functionPointer->SAD_MB_HalfPel[3] = &AVCSAD_MB_HalfPel_Cxhyh;
-
-    /* initialize timing control */
-    encvid->modTimeRef = 0;     /* ALWAYS ASSUME THAT TIMESTAMP START FROM 0 !!!*/
-    video->prevFrameNum = 0;
-    encvid->prevCodedFrameNum = 0;
-    encvid->dispOrdPOCRef = 0;
-
-    if (encvid->outOfBandParamSet == TRUE)
-    {
-        encvid->enc_state = AVCEnc_Encoding_SPS;
-    }
-    else
-    {
-        encvid->enc_state = AVCEnc_Analyzing_Frame;
-    }
-
-    return AVCENC_SUCCESS;
-}
-
-/* ======================================================================== */
-/*  Function : PVAVCEncGetMaxOutputSize()                                   */
-/*  Date     : 11/29/2008                                                   */
-/*  Purpose  : Return max output buffer size that apps should allocate for  */
-/*              output buffer.                                              */
-/*  In/out   :                                                              */
-/*  Return   : AVCENC_SUCCESS for success.                                  */
-/*  Modified :   size                                                       */
-/* ======================================================================== */
-
-OSCL_EXPORT_REF AVCEnc_Status PVAVCEncGetMaxOutputBufferSize(AVCHandle *avcHandle, int* size)
-{
-    AVCEncObject *encvid = (AVCEncObject*)avcHandle->AVCObject;
-
-    if (encvid == NULL)
-    {
-        return AVCENC_UNINITIALIZED;
-    }
-
-    *size = encvid->rateCtrl->cpbSize;
-
-    return AVCENC_SUCCESS;
-}
-
-/* ======================================================================== */
-/*  Function : PVAVCEncSetInput()                                           */
-/*  Date     : 4/18/2004                                                    */
-/*  Purpose  : To feed an unencoded original frame to the encoder library.  */
-/*  In/out   :                                                              */
-/*  Return   : AVCENC_SUCCESS for success.                                  */
-/*  Modified :                                                              */
-/* ======================================================================== */
-OSCL_EXPORT_REF AVCEnc_Status PVAVCEncSetInput(AVCHandle *avcHandle, AVCFrameIO *input)
-{
-    AVCEncObject *encvid = (AVCEncObject*)avcHandle->AVCObject;
-    AVCCommonObj *video = encvid->common;
-    AVCRateControl *rateCtrl = encvid->rateCtrl;
-
-    AVCEnc_Status status;
-    uint frameNum;
-
-    if (encvid == NULL)
-    {
-        return AVCENC_UNINITIALIZED;
-    }
-
-    if (encvid->enc_state == AVCEnc_WaitingForBuffer)
-    {
-        goto RECALL_INITFRAME;
-    }
-    else if (encvid->enc_state != AVCEnc_Analyzing_Frame)
-    {
-        return AVCENC_FAIL;
-    }
-
-    if (input->pitch > 0xFFFF)
-    {
-        return AVCENC_NOT_SUPPORTED; // we use 2-bytes for pitch
-    }
-
-    /***********************************/
-
-    /* Let's rate control decide whether to encode this frame or not */
-    /* Also set video->nal_unit_type, sliceHdr->slice_type, video->slice_type */
-    if (AVCENC_SUCCESS != RCDetermineFrameNum(encvid, rateCtrl, input->coding_timestamp, &frameNum))
-    {
-        return AVCENC_SKIPPED_PICTURE; /* not time to encode, thus skipping */
-    }
-
-    /* we may not need this line */
-    //nextFrmModTime = (uint32)((((frameNum+1)*1000)/rateCtrl->frame_rate) + modTimeRef); /* rec. time */
-    //encvid->nextModTime = nextFrmModTime - (encvid->frameInterval>>1) - 1; /* between current and next frame */
-
-    encvid->currInput = input;
-    encvid->currInput->coding_order = frameNum;
-
-RECALL_INITFRAME:
-    /* initialize and analyze the frame */
-    status = InitFrame(encvid);
-
-    if (status == AVCENC_SUCCESS)
-    {
-        encvid->enc_state = AVCEnc_Encoding_Frame;
-    }
-    else if (status == AVCENC_NEW_IDR)
-    {
-        if (encvid->outOfBandParamSet == TRUE)
-        {
-            encvid->enc_state = AVCEnc_Encoding_Frame;
-        }
-        else // assuming that in-band paramset keeps sending new SPS and PPS.
-        {
-            encvid->enc_state = AVCEnc_Encoding_SPS;
-            //video->currSeqParams->seq_parameter_set_id++;
-            //if(video->currSeqParams->seq_parameter_set_id > 31) // range check
-            {
-                video->currSeqParams->seq_parameter_set_id = 0;  // reset
-            }
-        }
-
-        video->sliceHdr->idr_pic_id++;
-        if (video->sliceHdr->idr_pic_id > 65535) // range check
-        {
-            video->sliceHdr->idr_pic_id = 0;  // reset
-        }
-    }
-    /* the following logics need to be revisited */
-    else if (status == AVCENC_PICTURE_READY) // no buffers returned back to the encoder
-    {
-        encvid->enc_state = AVCEnc_WaitingForBuffer; // Input accepted but can't continue
-        // need to free up some memory before proceeding with Encode
-    }
-
-    return status; // return status, including the AVCENC_FAIL case and all 3 above.
-}
-
-/* ======================================================================== */
-/*  Function : PVAVCEncodeNAL()                                             */
-/*  Date     : 4/29/2004                                                    */
-/*  Purpose  : To encode one NAL/slice.                                     */
-/*  In/out   :                                                              */
-/*  Return   : AVCENC_SUCCESS for success.                                  */
-/*  Modified :                                                              */
-/* ======================================================================== */
-OSCL_EXPORT_REF AVCEnc_Status PVAVCEncodeNAL(AVCHandle *avcHandle, unsigned char *buffer, unsigned int *buf_nal_size, int *nal_type)
-{
-    AVCEncObject *encvid = (AVCEncObject*)avcHandle->AVCObject;
-    AVCCommonObj *video = encvid->common;
-    AVCEncBitstream *bitstream = encvid->bitstream;
-    AVCEnc_Status status;
-
-    if (encvid == NULL)
-    {
-        return AVCENC_UNINITIALIZED;
-    }
-
-    switch (encvid->enc_state)
-    {
-        case AVCEnc_Initializing:
-            return AVCENC_UNINITIALIZED;
-        case AVCEnc_Encoding_SPS:
-            /* initialized the structure */
-            BitstreamEncInit(bitstream, buffer, *buf_nal_size, NULL, 0);
-            BitstreamWriteBits(bitstream, 8, (1 << 5) | AVC_NALTYPE_SPS);
-
-            /* encode SPS */
-            status = EncodeSPS(encvid, bitstream);
-            if (status != AVCENC_SUCCESS)
-            {
-                return status;
-            }
-
-            /* closing the NAL with trailing bits */
-            status = BitstreamTrailingBits(bitstream, buf_nal_size);
-            if (status == AVCENC_SUCCESS)
-            {
-                encvid->enc_state = AVCEnc_Encoding_PPS;
-                video->currPicParams->seq_parameter_set_id = video->currSeqParams->seq_parameter_set_id;
-                video->currPicParams->pic_parameter_set_id++;
-                *nal_type = AVC_NALTYPE_SPS;
-                *buf_nal_size = bitstream->write_pos;
-            }
-            break;
-        case AVCEnc_Encoding_PPS:
-            /* initialized the structure */
-            BitstreamEncInit(bitstream, buffer, *buf_nal_size, NULL, 0);
-            BitstreamWriteBits(bitstream, 8, (1 << 5) | AVC_NALTYPE_PPS);
-
-            /* encode PPS */
-            status = EncodePPS(encvid, bitstream);
-            if (status != AVCENC_SUCCESS)
-            {
-                return status;
-            }
-
-            /* closing the NAL with trailing bits */
-            status = BitstreamTrailingBits(bitstream, buf_nal_size);
-            if (status == AVCENC_SUCCESS)
-            {
-                if (encvid->outOfBandParamSet == TRUE) // already extract PPS, SPS
-                {
-                    encvid->enc_state = AVCEnc_Analyzing_Frame;
-                }
-                else    // SetInput has been called before SPS and PPS.
-                {
-                    encvid->enc_state = AVCEnc_Encoding_Frame;
-                }
-
-                *nal_type = AVC_NALTYPE_PPS;
-                *buf_nal_size = bitstream->write_pos;
-            }
-            break;
-
-        case AVCEnc_Encoding_Frame:
-            /* initialized the structure */
-            BitstreamEncInit(bitstream, buffer, *buf_nal_size, encvid->overrunBuffer, encvid->oBSize);
-            BitstreamWriteBits(bitstream, 8, (video->nal_ref_idc << 5) | (video->nal_unit_type));
-
-            /* Re-order the reference list according to the ref_pic_list_reordering() */
-            /* We don't have to reorder the list for the encoder here. This can only be done
-            after we encode this slice. We can run thru a second-pass to see if new ordering
-            would save more bits. Too much delay !! */
-            /* status = ReOrderList(video);*/
-            status = InitSlice(encvid);
-            if (status != AVCENC_SUCCESS)
-            {
-                return status;
-            }
-
-            /* when we have everything, we encode the slice header */
-            status = EncodeSliceHeader(encvid, bitstream);
-            if (status != AVCENC_SUCCESS)
-            {
-                return status;
-            }
-
-            status = AVCEncodeSlice(encvid);
-
-            video->slice_id++;
-
-            /* closing the NAL with trailing bits */
-            BitstreamTrailingBits(bitstream, buf_nal_size);
-
-            *buf_nal_size = bitstream->write_pos;
-
-            encvid->rateCtrl->numFrameBits += ((*buf_nal_size) << 3);
-
-            *nal_type = video->nal_unit_type;
-
-            if (status == AVCENC_PICTURE_READY)
-            {
-                status = RCUpdateFrame(encvid);
-                if (status == AVCENC_SKIPPED_PICTURE) /* skip current frame */
-                {
-                    DPBReleaseCurrentFrame(avcHandle, video);
-                    encvid->enc_state = AVCEnc_Analyzing_Frame;
-
-                    return status;
-                }
-
-                /* perform loop-filtering on the entire frame */
-                DeblockPicture(video);
-
-                /* update the original frame array */
-                encvid->prevCodedFrameNum = encvid->currInput->coding_order;
-
-                /* store the encoded picture in the DPB buffer */
-                StorePictureInDPB(avcHandle, video);
-
-                if (video->currPic->isReference)
-                {
-                    video->PrevRefFrameNum = video->sliceHdr->frame_num;
-                }
-
-                /* update POC related variables */
-                PostPOC(video);
-
-                encvid->enc_state = AVCEnc_Analyzing_Frame;
-                status = AVCENC_PICTURE_READY;
-
-            }
-            break;
-        default:
-            status = AVCENC_WRONG_STATE;
-    }
-
-    return status;
-}
-
-/* ======================================================================== */
-/*  Function : PVAVCEncGetOverrunBuffer()                                   */
-/*  Purpose  : To retrieve the overrun buffer. Check whether overrun buffer */
-/*              is used or not before returning                             */
-/*  In/out   :                                                              */
-/*  Return   : Pointer to the internal overrun buffer.                      */
-/*  Modified :                                                              */
-/* ======================================================================== */
-OSCL_EXPORT_REF uint8* PVAVCEncGetOverrunBuffer(AVCHandle* avcHandle)
-{
-    AVCEncObject *encvid = (AVCEncObject*)avcHandle->AVCObject;
-    AVCEncBitstream *bitstream = encvid->bitstream;
-
-    if (bitstream->overrunBuffer == bitstream->bitstreamBuffer) /* OB is used */
-    {
-        return encvid->overrunBuffer;
-    }
-    else
-    {
-        return NULL;
-    }
-}
-
-
-/* ======================================================================== */
-/*  Function : PVAVCEncGetRecon()                                           */
-/*  Date     : 4/29/2004                                                    */
-/*  Purpose  : To retrieve the most recently encoded frame.                 */
-/*              assume that user will make a copy if they want to hold on   */
-/*              to it. Otherwise, it is not guaranteed to be reserved.      */
-/*              Most applications prefer to see original frame rather than  */
-/*              reconstructed frame. So, we are staying aware from complex  */
-/*              buffering mechanism. If needed, can be added later.         */
-/*  In/out   :                                                              */
-/*  Return   : AVCENC_SUCCESS for success.                                  */
-/*  Modified :                                                              */
-/* ======================================================================== */
-OSCL_EXPORT_REF AVCEnc_Status PVAVCEncGetRecon(AVCHandle *avcHandle, AVCFrameIO *recon)
-{
-    AVCEncObject *encvid = (AVCEncObject*)avcHandle->AVCObject;
-    AVCCommonObj *video = encvid->common;
-    AVCFrameStore *currFS = video->currFS;
-
-    if (encvid == NULL)
-    {
-        return AVCENC_UNINITIALIZED;
-    }
-
-    recon->YCbCr[0] = currFS->frame.Sl;
-    recon->YCbCr[1] = currFS->frame.Scb;
-    recon->YCbCr[2] = currFS->frame.Scr;
-    recon->height = currFS->frame.height;
-    recon->pitch = currFS->frame.pitch;
-    recon->disp_order = currFS->PicOrderCnt;
-    recon->coding_order = currFS->FrameNum;
-    recon->id = (intptr_t) currFS->base_dpb; /* use the pointer as the id */
-
-    currFS->IsOutputted |= 1;
-
-    return AVCENC_SUCCESS;
-}
-
-OSCL_EXPORT_REF AVCEnc_Status PVAVCEncReleaseRecon(AVCHandle *avcHandle, AVCFrameIO *recon)
-{
-    OSCL_UNUSED_ARG(avcHandle);
-    OSCL_UNUSED_ARG(recon);
-
-    return AVCENC_SUCCESS; //for now
-}
-
-/* ======================================================================== */
-/*  Function : PVAVCCleanUpEncoder()                                        */
-/*  Date     : 4/18/2004                                                    */
-/*  Purpose  : To clean up memories allocated by PVAVCEncInitialize()       */
-/*  In/out   :                                                              */
-/*  Return   : AVCENC_SUCCESS for success.                                  */
-/*  Modified :                                                              */
-/* ======================================================================== */
-OSCL_EXPORT_REF void    PVAVCCleanUpEncoder(AVCHandle *avcHandle)
-{
-    AVCEncObject *encvid = (AVCEncObject*) avcHandle->AVCObject;
-    AVCCommonObj *video;
-    uint32 *userData = (uint32*) avcHandle->userData;
-
-    if (encvid != NULL)
-    {
-        CleanMotionSearchModule(avcHandle);
-
-        CleanupRateControlModule(avcHandle);
-
-        if (encvid->functionPointer != NULL)
-        {
-            avcHandle->CBAVC_Free(userData, encvid->functionPointer);
-        }
-
-        if (encvid->min_cost)
-        {
-            avcHandle->CBAVC_Free(userData, encvid->min_cost);
-        }
-
-        if (encvid->intraSearch)
-        {
-            avcHandle->CBAVC_Free(userData, encvid->intraSearch);
-        }
-
-        if (encvid->mot16x16)
-        {
-            avcHandle->CBAVC_Free(userData, encvid->mot16x16);
-        }
-
-        if (encvid->rateCtrl)
-        {
-            avcHandle->CBAVC_Free(userData, encvid->rateCtrl);
-        }
-
-        if (encvid->overrunBuffer)
-        {
-            avcHandle->CBAVC_Free(userData, encvid->overrunBuffer);
-        }
-
-        video = encvid->common;
-        if (video != NULL)
-        {
-            if (video->MbToSliceGroupMap)
-            {
-                avcHandle->CBAVC_Free(userData, video->MbToSliceGroupMap);
-            }
-            if (video->mblock != NULL)
-            {
-                avcHandle->CBAVC_Free(userData, video->mblock);
-            }
-            if (video->decPicBuf != NULL)
-            {
-                CleanUpDPB(avcHandle, video);
-                avcHandle->CBAVC_Free(userData, video->decPicBuf);
-            }
-            if (video->sliceHdr != NULL)
-            {
-                avcHandle->CBAVC_Free(userData, video->sliceHdr);
-            }
-            if (video->currPicParams != NULL)
-            {
-                if (video->currPicParams->slice_group_id)
-                {
-                    avcHandle->CBAVC_Free(userData, video->currPicParams->slice_group_id);
-                }
-
-                avcHandle->CBAVC_Free(userData, video->currPicParams);
-            }
-            if (video->currSeqParams != NULL)
-            {
-                avcHandle->CBAVC_Free(userData, video->currSeqParams);
-            }
-            if (encvid->bitstream != NULL)
-            {
-                avcHandle->CBAVC_Free(userData, encvid->bitstream);
-            }
-            if (video != NULL)
-            {
-                avcHandle->CBAVC_Free(userData, video);
-            }
-        }
-
-        avcHandle->CBAVC_Free(userData, encvid);
-
-        avcHandle->AVCObject = NULL;
-    }
-
-    return ;
-}
-
-OSCL_EXPORT_REF AVCEnc_Status PVAVCEncUpdateBitRate(AVCHandle *avcHandle, uint32 bitrate)
-{
-    OSCL_UNUSED_ARG(avcHandle);
-    OSCL_UNUSED_ARG(bitrate);
-
-    return AVCENC_FAIL;
-}
-
-OSCL_EXPORT_REF AVCEnc_Status PVAVCEncUpdateFrameRate(AVCHandle *avcHandle, uint32 num, uint32 denom)
-{
-    OSCL_UNUSED_ARG(avcHandle);
-    OSCL_UNUSED_ARG(num);
-    OSCL_UNUSED_ARG(denom);
-
-    return AVCENC_FAIL;
-}
-
-OSCL_EXPORT_REF AVCEnc_Status PVAVCEncUpdateIDRInterval(AVCHandle *avcHandle, int IDRInterval)
-{
-    OSCL_UNUSED_ARG(avcHandle);
-    OSCL_UNUSED_ARG(IDRInterval);
-
-    return AVCENC_FAIL;
-}
-
-OSCL_EXPORT_REF AVCEnc_Status PVAVCEncIDRRequest(AVCHandle *avcHandle)
-{
-    OSCL_UNUSED_ARG(avcHandle);
-
-    return AVCENC_FAIL;
-}
-
-OSCL_EXPORT_REF AVCEnc_Status PVAVCEncUpdateIMBRefresh(AVCHandle *avcHandle, int numMB)
-{
-    OSCL_UNUSED_ARG(avcHandle);
-    OSCL_UNUSED_ARG(numMB);
-
-    return AVCENC_FAIL;
-}
-
-void PVAVCEncGetFrameStats(AVCHandle *avcHandle, AVCEncFrameStats *avcStats)
-{
-    AVCEncObject *encvid = (AVCEncObject*) avcHandle->AVCObject;
-    AVCRateControl *rateCtrl = encvid->rateCtrl;
-
-    avcStats->avgFrameQP = GetAvgFrameQP(rateCtrl);
-    avcStats->numIntraMBs = encvid->numIntraMB;
-
-    return ;
-}
-
-
-
diff --git a/media/libstagefright/codecs/avc/enc/src/avcenc_api.h b/media/libstagefright/codecs/avc/enc/src/avcenc_api.h
deleted file mode 100644
index 6841ec3..0000000
--- a/media/libstagefright/codecs/avc/enc/src/avcenc_api.h
+++ /dev/null
@@ -1,323 +0,0 @@
-/* ------------------------------------------------------------------
- * 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 file contains application function interfaces to the AVC encoder library
-and necessary type defitionitions and enumerations.
-@publishedAll
-*/
-
-#ifndef AVCENC_API_H_INCLUDED
-#define AVCENC_API_H_INCLUDED
-
-#ifndef AVCAPI_COMMON_H_INCLUDED
-#include "avcapi_common.h"
-#endif
-
-// For memset, etc
-#include <string.h>
-
-/**
- This enumeration is used for the status returned from the library interface.
-*/
-typedef enum
-{
-    /**
-    Fail information, need to add more error code for more specific info
-    */
-    AVCENC_TRAILINGONES_FAIL = -35,
-    AVCENC_SLICE_EMPTY = -34,
-    AVCENC_POC_FAIL = -33,
-    AVCENC_CONSECUTIVE_NONREF = -32,
-    AVCENC_CABAC_FAIL = -31,
-    AVCENC_PRED_WEIGHT_TAB_FAIL = -30,
-    AVCENC_DEC_REF_PIC_MARK_FAIL = -29,
-    AVCENC_SPS_FAIL = -28,
-    AVCENC_BITSTREAM_BUFFER_FULL    = -27,
-    AVCENC_BITSTREAM_INIT_FAIL = -26,
-    AVCENC_CHROMA_QP_FAIL = -25,
-    AVCENC_INIT_QS_FAIL = -24,
-    AVCENC_INIT_QP_FAIL = -23,
-    AVCENC_WEIGHTED_BIPRED_FAIL = -22,
-    AVCENC_INVALID_INTRA_PERIOD = -21,
-    AVCENC_INVALID_CHANGE_RATE = -20,
-    AVCENC_INVALID_BETA_OFFSET = -19,
-    AVCENC_INVALID_ALPHA_OFFSET = -18,
-    AVCENC_INVALID_DEBLOCK_IDC = -17,
-    AVCENC_INVALID_REDUNDANT_PIC = -16,
-    AVCENC_INVALID_FRAMERATE = -15,
-    AVCENC_INVALID_NUM_SLICEGROUP = -14,
-    AVCENC_INVALID_POC_LSB = -13,
-    AVCENC_INVALID_NUM_REF = -12,
-    AVCENC_INVALID_FMO_TYPE = -11,
-    AVCENC_ENCPARAM_MEM_FAIL = -10,
-    AVCENC_LEVEL_NOT_SUPPORTED = -9,
-    AVCENC_LEVEL_FAIL = -8,
-    AVCENC_PROFILE_NOT_SUPPORTED = -7,
-    AVCENC_TOOLS_NOT_SUPPORTED = -6,
-    AVCENC_WRONG_STATE = -5,
-    AVCENC_UNINITIALIZED = -4,
-    AVCENC_ALREADY_INITIALIZED = -3,
-    AVCENC_NOT_SUPPORTED = -2,
-    AVCENC_MEMORY_FAIL = AVC_MEMORY_FAIL,
-    AVCENC_FAIL = AVC_FAIL,
-    /**
-    Generic success value
-    */
-    AVCENC_SUCCESS = AVC_SUCCESS,
-    AVCENC_PICTURE_READY = 2,
-    AVCENC_NEW_IDR = 3, /* upon getting this, users have to call PVAVCEncodeSPS and PVAVCEncodePPS to get a new SPS and PPS*/
-    AVCENC_SKIPPED_PICTURE = 4 /* continuable error message */
-
-} AVCEnc_Status;
-
-#define MAX_NUM_SLICE_GROUP  8      /* maximum for all the profiles */
-
-/**
-This structure contains the encoding parameters.
-*/
-typedef struct tagAVCEncParam
-{
-    /* if profile/level is set to zero, encoder will choose the closest one for you */
-    AVCProfile profile; /* profile of the bitstream to be compliant with*/
-    AVCLevel   level;   /* level of the bitstream to be compliant with*/
-
-    int width;      /* width of an input frame in pixel */
-    int height;     /* height of an input frame in pixel */
-
-    int poc_type; /* picture order count mode, 0,1 or 2 */
-    /* for poc_type == 0 */
-    uint log2_max_poc_lsb_minus_4; /* specify maximum value of POC Lsb, range 0..12*/
-    /* for poc_type == 1 */
-    uint delta_poc_zero_flag; /* delta POC always zero */
-    int offset_poc_non_ref; /* offset for non-reference pic */
-    int offset_top_bottom; /* offset between top and bottom field */
-    uint num_ref_in_cycle; /* number of reference frame in one cycle */
-    int *offset_poc_ref; /* array of offset for ref pic, dimension [num_ref_in_cycle] */
-
-    int num_ref_frame;  /* number of reference frame used */
-    int num_slice_group;  /* number of slice group */
-    int fmo_type;   /* 0: interleave, 1: dispersed, 2: foreground with left-over
-                    3: box-out, 4:raster scan, 5:wipe, 6:explicit */
-    /* for fmo_type == 0 */
-    uint run_length_minus1[MAX_NUM_SLICE_GROUP];   /* array of size num_slice_group, in round robin fasion */
-    /* fmo_type == 2*/
-    uint top_left[MAX_NUM_SLICE_GROUP-1];           /* array of co-ordinates of each slice_group */
-    uint bottom_right[MAX_NUM_SLICE_GROUP-1];       /* except the last one which is the background. */
-    /* fmo_type == 3,4,5 */
-    AVCFlag change_dir_flag;  /* slice group change direction flag */
-    uint change_rate_minus1;
-    /* fmo_type == 6 */
-    uint *slice_group; /* array of size MBWidth*MBHeight */
-
-    AVCFlag db_filter;  /* enable deblocking loop filter */
-    int disable_db_idc;  /* 0: filter everywhere, 1: no filter, 2: no filter across slice boundary */
-    int alpha_offset;   /* alpha offset range -6,...,6 */
-    int beta_offset;    /* beta offset range -6,...,6 */
-
-    AVCFlag constrained_intra_pred; /* constrained intra prediction flag */
-
-    AVCFlag auto_scd;   /* scene change detection on or off */
-    int idr_period; /* idr frame refresh rate in number of target encoded frame (no concept of actual time).*/
-    int intramb_refresh;    /* minimum number of intra MB per frame */
-    AVCFlag data_par;   /* enable data partitioning */
-
-    AVCFlag fullsearch; /* enable full-pel full-search mode */
-    int search_range;   /* search range for motion vector in (-search_range,+search_range) pixels */
-    AVCFlag sub_pel;    /* enable sub pel prediction */
-    AVCFlag submb_pred; /* enable sub MB partition mode */
-    AVCFlag rdopt_mode; /* RD optimal mode selection */
-    AVCFlag bidir_pred; /* enable bi-directional for B-slice, this flag forces the encoder to encode
-                        any frame with POC less than the previously encoded frame as a B-frame.
-                        If it's off, then such frames will remain P-frame. */
-
-    AVCFlag rate_control; /* rate control enable, on: RC on, off: constant QP */
-    int initQP;     /* initial QP */
-    uint32 bitrate;    /* target encoding bit rate in bits/second */
-    uint32 CPB_size;  /* coded picture buffer in number of bits */
-    uint32 init_CBP_removal_delay; /* initial CBP removal delay in msec */
-
-    uint32 frame_rate;  /* frame rate in the unit of frames per 1000 second */
-    /* note, frame rate is only needed by the rate control, AVC is timestamp agnostic. */
-
-    AVCFlag out_of_band_param_set; /* flag to set whether param sets are to be retrieved up front or not */
-
-    AVCFlag use_overrun_buffer;  /* do not throw away the frame if output buffer is not big enough.
-                                    copy excess bits to the overrun buffer */
-} AVCEncParams;
-
-
-/**
-This structure contains current frame encoding statistics for debugging purpose.
-*/
-typedef struct tagAVCEncFrameStats
-{
-    int avgFrameQP;   /* average frame QP */
-    int numIntraMBs;  /* number of intra MBs */
-    int numFalseAlarm;
-    int numMisDetected;
-    int numDetected;
-
-} AVCEncFrameStats;
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-    /** THE FOLLOWINGS ARE APIS */
-    /**
-    This function initializes the encoder library. It verifies the validity of the
-    encoding parameters against the specified profile/level and the list of supported
-    tools by this library. It allocates necessary memories required to perform encoding.
-    For re-encoding application, if users want to setup encoder in a more precise way,
-    users can give the external SPS and PPS to the encoder to follow.
-    \param "avcHandle"  "Handle to the AVC encoder library object."
-    \param "encParam"   "Pointer to the encoding parameter structure."
-    \param "extSPS"     "External SPS used for re-encoding purpose. NULL if not present"
-    \param "extPPS"     "External PPS used for re-encoding purpose. NULL if not present"
-    \return "AVCENC_SUCCESS for success,
-             AVCENC_NOT_SUPPORTED for the use of unsupported tools,
-             AVCENC_MEMORY_FAIL for memory allocation failure,
-             AVCENC_FAIL for generic failure."
-    */
-    OSCL_IMPORT_REF AVCEnc_Status PVAVCEncInitialize(AVCHandle *avcHandle, AVCEncParams *encParam, void* extSPS, void* extPPS);
-
-
-    /**
-    Since the output buffer size is not known prior to encoding a frame, users need to
-    allocate big enough buffer otherwise, that frame will be dropped. This function returns
-    the size of the output buffer to be allocated by the users that guarantees to hold one frame.
-    It follows the CPB spec for a particular level.  However, when the users set use_overrun_buffer
-    flag, this API is useless as excess output bits are saved in the overrun buffer waiting to be
-    copied out in small chunks, i.e. users can allocate any size of output buffer.
-    \param "avcHandle"  "Handle to the AVC encoder library object."
-    \param "size"   "Pointer to the size to be modified."
-    \return "AVCENC_SUCCESS for success, AVCENC_UNINITIALIZED when level is not known.
-    */
-
-    OSCL_IMPORT_REF AVCEnc_Status PVAVCEncGetMaxOutputBufferSize(AVCHandle *avcHandle, int* size);
-
-    /**
-    Users call this function to provide an input structure to the encoder library which will keep
-    a list of input structures it receives in case the users call this function many time before
-    calling PVAVCEncodeSlice. The encoder library will encode them according to the frame_num order.
-    Users should not modify the content of a particular frame until this frame is encoded and
-    returned thru CBAVCEnc_ReturnInput() callback function.
-    \param "avcHandle"  "Handle to the AVC encoder library object."
-    \param "input"      "Pointer to the input structure."
-    \return "AVCENC_SUCCESS for success,
-            AVCENC_FAIL if the encoder is not in the right state to take a new input frame.
-            AVCENC_NEW_IDR for the detection or determination of a new IDR, with this status,
-            the returned NAL is an SPS NAL,
-            AVCENC_NO_PICTURE if the input frame coding timestamp is too early, users must
-            get next frame or adjust the coding timestamp."
-    */
-    OSCL_IMPORT_REF AVCEnc_Status PVAVCEncSetInput(AVCHandle *avcHandle, AVCFrameIO *input);
-
-    /**
-    This function is called to encode a NAL unit which can be an SPS NAL, a PPS NAL or
-    a VCL (video coding layer) NAL which contains one slice of data. It could be a
-    fixed number of macroblocks, as specified in the encoder parameters set, or the
-    maximum number of macroblocks fitted into the given input argument "buffer". The
-    input frame is taken from the oldest unencoded input frame retrieved by users by
-    PVAVCEncGetInput API.
-    \param "avcHandle"  "Handle to the AVC encoder library object."
-    \param "buffer"     "Pointer to the output AVC bitstream buffer, the format will be EBSP,
-                         not RBSP."
-    \param "buf_nal_size"   "As input, the size of the buffer in bytes.
-                        This is the physical limitation of the buffer. As output, the size of the EBSP."
-    \param "nal_type"   "Pointer to the NAL type of the returned buffer."
-    \return "AVCENC_SUCCESS for success of encoding one slice,
-             AVCENC_PICTURE_READY for the completion of a frame encoding,
-             AVCENC_FAIL for failure (this should not occur, though)."
-    */
-    OSCL_IMPORT_REF AVCEnc_Status PVAVCEncodeNAL(AVCHandle *avcHandle, uint8 *buffer, uint *buf_nal_size, int *nal_type);
-
-    /**
-    This function sniffs the nal_unit_type such that users can call corresponding APIs.
-    This function is identical to PVAVCDecGetNALType() in the decoder.
-    \param "bitstream"  "Pointer to the beginning of a NAL unit (start with forbidden_zero_bit, etc.)."
-    \param "size"       "size of the bitstream (NumBytesInNALunit + 1)."
-    \param "nal_unit_type" "Pointer to the return value of nal unit type."
-    \return "AVCENC_SUCCESS if success, AVCENC_FAIL otherwise."
-    */
-    OSCL_IMPORT_REF AVCEnc_Status PVAVCEncGetNALType(uint8 *bitstream, int size, int *nal_type, int *nal_ref_idc);
-
-    /**
-    This function returns the pointer to internal overrun buffer. Users can call this to query
-    whether the overrun buffer has been used to encode the current NAL.
-    \param "avcHandle"  "Pointer to the handle."
-    \return "Pointer to overrun buffer if it is used, otherwise, NULL."
-    */
-    OSCL_IMPORT_REF uint8* PVAVCEncGetOverrunBuffer(AVCHandle* avcHandle);
-
-    /**
-    This function returns the reconstructed frame of the most recently encoded frame.
-    Note that this frame is not returned to the users yet. Users should only read the
-    content of this frame.
-    \param "avcHandle"  "Handle to the AVC encoder library object."
-    \param "output"     "Pointer to the input structure."
-    \return "AVCENC_SUCCESS for success, AVCENC_NO_PICTURE if no picture to be outputted."
-    */
-    OSCL_IMPORT_REF AVCEnc_Status PVAVCEncGetRecon(AVCHandle *avcHandle, AVCFrameIO *recon);
-
-    /**
-    This function is used to return the recontructed frame back to the AVC encoder library
-    in order to be re-used for encoding operation. If users want the content of it to remain
-    unchanged for a long time, they should make a copy of it and release the memory back to
-    the encoder. The encoder relies on the id element in the AVCFrameIO structure,
-    thus users should not change the id value.
-    \param "avcHandle"  "Handle to the AVC decoder library object."
-    \param "output"      "Pointer to the AVCFrameIO structure."
-    \return "AVCENC_SUCCESS for success, AVCENC_FAIL for fail for id not found."
-    */
-    OSCL_IMPORT_REF AVCEnc_Status PVAVCEncReleaseRecon(AVCHandle *avcHandle, AVCFrameIO *recon);
-
-    /**
-    This function performs clean up operation including memory deallocation.
-    The encoder will also clear the list of input structures it has not released.
-    This implies that users must keep track of the number of input structure they have allocated
-    and free them accordingly.
-    \param "avcHandle"  "Handle to the AVC encoder library object."
-    */
-    OSCL_IMPORT_REF void    PVAVCCleanUpEncoder(AVCHandle *avcHandle);
-
-    /**
-    This function extracts statistics of the current frame. If the encoder has not finished
-    with the current frame, the result is not accurate.
-    \param "avcHandle"  "Handle to the AVC encoder library object."
-    \param "avcStats"   "Pointer to AVCEncFrameStats structure."
-    \return "void."
-    */
-    void PVAVCEncGetFrameStats(AVCHandle *avcHandle, AVCEncFrameStats *avcStats);
-
-    /**
-    These functions are used for the modification of encoding parameters.
-    To be polished.
-    */
-    OSCL_IMPORT_REF AVCEnc_Status PVAVCEncUpdateBitRate(AVCHandle *avcHandle, uint32 bitrate);
-    OSCL_IMPORT_REF AVCEnc_Status PVAVCEncUpdateFrameRate(AVCHandle *avcHandle, uint32 num, uint32 denom);
-    OSCL_IMPORT_REF AVCEnc_Status PVAVCEncUpdateIDRInterval(AVCHandle *avcHandle, int IDRInterval);
-    OSCL_IMPORT_REF AVCEnc_Status PVAVCEncIDRRequest(AVCHandle *avcHandle);
-    OSCL_IMPORT_REF AVCEnc_Status PVAVCEncUpdateIMBRefresh(AVCHandle *avcHandle, int numMB);
-
-
-#ifdef __cplusplus
-}
-#endif
-#endif  /* _AVCENC_API_H_ */
-
diff --git a/media/libstagefright/codecs/avc/enc/src/avcenc_int.h b/media/libstagefright/codecs/avc/enc/src/avcenc_int.h
deleted file mode 100644
index 22042a5..0000000
--- a/media/libstagefright/codecs/avc/enc/src/avcenc_int.h
+++ /dev/null
@@ -1,471 +0,0 @@
-/* ------------------------------------------------------------------
- * 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 file contains application function interfaces to the AVC encoder library
-and necessary type defitionitions and enumerations.
-@publishedAll
-*/
-
-#ifndef AVCENC_INT_H_INCLUDED
-#define AVCENC_INT_H_INCLUDED
-
-#ifndef AVCINT_COMMON_H_INCLUDED
-#include "avcint_common.h"
-#endif
-#ifndef AVCENC_API_H_INCLUDED
-#include "avcenc_api.h"
-#endif
-
-typedef float OsclFloat;
-
-/* Definition for the structures below */
-#define DEFAULT_ATTR    0 /* default memory attribute */
-#define MAX_INPUT_FRAME 30 /* some arbitrary number, it can be much higher than this. */
-#define MAX_REF_FRAME  16 /* max size of the RefPicList0 and RefPicList1 */
-#define MAX_REF_PIC_LIST 33
-
-#define MIN_QP          0
-#define MAX_QP          51
-#define SHIFT_QP        12
-#define  LAMBDA_ACCURACY_BITS         16
-#define  LAMBDA_FACTOR(lambda)        ((int)((double)(1<<LAMBDA_ACCURACY_BITS)*(lambda)+0.5))
-
-
-#define DISABLE_THRESHOLDING  0
-// for better R-D performance
-#define _LUMA_COEFF_COST_       4 //!< threshold for luma coeffs
-#define _CHROMA_COEFF_COST_     4 //!< threshold for chroma coeffs, used to be 7
-#define _LUMA_MB_COEFF_COST_    5 //!< threshold for luma coeffs of inter Macroblocks
-#define _LUMA_8x8_COEFF_COST_   5 //!< threshold for luma coeffs of 8x8 Inter Partition
-#define MAX_VALUE       999999   //!< used for start value for some variables
-
-#define  WEIGHTED_COST(factor,bits)   (((factor)*(bits))>>LAMBDA_ACCURACY_BITS)
-#define  MV_COST(f,s,cx,cy,px,py)     (WEIGHTED_COST(f,mvbits[((cx)<<(s))-(px)]+mvbits[((cy)<<((s)))-(py)]))
-#define  MV_COST_S(f,cx,cy,px,py)     (WEIGHTED_COST(f,mvbits[(cx)-(px)]+mvbits[(cy)-(py)]))
-
-/* for sub-pel search and interpolation */
-#define SUBPEL_PRED_BLK_SIZE 576 // 24x24
-#define REF_CENTER 75
-#define V2Q_H0Q 1
-#define V0Q_H2Q 2
-#define V2Q_H2Q 3
-
-/*
-#define V3Q_H0Q 1
-#define V3Q_H1Q 2
-#define V0Q_H1Q 3
-#define V1Q_H1Q 4
-#define V1Q_H0Q 5
-#define V1Q_H3Q 6
-#define V0Q_H3Q 7
-#define V3Q_H3Q 8
-#define V2Q_H3Q 9
-#define V2Q_H0Q 10
-#define V2Q_H1Q 11
-#define V2Q_H2Q 12
-#define V3Q_H2Q 13
-#define V0Q_H2Q 14
-#define V1Q_H2Q 15
-*/
-
-
-#define DEFAULT_OVERRUN_BUFFER_SIZE 1000
-
-// associated with the above cost model
-const uint8 COEFF_COST[2][16] =
-{
-    {3, 2, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9}
-};
-
-
-
-//! convert from H.263 QP to H.264 quant given by: quant=pow(2,QP/6)
-const int QP2QUANT[40] =
-{
-    1, 1, 1, 1, 2, 2, 2, 2,
-    3, 3, 3, 4, 4, 4, 5, 6,
-    6, 7, 8, 9, 10, 11, 13, 14,
-    16, 18, 20, 23, 25, 29, 32, 36,
-    40, 45, 51, 57, 64, 72, 81, 91
-};
-
-
-/**
-This enumeration keeps track of the internal status of the encoder whether it is doing
-something. The encoding flow follows the order in which these states are.
-@publishedAll
-*/
-typedef enum
-{
-    AVCEnc_Initializing = 0,
-    AVCEnc_Encoding_SPS,
-    AVCEnc_Encoding_PPS,
-    AVCEnc_Analyzing_Frame,
-    AVCEnc_WaitingForBuffer,  // pending state
-    AVCEnc_Encoding_Frame,
-} AVCEnc_State ;
-
-/**
-Bitstream structure contains bitstream related parameters such as the pointer
-to the buffer, the current byte position and bit position. The content of the
-bitstreamBuffer will be in EBSP format as the emulation prevention codes are
-automatically inserted as the RBSP is recorded.
-@publishedAll
-*/
-typedef struct tagEncBitstream
-{
-    uint8 *bitstreamBuffer; /* pointer to buffer memory   */
-    int buf_size;       /* size of the buffer memory */
-    int write_pos;      /* next position to write to bitstreamBuffer  */
-    int count_zeros;   /* count number of consecutive zero */
-    uint current_word;  /* byte-swapped (MSB left) current word to write to buffer */
-    int bit_left;      /* number of bit left in current_word */
-    uint8   *overrunBuffer;  /* extra output buffer to prevent current skip due to output buffer overrun*/
-    int     oBSize;     /* size of allocated overrun buffer */
-    void   *encvid; /* pointer to the main object */
-
-} AVCEncBitstream;
-
-/**
-This structure is used for rate control purpose and other performance related control
-variables such as, RD cost, statistics, motion search stuffs, etc.
-should be in this structure.
-@publishedAll
-*/
-
-
-typedef struct tagRDInfo
-{
-    int QP;
-    int actual_bits;
-    OsclFloat mad;
-    OsclFloat 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*/
-    OsclFloat mad;          /* mad for current frame, = video->avgMAD*/
-    int bitrate;        /* bitrate for current frame */
-    OsclFloat 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 */
-    OsclFloat 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 */
-    OsclFloat sum_QP;
-    int diff_counter;   /* diff_counter = -diff_counter_BTdst, or diff_counter_BTsrc */
-
-    /* For target bitrate or framerate update */
-    OsclFloat target_bits_per_frame;        /* = C = bitrate/framerate */
-    OsclFloat target_bits_per_frame_prev;   /* previous C */
-    OsclFloat aver_mad;                     /* so-far average mad could replace sum_mad */
-    OsclFloat aver_mad_prev;                /* previous average mad */
-    int   overlapped_win_size;          /* transition period of time */
-    int   encoded_frames_prev;          /* previous encoded_frames */
-} MultiPass;
-
-
-typedef struct tagdataPointArray
-{
-    int Qp;
-    int Rp;
-    OsclFloat Mp;   /* for MB-based RC */
-    struct tagdataPointArray *next;
-    struct tagdataPointArray *prev;
-} dataPointArray;
-
-typedef struct tagAVCRateControl
-{
-
-    /* these parameters are initialized by the users AVCEncParams */
-    /* bitrate-robustness tradeoff */
-    uint scdEnable; /* enable scene change detection */
-    int idrPeriod;  /* IDR period in number of frames */
-    int intraMBRate;   /* intra MB refresh rate per frame */
-    uint dpEnable;  /* enable data partitioning */
-
-    /* quality-complexity tradeoff */
-    uint subPelEnable;  /* enable quarter pel search */
-    int mvRange;    /* motion vector search range in +/- pixel */
-    uint subMBEnable;  /* enable sub MB prediction mode (4x4, 4x8, 8x4) */
-    uint rdOptEnable;  /* enable RD-opt mode selection */
-    uint twoPass; /* flag for 2 pass encoding ( for future )*/
-    uint bidirPred; /* bi-directional prediction for B-frame. */
-
-    uint rcEnable;  /* enable rate control, '1' on, '0' const QP */
-    int initQP; /* initial QP */
-
-    /* note the following 3 params are for HRD, these triplets can be a series
-    of triplets as the generalized HRD allows. SEI message must be generated in this case. */
-    /* We no longer have to differentiate between CBR and VBR. The users to the
-    AVC encoder lib will do the mapping from CBR/VBR to these parameters. */
-    int32 bitRate;  /* target bit rate for the overall clip in bits/second*/
-    int32 cpbSize;  /* coded picture buffer size in bytes */
-    int32 initDelayOffset; /* initial CBP removal delay in bits */
-
-    OsclFloat frame_rate; /* frame rate */
-    int srcInterval; /* source frame rate in msec */
-    int basicUnit;  /* number of macroblocks per BU */
-
-    /* Then internal parameters for the operation */
-    uint first_frame; /* a flag for the first frame */
-    int lambda_mf; /* for example */
-    int totalSAD;    /* SAD of current frame */
-
-    /*******************************************/
-    /* this part comes from MPEG4 rate control */
-    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 */
-    OsclFloat Ts;   /*number of seconds for the sequence  (or segment). e.g., 10 sec */
-    OsclFloat Ep;
-    OsclFloat 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;
-    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 */
-    OsclFloat X1;
-    OsclFloat X2;
-    OsclFloat X11;
-    OsclFloat M;            /*safe margin for the buffer */
-    OsclFloat 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     VBR_Enabled;
-
-    int totalFrameNumber; /* total coded frames, for debugging!!*/
-
-    char    oFirstTime;
-
-    int numFrameBits; /* keep track of number of bits of the current frame */
-    int NumberofHeaderBits;
-    int NumberofTextureBits;
-    int numMBHeaderBits;
-    int numMBTextureBits;
-    double *MADofMB;
-    int32 bitsPerFrame;
-
-    /* BX rate control, something like TMN8 rate control*/
-
-    MultiPass *pMP;
-
-    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 */
-    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 */
-
-} AVCRateControl;
-
-
-/**
-This structure is for the motion vector information. */
-typedef struct tagMV
-{
-    int x;
-    int y;
-    uint sad;
-} AVCMV;
-
-/**
-This structure contains function pointers for different platform dependent implementation of
-functions. */
-typedef struct tagAVCEncFuncPtr
-{
-
-    int (*SAD_MB_HalfPel[4])(uint8*, uint8*, int, void *);
-    int (*SAD_Macroblock)(uint8 *ref, uint8 *blk, int dmin_lx, void *extra_info);
-
-} AVCEncFuncPtr;
-
-/**
-This structure contains information necessary for correct padding.
-*/
-typedef struct tagPadInfo
-{
-    int i;
-    int width;
-    int j;
-    int height;
-} AVCPadInfo;
-
-
-#ifdef HTFM
-typedef struct tagHTFM_Stat
-{
-    int abs_dif_mad_avg;
-    uint countbreak;
-    int offsetArray[16];
-    int offsetRef[16];
-} HTFM_Stat;
-#endif
-
-
-/**
-This structure is the main object for AVC encoder library providing access to all
-global variables. It is allocated at PVAVCInitEncoder and freed at PVAVCCleanUpEncoder.
-@publishedAll
-*/
-typedef struct tagEncObject
-{
-
-    AVCCommonObj *common;
-
-    AVCEncBitstream     *bitstream; /* for current NAL */
-    uint8   *overrunBuffer;  /* extra output buffer to prevent current skip due to output buffer overrun*/
-    int     oBSize;     /* size of allocated overrun buffer */
-
-    /* rate control */
-    AVCRateControl      *rateCtrl; /* pointer to the rate control structure */
-
-    /* encoding operation */
-    AVCEnc_State        enc_state; /* encoding state */
-
-    AVCFrameIO          *currInput; /* pointer to the current input frame */
-
-    int                 currSliceGroup; /* currently encoded slice group id */
-
-    int     level[24][16], run[24][16]; /* scratch memory */
-    int     leveldc[16], rundc[16]; /* for DC component */
-    int     levelcdc[16], runcdc[16]; /* for chroma DC component */
-    int     numcoefcdc[2]; /* number of coefficient for chroma DC */
-    int     numcoefdc;      /* number of coefficients for DC component */
-
-    int     qp_const;
-    int     qp_const_c;
-    /********* intra prediction scratch memory **********************/
-    uint8   pred_i16[AVCNumI16PredMode][256]; /* save prediction for MB */
-    uint8   pred_i4[AVCNumI4PredMode][16];  /* save prediction for blk */
-    uint8   pred_ic[AVCNumIChromaMode][128];  /* for 2 chroma */
-
-    int     mostProbableI4Mode[16]; /* in raster scan order */
-    /********* motion compensation related variables ****************/
-    AVCMV   *mot16x16;          /* Saved motion vectors for 16x16 block*/
-    AVCMV(*mot16x8)[2];     /* Saved motion vectors for 16x8 block*/
-    AVCMV(*mot8x16)[2];     /* Saved motion vectors for 8x16 block*/
-    AVCMV(*mot8x8)[4];      /* Saved motion vectors for 8x8 block*/
-
-    /********* subpel position **************************************/
-    uint32  subpel_pred[SUBPEL_PRED_BLK_SIZE/*<<2*/]; /* all 16 sub-pel positions  */
-    uint8   *hpel_cand[9];      /* pointer to half-pel position */
-    int     best_hpel_pos;          /* best position */
-    uint8   qpel_cand[8][24*16];        /* pointer to quarter-pel position */
-    int     best_qpel_pos;
-    uint8   *bilin_base[9][4];    /* pointer to 4 position at top left of bilinear quarter-pel */
-
-    /* need for intra refresh rate */
-    uint8   *intraSearch;       /* Intra Array for MBs to be intra searched */
-    uint    firstIntraRefreshMBIndx; /* keep track for intra refresh */
-
-    int     i4_sad;             /* temporary for i4 mode SAD */
-    int     *min_cost;          /* Minimum cost for the all MBs */
-    int     lambda_mode;        /* Lagrange parameter for mode selection */
-    int     lambda_motion;      /* Lagrange parameter for MV selection */
-
-    uint8   *mvbits_array;      /* Table for bits spent in the cost funciton */
-    uint8   *mvbits;            /* An offset to the above array. */
-
-    /* to speedup the SAD calculation */
-    void *sad_extra_info;
-    uint8 currYMB[256];     /* interleaved current macroblock in HTFM order */
-
-#ifdef HTFM
-    int nrmlz_th[48];       /* Threshold for fast SAD calculation using HTFM */
-    HTFM_Stat htfm_stat;    /* For statistics collection */
-#endif
-
-    /* statistics */
-    int numIntraMB;         /* keep track of number of intra MB */
-
-    /* encoding complexity control */
-    uint fullsearch_enable; /* flag to enable full-pel full-search */
-
-    /* misc.*/
-    bool outOfBandParamSet; /* flag to enable out-of-band param set */
-
-    AVCSeqParamSet extSPS; /* for external SPS */
-    AVCPicParamSet extPPS; /* for external PPS */
-
-    /* time control */
-    uint32  prevFrameNum;   /* previous frame number starting from modTimeRef */
-    uint32  modTimeRef;     /* Reference modTime update every I-Vop*/
-    uint32  wrapModTime;    /* Offset to modTime Ref, rarely used */
-
-    uint    prevProcFrameNum;  /* previously processed frame number, could be skipped */
-    uint    prevCodedFrameNum;  /* previously encoded frame number */
-    /* POC related variables */
-    uint32  dispOrdPOCRef;      /* reference POC is displayer order unit. */
-
-    /* Function pointers */
-    AVCEncFuncPtr *functionPointer; /* store pointers to platform specific functions */
-
-    /* Application control data */
-    AVCHandle *avcHandle;
-
-
-} AVCEncObject;
-
-
-#endif /*AVCENC_INT_H_INCLUDED*/
-
diff --git a/media/libstagefright/codecs/avc/enc/src/avcenc_lib.h b/media/libstagefright/codecs/avc/enc/src/avcenc_lib.h
deleted file mode 100644
index 17e28ef..0000000
--- a/media/libstagefright/codecs/avc/enc/src/avcenc_lib.h
+++ /dev/null
@@ -1,1020 +0,0 @@
-/* ------------------------------------------------------------------
- * 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 file contains declarations of internal functions for AVC decoder library.
-@publishedAll
-*/
-#ifndef AVCENC_LIB_H_INCLUDED
-#define AVCENC_LIB_H_INCLUDED
-
-#ifndef AVCLIB_COMMON_H_INCLUDED
-#include "avclib_common.h"
-#endif
-#ifndef AVCENC_INT_H_INCLUDED
-#include "avcenc_int.h"
-#endif
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-    /*------------- block.c -------------------------*/
-
-    /**
-    This function perform residue calculation, transform, quantize, inverse quantize,
-    inverse transform and residue compensation on a 4x4 block.
-    \param "encvid" "Pointer to AVCEncObject."
-    \param "blkidx"  "raster scan block index of the current 4x4 block."
-    \param "cur"    "Pointer to the reconstructed block."
-    \param "org"    "Pointer to the original block."
-    \param "coef_cost"  "Pointer to the coefficient cost to be filled in and returned."
-    \return "Number of non-zero coefficients."
-    */
-    int dct_luma(AVCEncObject *encvid, int blkidx, uint8 *cur, uint8 *org, int *coef_cost);
-
-    /**
-    This function performs IDCT on an INTER macroblock.
-    \param "video"  "Pointer to AVCCommonObj."
-    \param "curL"   "Pointer to the origin of the macroblock on the current frame."
-    \param "currMB" "Pointer to the AVCMacroblock structure."
-    \param "picPitch" "Pitch of the current frame."
-    \return "void".
-    */
-    void MBInterIdct(AVCCommonObj *video, uint8 *curL, AVCMacroblock *currMB, int picPitch);
-
-    /**
-    This function perform residue calculation, transform, quantize, inverse quantize,
-    inverse transform and residue compensation on a macroblock.
-    \param "encvid" "Pointer to AVCEncObject."
-    \param "curL"   "Pointer to the reconstructed MB."
-    \param "orgL"    "Pointer to the original MB."
-    \return "void"
-    */
-    void dct_luma_16x16(AVCEncObject *encvid, uint8 *curL, uint8 *orgL);
-
-    /**
-    This function perform residue calculation, transform, quantize, inverse quantize,
-    inverse transform and residue compensation for chroma components of an MB.
-    \param "encvid" "Pointer to AVCEncObject."
-    \param "curC"   "Pointer to the reconstructed MB."
-    \param "orgC"    "Pointer to the original MB."
-    \param "cr"     "Flag whether it is Cr or not."
-    \return "void"
-    */
-    void dct_chroma(AVCEncObject *encvid, uint8 *curC, uint8 *orgC, int cr);
-
-    /*----------- init.c ------------------*/
-    /**
-    This function interprets the encoding parameters provided by users in encParam.
-    The results are kept in AVCEncObject, AVCSeqParamSet, AVCPicParamSet and AVCSliceHeader.
-    \param "encvid"     "Pointer to AVCEncObject."
-    \param "encParam"   "Pointer to AVCEncParam."
-    \param "extSPS"     "External SPS template to be followed. NULL if not present."
-    \param "extPPS"     "External PPS template to be followed. NULL if not present."
-    \return "see AVCEnc_Status."
-    */
-    AVCEnc_Status  SetEncodeParam(AVCHandle *avcHandle, AVCEncParams *encParam,
-                                  void *extSPS, void *extPPS);
-
-    /**
-    This function verifies the encoding parameters whether they meet the set of supported
-    tool by a specific profile. If the profile is not set, it will just find the closest
-    profile instead of verifying it.
-    \param "video"  "Pointer to AVCEncObject."
-    \param "seqParam"   "Pointer to AVCSeqParamSet."
-    \param "picParam"   "Pointer to AVCPicParamSet."
-    \return "AVCENC_SUCCESS if success,
-            AVCENC_PROFILE_NOT_SUPPORTED if the specified profile
-                is not supported by this version of the library,
-            AVCENC_TOOLS_NOT_SUPPORTED if any of the specified encoding tools are
-            not supported by the user-selected profile."
-    */
-    AVCEnc_Status VerifyProfile(AVCEncObject *video, AVCSeqParamSet *seqParam, AVCPicParamSet *picParam);
-
-    /**
-    This function verifies the encoding parameters whether they meet the requirement
-    for a specific level. If the level is not set, it will just find the closest
-    level instead of verifying it.
-    \param "video"  "Pointer to AVCEncObject."
-    \param "seqParam"   "Pointer to AVCSeqParamSet."
-    \param "picParam"   "Pointer to AVCPicParamSet."
-    \return "AVCENC_SUCCESS if success,
-            AVCENC_LEVEL_NOT_SUPPORTED if the specified level
-                is not supported by this version of the library,
-            AVCENC_LEVEL_FAIL if any of the encoding parameters exceed
-            the range of the user-selected level."
-    */
-    AVCEnc_Status VerifyLevel(AVCEncObject *video, AVCSeqParamSet *seqParam, AVCPicParamSet *picParam);
-
-    /**
-    This funciton initializes the frame encoding by setting poc/frame_num related parameters. it
-    also performs motion estimation.
-    \param "encvid" "Pointer to the AVCEncObject."
-    \return "AVCENC_SUCCESS if success, AVCENC_NO_PICTURE if there is no input picture
-            in the queue to encode, AVCENC_POC_FAIL or AVCENC_CONSECUTIVE_NONREF for POC
-            related errors, AVCENC_NEW_IDR if new IDR is detected."
-    */
-    AVCEnc_Status InitFrame(AVCEncObject *encvid);
-
-    /**
-    This function initializes slice header related variables and other variables necessary
-    for decoding one slice.
-    \param "encvid" "Pointer to the AVCEncObject."
-    \return "AVCENC_SUCCESS if success."
-    */
-    AVCEnc_Status InitSlice(AVCEncObject *encvid);
-
-    /*----------- header.c ----------------*/
-    /**
-    This function performs bitstream encoding of the sequence parameter set NAL.
-    \param "encvid" "Pointer to the AVCEncObject."
-    \param "stream" "Pointer to AVCEncBitstream."
-    \return "AVCENC_SUCCESS if success or AVCENC_SPS_FAIL or others for unexpected failure which
-    should not occur. The SPS parameters should all be verified before this function is called."
-    */
-    AVCEnc_Status EncodeSPS(AVCEncObject *encvid, AVCEncBitstream *stream);
-
-    /**
-    This function encodes the VUI parameters into the sequence parameter set bitstream.
-    \param "stream" "Pointer to AVCEncBitstream."
-    \param "vui"    "Pointer to AVCVUIParams."
-    \return "nothing."
-    */
-    void EncodeVUI(AVCEncBitstream* stream, AVCVUIParams* vui);
-
-    /**
-    This function encodes HRD parameters into the sequence parameter set bitstream
-    \param "stream" "Pointer to AVCEncBitstream."
-    \param "hrd"    "Pointer to AVCHRDParams."
-    \return "nothing."
-    */
-    void EncodeHRD(AVCEncBitstream* stream, AVCHRDParams* hrd);
-
-
-    /**
-    This function performs bitstream encoding of the picture parameter set NAL.
-    \param "encvid" "Pointer to the AVCEncObject."
-    \param "stream" "Pointer to AVCEncBitstream."
-    \return "AVCENC_SUCCESS if success or AVCENC_PPS_FAIL or others for unexpected failure which
-    should not occur. The SPS parameters should all be verified before this function is called."
-    */
-    AVCEnc_Status EncodePPS(AVCEncObject *encvid, AVCEncBitstream *stream);
-
-    /**
-    This function encodes slice header information which has been initialized or fabricated
-    prior to entering this funciton.
-    \param "encvid" "Pointer to the AVCEncObject."
-    \param "stream" "Pointer to AVCEncBitstream."
-    \return "AVCENC_SUCCESS if success or bitstream fail statuses."
-    */
-    AVCEnc_Status EncodeSliceHeader(AVCEncObject *encvid, AVCEncBitstream *stream);
-
-    /**
-    This function encodes reference picture list reordering relted syntax.
-    \param "video" "Pointer to AVCCommonObj."
-    \param "stream" "Pointer to AVCEncBitstream."
-    \param "sliceHdr" "Pointer to AVCSliceHdr."
-    \param "slice_type" "Value of slice_type - 5 if greater than 5."
-    \return "AVCENC_SUCCESS for success and AVCENC_FAIL otherwise."
-    */
-    AVCEnc_Status ref_pic_list_reordering(AVCCommonObj *video, AVCEncBitstream *stream, AVCSliceHeader *sliceHdr, int slice_type);
-
-    /**
-    This function encodes dec_ref_pic_marking related syntax.
-    \param "video" "Pointer to AVCCommonObj."
-    \param "stream" "Pointer to AVCEncBitstream."
-    \param "sliceHdr" "Pointer to AVCSliceHdr."
-    \return "AVCENC_SUCCESS for success and AVCENC_FAIL otherwise."
-    */
-    AVCEnc_Status dec_ref_pic_marking(AVCCommonObj *video, AVCEncBitstream *stream, AVCSliceHeader *sliceHdr);
-
-    /**
-    This function initializes the POC related variables and the POC syntax to be encoded
-    to the slice header derived from the disp_order and is_reference flag of the original
-    input frame to be encoded.
-    \param "video"  "Pointer to the AVCEncObject."
-    \return "AVCENC_SUCCESS if success,
-            AVCENC_POC_FAIL if the poc type is undefined or
-            AVCENC_CONSECUTIVE_NONREF if there are consecutive non-reference frame for POC type 2."
-    */
-    AVCEnc_Status InitPOC(AVCEncObject *video);
-
-    /**
-    This function performs POC related operation after a picture is decoded.
-    \param "video" "Pointer to AVCCommonObj."
-    \return "AVCENC_SUCCESS"
-    */
-    AVCEnc_Status PostPOC(AVCCommonObj *video);
-
-    /*----------- bitstream_io.c ----------------*/
-    /**
-    This function initializes the bitstream structure with the information given by
-    the users.
-    \param "bitstream"  "Pointer to the AVCEncBitstream structure."
-    \param "buffer"     "Pointer to the unsigned char buffer for output."
-    \param "buf_size"   "The size of the buffer in bytes."
-    \param "overrunBuffer"  "Pointer to extra overrun buffer."
-    \param "oBSize"     "Size of overrun buffer in bytes."
-    \return "AVCENC_SUCCESS if success, AVCENC_BITSTREAM_INIT_FAIL if fail"
-    */
-    AVCEnc_Status BitstreamEncInit(AVCEncBitstream *bitstream, uint8 *buffer, int buf_size,
-                                   uint8 *overrunBuffer, int oBSize);
-
-    /**
-    This function writes the data from the cache into the bitstream buffer. It also adds the
-    emulation prevention code if necessary.
-    \param "stream"     "Pointer to the AVCEncBitstream structure."
-    \return "AVCENC_SUCCESS if success or AVCENC_BITSTREAM_BUFFER_FULL if fail."
-    */
-    AVCEnc_Status AVCBitstreamSaveWord(AVCEncBitstream *stream);
-
-    /**
-    This function writes the codeword into the cache which will eventually be written to
-    the bitstream buffer.
-    \param "stream"     "Pointer to the AVCEncBitstream structure."
-    \param "nBits"      "Number of bits in the codeword."
-    \param "code"       "The codeword."
-    \return "AVCENC_SUCCESS if success or AVCENC_BITSTREAM_BUFFER_FULL if fail."
-    */
-    AVCEnc_Status BitstreamWriteBits(AVCEncBitstream *stream, int nBits, uint code);
-
-    /**
-    This function writes one bit of data into the cache which will eventually be written
-    to the bitstream buffer.
-    \param "stream"     "Pointer to the AVCEncBitstream structure."
-    \param "code"       "The codeword."
-    \return "AVCENC_SUCCESS if success or AVCENC_BITSTREAM_BUFFER_FULL if fail."
-    */
-    AVCEnc_Status BitstreamWrite1Bit(AVCEncBitstream *stream, uint code);
-
-    /**
-    This function adds trailing bits to the bitstream and reports back the final EBSP size.
-    \param "stream"     "Pointer to the AVCEncBitstream structure."
-    \param "nal_size"   "Output the final NAL size."
-    \return "AVCENC_SUCCESS if success or AVCENC_BITSTREAM_BUFFER_FULL if fail."
-    */
-    AVCEnc_Status BitstreamTrailingBits(AVCEncBitstream *bitstream, uint *nal_size);
-
-    /**
-    This function checks whether the current bit position is byte-aligned or not.
-    \param "stream" "Pointer to the bitstream structure."
-    \return "true if byte-aligned, false otherwise."
-    */
-    bool byte_aligned(AVCEncBitstream *stream);
-
-
-    /**
-    This function checks the availability of overrun buffer and switches to use it when
-    normal bufffer is not big enough.
-    \param "stream" "Pointer to the bitstream structure."
-    \param "numExtraBytes" "Number of extra byte needed."
-    \return "AVCENC_SUCCESS or AVCENC_FAIL."
-    */
-    AVCEnc_Status AVCBitstreamUseOverrunBuffer(AVCEncBitstream* stream, int numExtraBytes);
-
-
-    /*-------------- intra_est.c ---------------*/
-
-    /** This function performs intra/inter decision based on ABE.
-    \param "encvid" "Pointer to AVCEncObject."
-    \param "min_cost"   "Best inter cost."
-    \param "curL"   "Pointer to the current MB origin in reconstructed frame."
-    \param "picPitch" "Pitch of the reconstructed frame."
-    \return "Boolean for intra mode."
-    */
-
-//bool IntraDecisionABE(AVCEncObject *encvid, int min_cost, uint8 *curL, int picPitch);
-    bool IntraDecision(int *min_cost, uint8 *cur, int pitch, bool ave);
-
-    /**
-    This function performs intra prediction mode search.
-    \param "encvid" "Pointer to AVCEncObject."
-    \param "mbnum"  "Current MB number."
-    \param "curL"   "Pointer to the current MB origin in reconstructed frame."
-    \param "picPitch" "Pitch of the reconstructed frame."
-    \return "void."
-    */
-    void MBIntraSearch(AVCEncObject *encvid, int mbnum, uint8 *curL, int picPitch);
-
-    /**
-    This function generates all the I16 prediction modes for an MB and keep it in
-    encvid->pred_i16.
-    \param "encvid" "Pointer to AVCEncObject."
-    \return "void"
-    */
-    void intrapred_luma_16x16(AVCEncObject *encvid);
-
-    /**
-    This function calculate the cost of all I16 modes and compare them to get the minimum.
-    \param "encvid" "Pointer to AVCEncObject."
-    \param "orgY"   "Pointer to the original luma MB."
-    \param "min_cost" "Pointer to the minimal cost so-far."
-    \return "void"
-    */
-    void find_cost_16x16(AVCEncObject *encvid, uint8 *orgY, int *min_cost);
-
-    /**
-    This function calculates the cost of each I16 mode.
-    \param "org"    "Pointer to the original luma MB."
-    \param "org_pitch" "Stride size of the original frame."
-    \param "pred"   "Pointer to the prediction values."
-    \param "min_cost" "Minimal cost so-far."
-    \return "Cost"
-    */
-
-    int cost_i16(uint8 *org, int org_pitch, uint8 *pred, int min_cost);
-
-    /**
-    This function generates all the I4 prediction modes and select the best one
-    for all the blocks inside a macroblock.It also calls dct_luma to generate the reconstructed
-    MB, and transform coefficients to be encoded.
-    \param "encvid" "Pointer to AVCEncObject."
-    \param "min_cost" "Pointer to the minimal cost so-far."
-    \return "void"
-    */
-    void mb_intra4x4_search(AVCEncObject *encvid, int *min_cost);
-
-    /**
-    This function calculates the most probable I4 mode of a given 4x4 block
-    from neighboring informationaccording to AVC/H.264 standard.
-    \param "video"  "Pointer to AVCCommonObj."
-    \param "blkidx" "The current block index."
-    \return "Most probable mode."
-    */
-    int FindMostProbableI4Mode(AVCCommonObj *video, int blkidx);
-
-    /**
-    This function is where a lot of actions take place in the 4x4 block level inside
-    mb_intra4x4_search.
-    \param "encvid" "Pointer to AVCEncObject."
-    \param "blkidx" "The current 4x4 block index."
-    \param "cur"    "Pointer to the reconstructed block."
-    \param "org"    "Pointer to the original block."
-    \return "Minimal cost, also set currMB->i4Mode"
-    */
-    int blk_intra4x4_search(AVCEncObject *encvid, int blkidx, uint8 *cur, uint8 *org);
-
-    /**
-    This function calculates the cost of a given I4 prediction mode.
-    \param "org"    "Pointer to the original block."
-    \param "org_pitch"  "Stride size of the original frame."
-    \param "pred"   "Pointer to the prediction block. (encvid->pred_i4)"
-    \param "cost"   "Pointer to the minimal cost (to be updated)."
-    \return "void"
-    */
-    void cost_i4(uint8 *org, int org_pitch, uint8 *pred, uint16 *cost);
-
-    /**
-    This function performs chroma intra search. Each mode is saved in encvid->pred_ic.
-    \param "encvid" "Pointer to AVCEncObject."
-    \return "void"
-    */
-    void chroma_intra_search(AVCEncObject *encvid);
-
-    /**
-    This function calculates the cost of a chroma prediction mode.
-    \param "orgCb"  "Pointer to the original Cb block."
-    \param "orgCr"  "Pointer to the original Cr block."
-    \param "org_pitch"  "Stride size of the original frame."
-    \param "pred"   "Pointer to the prediction block (encvid->pred_ic)"
-    \param "mincost"    "Minimal cost so far."
-    \return "Cost."
-    */
-
-    int SATDChroma(uint8 *orgCb, uint8 *orgCr, int org_pitch, uint8 *pred, int mincost);
-
-    /*-------------- motion_comp.c ---------------*/
-
-    /**
-    This is a main function to peform inter prediction.
-    \param "encvid"     "Pointer to AVCEncObject."
-    \param "video"      "Pointer to AVCCommonObj."
-    \return "void".
-    */
-    void AVCMBMotionComp(AVCEncObject *encvid, AVCCommonObj *video);
-
-
-    /**
-    This function is called for luma motion compensation.
-    \param "ref"    "Pointer to the origin of a reference luma."
-    \param "picwidth"   "Width of the picture."
-    \param "picheight"  "Height of the picture."
-    \param "x_pos"  "X-coordinate of the predicted block in quarter pel resolution."
-    \param "y_pos"  "Y-coordinate of the predicted block in quarter pel resolution."
-    \param "pred"   "Pointer to the output predicted block."
-    \param "pred_pitch" "Width of pred."
-    \param "blkwidth"   "Width of the current partition."
-    \param "blkheight"  "Height of the current partition."
-    \return "void"
-    */
-    void eLumaMotionComp(uint8 *ref, int picwidth, int picheight,
-                         int x_pos, int y_pos,
-                         uint8 *pred, int pred_pitch,
-                         int blkwidth, int blkheight);
-
-    void eFullPelMC(uint8 *in, int inwidth, uint8 *out, int outpitch,
-                    int blkwidth, int blkheight);
-
-    void eHorzInterp1MC(uint8 *in, int inpitch, uint8 *out, int outpitch,
-                        int blkwidth, int blkheight, int dx);
-
-    void eHorzInterp2MC(int *in, int inpitch, uint8 *out, int outpitch,
-                        int blkwidth, int blkheight, int dx);
-
-    void eHorzInterp3MC(uint8 *in, int inpitch, int *out, int outpitch,
-                        int blkwidth, int blkheight);
-
-    void eVertInterp1MC(uint8 *in, int inpitch, uint8 *out, int outpitch,
-                        int blkwidth, int blkheight, int dy);
-
-    void eVertInterp2MC(uint8 *in, int inpitch, int *out, int outpitch,
-                        int blkwidth, int blkheight);
-
-    void eVertInterp3MC(int *in, int inpitch, uint8 *out, int outpitch,
-                        int blkwidth, int blkheight, int dy);
-
-    void eDiagonalInterpMC(uint8 *in1, uint8 *in2, int inpitch,
-                           uint8 *out, int outpitch,
-                           int blkwidth, int blkheight);
-
-    void eChromaMotionComp(uint8 *ref, int picwidth, int picheight,
-                           int x_pos, int y_pos, uint8 *pred, int pred_pitch,
-                           int blkwidth, int blkheight);
-
-    void eChromaDiagonalMC_SIMD(uint8 *pRef, int srcPitch, int dx, int dy,
-                                uint8 *pOut, int predPitch, int blkwidth, int blkheight);
-
-    void eChromaHorizontalMC_SIMD(uint8 *pRef, int srcPitch, int dx, int dy,
-                                  uint8 *pOut, int predPitch, int blkwidth, int blkheight);
-
-    void eChromaVerticalMC_SIMD(uint8 *pRef, int srcPitch, int dx, int dy,
-                                uint8 *pOut, int predPitch, int blkwidth, int blkheight);
-
-    void eChromaFullMC_SIMD(uint8 *pRef, int srcPitch, int dx, int dy,
-                            uint8 *pOut, int predPitch, int blkwidth, int blkheight);
-
-    void eChromaVerticalMC2_SIMD(uint8 *pRef, int srcPitch, int dx, int dy,
-                                 uint8 *pOut, int predPitch, int blkwidth, int blkheight);
-
-    void eChromaHorizontalMC2_SIMD(uint8 *pRef, int srcPitch, int dx, int dy,
-                                   uint8 *pOut, int predPitch, int blkwidth, int blkheight);
-
-    void eChromaDiagonalMC2_SIMD(uint8 *pRef, int srcPitch, int dx, int dy,
-                                 uint8 *pOut, int predPitch, int blkwidth, int blkheight);
-
-
-    /*-------------- motion_est.c ---------------*/
-
-    /**
-    Allocate and initialize arrays necessary for motion search algorithm.
-    \param "envid" "Pointer to AVCEncObject."
-    \return "AVC_SUCCESS or AVC_MEMORY_FAIL."
-    */
-    AVCEnc_Status InitMotionSearchModule(AVCHandle *avcHandle);
-
-    /**
-    Clean up memory allocated in InitMotionSearchModule.
-    \param "envid" "Pointer to AVCEncObject."
-    \return "void."
-    */
-    void CleanMotionSearchModule(AVCHandle *avcHandle);
-
-
-    /**
-    This function performs motion estimation of all macroblocks in a frame during the InitFrame.
-    The goal is to find the best MB partition for inter and find out if intra search is needed for
-    any MBs. This intra MB tendency can be used for scene change detection.
-    \param "encvid" "Pointer to AVCEncObject."
-    \return "void"
-    */
-    void AVCMotionEstimation(AVCEncObject *encvid);
-
-    /**
-    This function performs repetitive edge padding to the reference picture by adding 16 pixels
-    around the luma and 8 pixels around the chromas.
-    \param "refPic" "Pointer to the reference picture."
-    \return "void"
-    */
-    void  AVCPaddingEdge(AVCPictureData *refPic);
-
-    /**
-    This function keeps track of intra refresh macroblock locations.
-    \param "encvid" "Pointer to the global array structure AVCEncObject."
-    \param "mblock" "Pointer to the array of AVCMacroblock structures."
-    \param "totalMB" "Total number of MBs in a frame."
-    \param "numRefresh" "Number of MB to be intra refresh in a single frame."
-    \return "void"
-    */
-    void AVCRasterIntraUpdate(AVCEncObject *encvid, AVCMacroblock *mblock, int totalMB, int numRefresh);
-
-#ifdef HTFM
-    void InitHTFM(VideoEncData *encvid, HTFM_Stat *htfm_stat, double *newvar, int *collect);
-    void UpdateHTFM(AVCEncObject *encvid, double *newvar, double *exp_lamda, HTFM_Stat *htfm_stat);
-    void CalcThreshold(double pf, double exp_lamda[], int nrmlz_th[]);
-    void    HTFMPrepareCurMB_AVC(AVCEncObject *encvid, HTFM_Stat *htfm_stat, uint8 *cur, int pitch);
-#endif
-
-    /**
-    This function reads the input MB into a smaller faster memory space to minimize the cache miss.
-    \param "encvid" "Pointer to the global AVCEncObject."
-    \param "cur"    "Pointer to the original input macroblock."
-    \param "pitch"  "Stride size of the input frame (luma)."
-    \return "void"
-    */
-    void    AVCPrepareCurMB(AVCEncObject *encvid, uint8 *cur, int pitch);
-
-    /**
-    Performs motion vector search for a macroblock.
-    \param "encvid" "Pointer to AVCEncObject structure."
-    \param "cur"    "Pointer to the current macroblock in the input frame."
-    \param "best_cand" "Array of best candidates (to be filled in and returned)."
-    \param "i0"     "X-coordinate of the macroblock."
-    \param "j0"     "Y-coordinate of the macroblock."
-    \param "type_pred" "Indicates the type of operations."
-    \param "FS_en"      "Flag for fullsearch enable."
-    \param "hp_guess"   "Guess for half-pel search."
-    \return "void"
-    */
-    void AVCMBMotionSearch(AVCEncObject *encvid, uint8 *cur, uint8 *best_cand[],
-                           int i0, int j0, int type_pred, int FS_en, int *hp_guess);
-
-//AVCEnc_Status AVCMBMotionSearch(AVCEncObject *encvid, AVCMacroblock *currMB, int mbNum,
-//                           int num_pass);
-
-    /**
-    Perform full-pel exhaustive search around the predicted MV.
-    \param "encvid" "Pointer to AVCEncObject structure."
-    \param "prev"   "Pointer to the reference frame."
-    \param "cur"    "Pointer to the input macroblock."
-    \param "imin"   "Pointer to minimal mv (x)."
-    \param "jmin"   "Pointer to minimal mv (y)."
-    \param "ilow, ihigh, jlow, jhigh"   "Lower bound on search range."
-    \param "cmvx, cmvy" "Predicted MV value."
-
-    \return "The cost function of the best candidate."
-    */
-    int AVCFullSearch(AVCEncObject *encvid, uint8 *prev, uint8 *cur,
-                      int *imin, int *jmin, int ilow, int ihigh, int jlow, int jhigh,
-                      int cmvx, int cmvy);
-
-    /**
-    Select candidates from neighboring blocks according to the type of the
-    prediction selection.
-    \param "mvx"    "Pointer to the candidate, x-coordinate."
-    \param "mvy"    "Pointer to the candidate, y-coordinate."
-    \param "num_can"    "Pointer to the number of candidates returned."
-    \param "imb"    "The MB index x-coordinate."
-    \param "jmb"    "The MB index y-coordinate."
-    \param "type_pred"  "Type of the prediction."
-    \param "cmvx, cmvy" "Pointer to predicted MV (modified version)."
-    \return "void."
-    */
-    void AVCCandidateSelection(int *mvx, int *mvy, int *num_can, int imb, int jmb,
-                               AVCEncObject *encvid, int type_pred, int *cmvx, int *cmvy);
-
-    /**
-    Utility function to move the values in the array dn according to the new
-    location to avoid redundant calculation.
-    \param "dn" "Array of integer of size 9."
-    \param "new_loc"    "New location index."
-    \return "void."
-    */
-    void AVCMoveNeighborSAD(int dn[], int new_loc);
-
-    /**
-    Find minimum index of dn.
-    \param "dn" "Array of integer of size 9."
-    \return "The index of dn with the smallest dn[] value."
-    */
-    int AVCFindMin(int dn[]);
-
-
-    /*------------- findhalfpel.c -------------------*/
-
-    /**
-    Search for the best half-pel resolution MV around the full-pel MV.
-    \param "encvid" "Pointer to the global AVCEncObject structure."
-    \param "cur"    "Pointer to the current macroblock."
-    \param "mot"    "Pointer to the AVCMV array of the frame."
-    \param "ncand"  "Pointer to the origin of the fullsearch result."
-    \param "xpos"   "The current MB position in x."
-    \param "ypos"   "The current MB position in y."
-    \param "hp_guess"   "Input to help speedup the search."
-    \param "cmvx, cmvy" "Predicted motion vector use for mvcost."
-    \return "Minimal cost (SATD) without MV cost. (for rate control purpose)"
-    */
-    int AVCFindHalfPelMB(AVCEncObject *encvid, uint8 *cur, AVCMV *mot, uint8 *ncand,
-                         int xpos, int ypos, int hp_guess, int cmvx, int cmvy);
-
-    /**
-    This function generates sub-pel pixels required to do subpel MV search.
-    \param "subpel_pred" "Pointer to 2-D array, each array for each position."
-    \param "ncand" "Pointer to the full-pel center position in ref frame."
-    \param "lx" "Pitch of the ref frame."
-    \return "void"
-     */
-    void GenerateHalfPelPred(uint8 *subpel_pred, uint8 *ncand, int lx);
-
-    /**
-    This function calculate vertical interpolation at half-point of size 4x17.
-    \param "dst" "Pointer to destination."
-    \param "ref" "Pointer to the starting reference pixel."
-    \return "void."
-    */
-    void VertInterpWClip(uint8 *dst, uint8 *ref);
-
-    /**
-    This function generates quarter-pel pixels around the best half-pel result
-    during the sub-pel MV search.
-    \param "bilin_base"  "Array of pointers to be used as basis for q-pel interp."
-    \param "qpel_pred"  "Array of pointers pointing to quarter-pel candidates."
-    \param "hpel_pos" "Best half-pel position at the center."
-    \return "void"
-    */
-    void GenerateQuartPelPred(uint8 **bilin_base, uint8 *qpel_pred, int hpel_pos);
-
-    /**
-    This function calculates the SATD of a subpel candidate.
-    \param "cand"   "Pointer to a candidate."
-    \param "cur"    "Pointer to the current block."
-    \param "dmin"   "Min-so-far SATD."
-    \return "Sum of Absolute Transformed Difference."
-    */
-    int SATD_MB(uint8 *cand, uint8 *cur, int dmin);
-
-    /*------------- rate_control.c -------------------*/
-
-    /** This function is a utility function. It returns average QP of the previously encoded frame.
-    \param "rateCtrl" "Pointer to AVCRateControl structure."
-    \return "Average QP."
-    */
-    int GetAvgFrameQP(AVCRateControl *rateCtrl);
-
-    /**
-    This function takes the timestamp of the input and determine whether it should be encoded
-    or skipped.
-    \param "encvid" "Pointer to the AVCEncObject structure."
-    \param "rateCtrl"   "Pointer to the AVCRateControl structure."
-    \param "modTime"    "The 32 bit timestamp of the input frame."
-    \param "frameNum"   "Pointer to the frame number if to be encoded."
-    \return "AVC_SUCCESS or else."
-    */
-    AVCEnc_Status RCDetermineFrameNum(AVCEncObject *encvid, AVCRateControl *rateCtrl, uint32 modTime, uint *frameNum);
-
-    /**
-    This function updates the buffer fullness when frames are dropped either by the
-    rate control algorithm or by the users to make sure that target bit rate is still met.
-    \param "video" "Pointer to the common object structure."
-    \param "rateCtrl" "Pointer to rate control structure."
-    \param "frameInc" "Difference of the current frame number and previous frame number."
-    \return "void."
-    */
-    void RCUpdateBuffer(AVCCommonObj *video, AVCRateControl *rateCtrl, int frameInc);
-
-    /**
-    This function initializes rate control module and allocates necessary bufferes to do the job.
-    \param "avcHandle" "Pointer to the encoder handle."
-    \return "AVCENC_SUCCESS or AVCENC_MEMORY_FAIL."
-    */
-    AVCEnc_Status InitRateControlModule(AVCHandle *avcHandle);
-
-    /**
-    This function frees buffers allocated in InitRateControlModule.
-    \param "avcHandle" "Pointer to the encoder handle."
-    \return "void."
-    */
-    void CleanupRateControlModule(AVCHandle *avcHandle);
-
-    /**
-    This function is called at the beginning of each GOP or the first IDR frame. It calculates
-    target bits for a GOP.
-    \param "encvid" "Pointer to the encoder object."
-    \return "void."
-    */
-    void RCInitGOP(AVCEncObject *encvid);
-
-    /**
-    This function calculates target bits for a particular frame.
-    \param "video"  "Pointer to the AVCEncObject structure."
-    \return "void"
-    */
-    void RCInitFrameQP(AVCEncObject *video);
-
-    /**
-    This function calculates QP for the upcoming frame or basic unit.
-    \param "encvid" "Pointer to the encoder object."
-    \param "rateCtrl" "Pointer to the rate control object."
-    \return "QP value ranging from 0-51."
-    */
-    int  RCCalculateQP(AVCEncObject *encvid, AVCRateControl *rateCtrl);
-
-    /**
-    This function translates the luma QP to chroma QP and calculates lambda based on QP.
-    \param "video"  "Pointer to the AVCEncObject structure."
-    \return "void"
-    */
-    void RCInitChromaQP(AVCEncObject *encvid);
-
-    /**
-    This function is called before encoding each macroblock.
-    \param "encvid" "Pointer to the encoder object."
-    \return "void."
-    */
-    void RCInitMBQP(AVCEncObject *encvid);
-
-    /**
-    This function updates bits usage stats after encoding an macroblock.
-    \param "video" "Pointer to AVCCommonObj."
-    \param "rateCtrl" "Pointer to AVCRateControl."
-    \param "num_header_bits" "Number of bits used for MB header."
-    \param "num_texture_bits" "Number of bits used for MB texture."
-    \return "void"
-    */
-    void RCPostMB(AVCCommonObj *video, AVCRateControl *rateCtrl, int num_header_bits, int num_texture_bits);
-
-    /**
-    This function calculates the difference between prediction and original MB.
-    \param "encvid" "Pointer to the encoder object."
-    \param "currMB" "Pointer to the current macroblock structure."
-    \param "orgL" "Pointer to the original MB."
-    \param "orgPitch" "Pointer to the original picture pitch."
-    \return "void."
-    */
-    void RCCalculateMAD(AVCEncObject *encvid, AVCMacroblock *currMB, uint8 *orgL, int orgPitch);
-
-    /**
-    Restore QP related parameters of previous MB when current MB is skipped.
-    \param "currMB" "Pointer to the current macroblock."
-    \param "video"  "Pointer to the common video structure."
-    \param "encvid" "Pointer to the global encoding structure."
-    \return "void"
-    */
-    void RCRestoreQP(AVCMacroblock *currMB, AVCCommonObj *video, AVCEncObject *encvid);
-
-    /**
-    This function is called after done with a frame.
-    \param "encvid" "Pointer to the encoder object."
-    \return "AVCENC_SUCCESS or AVCENC_SKIPPED_PICTURE when bufer overflow (need to discard current frame)."
-    */
-    AVCEnc_Status RCUpdateFrame(AVCEncObject *encvid);
-
-    /*--------- residual.c -------------------*/
-
-    /**
-    This function encodes the intra pcm data and fill it in the corresponding location
-    on the current picture.
-    \param "video"  "Pointer to AVCEncObject."
-    \return "AVCENC_SUCCESS if success, or else for bitstream errors."
-    */
-    AVCEnc_Status EncodeIntraPCM(AVCEncObject *video);
-
-    /**
-    This function performs CAVLC syntax encoding on the run and level information of the coefficients.
-    The level and run arrays are elements in AVCEncObject structure, populated by TransQuantZZ,
-    TransQuantIntraDC and TransQuantChromaDC functions.
-    \param "video"  "Pointer to AVCEncObject."
-    \param "type"   "One of AVCResidualType for a particular 4x4 block."
-    \param "bindx"  "Block index or number of nonzero coefficients for AVC_Intra16DC and AVC_ChromaDC mode."
-    \param "currMB" "Pointer to the current macroblock structure."
-    \return "AVCENC_SUCCESS for success."
-    \Note   "This function has 32-bit machine specific instruction!!!!"
-    */
-    AVCEnc_Status enc_residual_block(AVCEncObject *encvid, AVCResidualType type, int bindx, AVCMacroblock *currMB);
-
-
-    /*------------- sad.c ---------------------------*/
-
-
-    int AVCSAD_MB_HalfPel_Cxhyh(uint8 *ref, uint8 *blk, int dmin_lx, void *extra_info);
-    int AVCSAD_MB_HalfPel_Cyh(uint8 *ref, uint8 *blk, int dmin_lx, void *extra_info);
-    int AVCSAD_MB_HalfPel_Cxh(uint8 *ref, uint8 *blk, int dmin_lx, void *extra_info);
-    int AVCSAD_Macroblock_C(uint8 *ref, uint8 *blk, int dmin_lx, void *extra_info);
-
-#ifdef HTFM /*  3/2/1, Hypothesis Testing Fast Matching */
-    int AVCSAD_MB_HP_HTFM_Collectxhyh(uint8 *ref, uint8 *blk, int dmin_x, void *extra_info);
-    int AVCSAD_MB_HP_HTFM_Collectyh(uint8 *ref, uint8 *blk, int dmin_x, void *extra_info);
-    int AVCSAD_MB_HP_HTFM_Collectxh(uint8 *ref, uint8 *blk, int dmin_x, void *extra_info);
-    int AVCSAD_MB_HP_HTFMxhyh(uint8 *ref, uint8 *blk, int dmin_lx, void *extra_info);
-    int AVCSAD_MB_HP_HTFMyh(uint8 *ref, uint8 *blk, int dmin_lx, void *extra_info);
-    int AVCSAD_MB_HP_HTFMxh(uint8 *ref, uint8 *blk, int dmin_lx, void *extra_info);
-    int AVCSAD_MB_HTFM_Collect(uint8 *ref, uint8 *blk, int dmin_lx, void *extra_info);
-    int AVCSAD_MB_HTFM(uint8 *ref, uint8 *blk, int dmin_lx, void *extra_info);
-#endif
-
-
-    /*------------- slice.c -------------------------*/
-
-    /**
-    This function performs the main encoding loop for a slice.
-    \param "encvid" "Pointer to AVCEncObject."
-    \return "AVCENC_SUCCESS for success, AVCENC_PICTURE_READY for end-of-picture and
-             AVCENC_FAIL or AVCENC_SLICE_EMPTY otherwise."
-    */
-    AVCEnc_Status AVCEncodeSlice(AVCEncObject *encvid);
-
-    /**
-    This function performs the main encoding operation for one macroblock.
-    \param "video" "pointer to AVCEncObject."
-    \return "AVCENC_SUCCESS for success, or other bitstream related failure status."
-    */
-    AVCEnc_Status EncodeMB(AVCEncObject *video);
-
-    /**
-    This function calls prediction INTRA/INTER functions, transform,
-    quantization and zigzag scanning to get the run-level symbols.
-    \param "encvid" "pointer to AVCEncObject."
-    \param "curL"   "pointer to Luma component of the current frame.
-    \param "curCb"  "pointer to Cb component of the current frame.
-    \param "curCr"  "pointer to Cr component of the current frame.
-    \return "void for now."
-     */
-    void MBPredTransQuantZZ(AVCEncObject *encvid, uint8 *curL, uint8 *curCb, uint8 *curCr);
-
-    /**
-    This function copies the content of the prediction MB into the reconstructed YUV
-    frame directly.
-    \param "curL"   "Pointer to the destination Y component."
-    \param "curCb"  "Pointer to the destination Cb component."
-    \param "curCr"  "Pointer to the destination Cr component."
-    \param "predBlock"  "Pointer to the prediction MB."
-    \param "picWidth"   "The width of the frame."
-    \return "None."
-    */
-    void Copy_MB(uint8 *curL, uint8 *curCb, uint8 *curCr, uint8 *predBlock, int picWidth);
-
-    /**
-    This function encodes the mb_type, CBP, prediction mode, ref idx and MV.
-    \param "currMB" "Pointer to the current macroblock structure."
-    \param "video" "Pointer to the AVCEncObject structure."
-    \return "AVCENC_SUCCESS for success or else for fail."
-    */
-    AVCEnc_Status EncodeMBHeader(AVCMacroblock *currMB, AVCEncObject *video);
-
-    /**
-    This function finds the right mb_type for a macroblock given the mbMode, CBP,
-    NumPart, PredPartMode.
-    \param "currMB" "Pointer to the current macroblock structure."
-    \param "slice_type" "Value of the slice_type."
-    \return "mb_type."
-    */
-    uint InterpretMBType(AVCMacroblock *currMB, int slice_type);
-
-    /**
-    This function encodes the mb_pred part of the macroblock data.
-    \param "video"  "Pointer to the AVCCommonObj structure."
-    \param "currMB" "Pointer to the current macroblock structure."
-    \param "stream" "Pointer to the AVCEncBitstream structure."
-    \return "AVCENC_SUCCESS for success or bitstream fail status."
-    */
-    AVCEnc_Status mb_pred(AVCCommonObj *video, AVCMacroblock *currMB, AVCEncBitstream *stream);
-
-    /**
-    This function encodes the sub_mb_pred part of the macroblock data.
-    \param "video"  "Pointer to the AVCCommonObj structure."
-    \param "currMB" "Pointer to the current macroblock structure."
-    \param "stream" "Pointer to the AVCEncBitstream structure."
-    \return "AVCENC_SUCCESS for success or bitstream fail status."
-    */
-    AVCEnc_Status sub_mb_pred(AVCCommonObj *video, AVCMacroblock *currMB, AVCEncBitstream *stream);
-
-    /**
-    This function interprets the sub_mb_type and sets necessary information
-    when the slice type is AVC_P_SLICE.
-    in the macroblock structure.
-    \param "mblock" "Pointer to current AVCMacroblock."
-    \param "sub_mb_type" "From the syntax bitstream."
-    \return "void"
-    */
-    void InterpretSubMBTypeP(AVCMacroblock *mblock, uint *sub_mb_type);
-
-    /**
-    This function interprets the sub_mb_type and sets necessary information
-    when the slice type is AVC_B_SLICE.
-    in the macroblock structure.
-    \param "mblock" "Pointer to current AVCMacroblock."
-    \param "sub_mb_type" "From the syntax bitstream."
-    \return "void"
-    */
-    void InterpretSubMBTypeB(AVCMacroblock *mblock, uint *sub_mb_type);
-
-    /**
-    This function encodes intra 4x4 mode. It calculates the predicted I4x4 mode and the
-    remnant to be encoded.
-    \param "video"  "Pointer to AVCEncObject structure."
-    \param "currMB" "Pointer to the AVCMacroblock structure."
-    \param "stream" "Pointer to AVCEncBitstream sructure."
-    \return "AVCENC_SUCCESS for success."
-    */
-    AVCEnc_Status EncodeIntra4x4Mode(AVCCommonObj *video, AVCMacroblock *currMB, AVCEncBitstream *stream);
-
-    /*------------- vlc_encode.c -----------------------*/
-    /**
-    This function encodes and writes a value into an Exp-Golomb codeword.
-    \param "bitstream" "Pointer to AVCEncBitstream."
-    \param "codeNum" "Pointer to the value of the codeNum."
-    \return "AVCENC_SUCCESS for success or bitstream error messages for fail."
-    */
-    AVCEnc_Status ue_v(AVCEncBitstream *bitstream, uint codeNum);
-
-    /**
-    This function maps and encodes signed Exp-Golomb codes.
-    \param "bitstream" "Pointer to AVCEncBitstream."
-    \param "value"  "Pointer to syntax element value."
-    \return "AVCENC_SUCCESS or AVCENC_FAIL."
-    */
-    AVCEnc_Status  se_v(AVCEncBitstream *bitstream, int value);
-
-    /**
-    This function maps and encodes truncated Exp-Golomb codes.
-    \param "bitstream" "Pointer to AVCEncBitstream."
-    \param "value"  "Pointer to syntax element value."
-    \param "range"  "Range of the value as input to determine the algorithm."
-    \return "AVCENC_SUCCESS or AVCENC_FAIL."
-    */
-    AVCEnc_Status te_v(AVCEncBitstream *bitstream, uint value, uint range);
-
-    /**
-    This function creates Exp-Golomb codeword from codeNum.
-    \param "bitstream" "Pointer to AVCEncBitstream."
-    \param "codeNum" "Pointer to the codeNum value."
-    \return "AVCENC_SUCCESS for success or bitstream error messages for fail."
-    */
-    AVCEnc_Status SetEGBitstring(AVCEncBitstream *bitstream, uint codeNum);
-
-    /**
-    This function performs CAVLC encoding of the CBP (coded block pattern) of a macroblock
-    by calling ue_v() and then mapping the CBP to the corresponding VLC codeNum.
-    \param "currMB"  "Pointer to the current AVCMacroblock structure."
-    \param "stream"  "Pointer to the AVCEncBitstream."
-    \return "void"
-    */
-    AVCEnc_Status EncodeCBP(AVCMacroblock *currMB, AVCEncBitstream *stream);
-
-    /**
-    This function encodes trailing ones and total coefficient.
-    \param "stream" "Pointer to the AVCEncBitstream."
-    \param "TrailingOnes"   "The trailing one variable output."
-    \param "TotalCoeff" "The total coefficient variable output."
-    \param "nC" "Context for number of nonzero coefficient (prediction context)."
-    \return "AVCENC_SUCCESS for success or else for bitstream failure."
-    */
-    AVCEnc_Status ce_TotalCoeffTrailingOnes(AVCEncBitstream *stream, int TrailingOnes, int TotalCoeff, int nC);
-
-    /**
-    This function encodes trailing ones and total coefficient for chroma DC block.
-    \param "stream" "Pointer to the AVCEncBitstream."
-    \param "TrailingOnes"   "The trailing one variable output."
-    \param "TotalCoeff" "The total coefficient variable output."
-    \return "AVCENC_SUCCESS for success or else for bitstream failure."
-    */
-    AVCEnc_Status ce_TotalCoeffTrailingOnesChromaDC(AVCEncBitstream *stream, int TrailingOnes, int TotalCoeff);
-
-    /**
-    This function encodes total_zeros value as in Table 9-7 and 9-8.
-    \param "stream" "Pointer to the AVCEncBitstream."
-    \param "TotalZeros" "The total_zeros value."
-    \param "TotalCoeff" "The total coefficient variable output."
-    \return "AVCENC_SUCCESS for success or else for bitstream failure."
-    */
-    AVCEnc_Status ce_TotalZeros(AVCEncBitstream *stream, int total_zeros, int TotalCoeff);
-
-    /**
-    This function encodes total_zeros VLC syntax for chroma DC as in Table 9-9.
-    \param "stream" "Pointer to the AVCEncBitstream."
-    \param "TotalZeros" "The total_zeros value."
-    \param "TotalCoeff" "The total coefficient variable output."
-    \return "AVCENC_SUCCESS for success or else for bitstream failure."
-    */
-    AVCEnc_Status ce_TotalZerosChromaDC(AVCEncBitstream *stream, int total_zeros, int TotalCoeff);
-
-    /**
-    This function encodes run_before VLC syntax as in Table 9-10.
-    \param "stream" "Pointer to the AVCEncBitstream."
-    \param "run_before" "The run_before value."
-    \param "zerosLeft"  "The context for number of zeros left."
-    \return "AVCENC_SUCCESS for success or else for bitstream failure."
-    */
-    AVCEnc_Status ce_RunBefore(AVCEncBitstream *stream, int run_before, int zerosLeft);
-
-#ifdef __cplusplus
-}
-#endif
-
-
-#endif /* _AVCENC_LIB_H_ */
-
diff --git a/media/libstagefright/codecs/avc/enc/src/bitstream_io.cpp b/media/libstagefright/codecs/avc/enc/src/bitstream_io.cpp
deleted file mode 100644
index d71c327..0000000
--- a/media/libstagefright/codecs/avc/enc/src/bitstream_io.cpp
+++ /dev/null
@@ -1,339 +0,0 @@
-/* ------------------------------------------------------------------
- * 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 "avcenc_lib.h"
-
-#define WORD_SIZE 32
-
-/* array for trailing bit pattern as function of number of bits */
-/* the first one is unused. */
-const static uint8 trailing_bits[9] = {0, 0x1, 0x2, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80};
-
-/* ======================================================================== */
-/*  Function : BitstreamInit()                                              */
-/*  Date     : 11/4/2003                                                    */
-/*  Purpose  : Populate bitstream structure with bitstream buffer and size  */
-/*             it also initializes internal data                            */
-/*  In/out   :                                                              */
-/*  Return   : AVCENC_SUCCESS if successed, AVCENC_FAIL if failed.              */
-/*  Modified :                                                              */
-/* ======================================================================== */
-/* |--------|--------|----~~~~~-----|---------|---------|---------|
-   ^                                          ^write_pos          ^buf_size
-   bitstreamBuffer                  <--------->
-                                    current_word
-
-   |-----xxxxxxxxxxxxx|  = current_word 32 or 16 bits
-    <---->
-     bit_left
- ======================================================================== */
-
-AVCEnc_Status BitstreamEncInit(AVCEncBitstream *stream, uint8 *buffer, int buf_size,
-                               uint8 *overrunBuffer, int oBSize)
-{
-    if (stream == NULL || buffer == NULL || buf_size <= 0)
-    {
-        return AVCENC_BITSTREAM_INIT_FAIL;
-    }
-
-    stream->bitstreamBuffer = buffer;
-
-    stream->buf_size = buf_size;
-
-    stream->write_pos = 0;
-
-    stream->count_zeros = 0;
-
-    stream->current_word = 0;
-
-    stream->bit_left = WORD_SIZE;
-
-    stream->overrunBuffer = overrunBuffer;
-
-    stream->oBSize = oBSize;
-
-    return AVCENC_SUCCESS;
-}
-
-/* ======================================================================== */
-/*  Function : AVCBitstreamSaveWord()                                           */
-/*  Date     : 3/29/2004                                                    */
-/*  Purpose  : Save the current_word into the buffer, byte-swap, and        */
-/*              add emulation prevention insertion.                         */
-/*  In/out   :                                                              */
-/*  Return   : AVCENC_SUCCESS if successed, AVCENC_WRITE_FAIL if buffer is  */
-/*              full.                                                       */
-/*  Modified :                                                              */
-/* ======================================================================== */
-AVCEnc_Status AVCBitstreamSaveWord(AVCEncBitstream *stream)
-{
-    int num_bits;
-    uint8 *write_pnt, byte;
-    uint current_word;
-
-    /* check number of bytes in current_word, must always be byte-aligned!!!! */
-    num_bits = WORD_SIZE - stream->bit_left; /* must be multiple of 8 !!*/
-
-    if (stream->buf_size - stream->write_pos <= (num_bits >> 3) + 2) /* 2 more bytes for possible EPBS */
-    {
-        if (AVCENC_SUCCESS != AVCBitstreamUseOverrunBuffer(stream, (num_bits >> 3) + 2))
-        {
-            return AVCENC_BITSTREAM_BUFFER_FULL;
-        }
-    }
-
-    /* write word, byte-by-byte */
-    write_pnt = stream->bitstreamBuffer + stream->write_pos;
-    current_word = stream->current_word;
-    while (num_bits) /* no need to check stream->buf_size and stream->write_pos, taken care already */
-    {
-        num_bits -= 8;
-        byte = (current_word >> num_bits) & 0xFF;
-        if (stream->count_zeros == 2)
-        {   /* for num_bits = 32, this can add 2 more bytes extra for EPBS */
-            if (byte <= 3)
-            {
-                *write_pnt++ = 0x3;
-                stream->write_pos++;
-                stream->count_zeros = 0;
-            }
-        }
-        if (byte != 0)
-        {
-            *write_pnt++ = byte;
-            stream->write_pos++;
-            stream->count_zeros = 0;
-        }
-        else
-        {
-            stream->count_zeros++;
-            *write_pnt++ = byte;
-            stream->write_pos++;
-        }
-    }
-
-    /* reset current_word and bit_left */
-    stream->current_word = 0;
-    stream->bit_left = WORD_SIZE;
-
-    return AVCENC_SUCCESS;
-}
-
-/* ======================================================================== */
-/*  Function : BitstreamWriteBits()                                         */
-/*  Date     : 3/29/2004                                                    */
-/*  Purpose  : Write up to machine word.                                    */
-/*  In/out   : Unused bits in 'code' must be all zeros.                     */
-/*  Return   : AVCENC_SUCCESS if successed, AVCENC_WRITE_FAIL if buffer is  */
-/*              full.                                                       */
-/*  Modified :                                                              */
-/* ======================================================================== */
-AVCEnc_Status BitstreamWriteBits(AVCEncBitstream *stream, int nBits, uint code)
-{
-    AVCEnc_Status status = AVCENC_SUCCESS;
-    int bit_left = stream->bit_left;
-    uint current_word = stream->current_word;
-
-    //DEBUG_LOG(userData,AVC_LOGTYPE_INFO,"BitstreamWriteBits",nBits,-1);
-
-    if (nBits > WORD_SIZE) /* has to be taken care of specially */
-    {
-        return AVCENC_FAIL; /* for now */
-        /* otherwise, break it down to 2 write of less than 16 bits at a time. */
-    }
-
-    if (nBits <= bit_left) /* more bits left in current_word */
-    {
-        stream->current_word = (current_word << nBits) | code;
-        stream->bit_left -= nBits;
-        if (stream->bit_left == 0) /* prepare for the next word */
-        {
-            status = AVCBitstreamSaveWord(stream);
-            return status;
-        }
-    }
-    else
-    {
-        stream->current_word = (current_word << bit_left) | (code >> (nBits - bit_left));
-
-        nBits -= bit_left;
-
-        stream->bit_left = 0;
-
-        status = AVCBitstreamSaveWord(stream); /* save current word */
-
-        stream->bit_left = WORD_SIZE - nBits;
-
-        stream->current_word = code; /* no extra masking for code, must be handled before saving */
-    }
-
-    return status;
-}
-
-
-/* ======================================================================== */
-/*  Function : BitstreamWrite1Bit()                                         */
-/*  Date     : 3/30/2004                                                    */
-/*  Purpose  : Write 1 bit                                                  */
-/*  In/out   : Unused bits in 'code' must be all zeros.                     */
-/*  Return   : AVCENC_SUCCESS if successed, AVCENC_WRITE_FAIL if buffer is  */
-/*              full.                                                       */
-/*  Modified :                                                              */
-/* ======================================================================== */
-AVCEnc_Status BitstreamWrite1Bit(AVCEncBitstream *stream, uint code)
-{
-    AVCEnc_Status status;
-    uint current_word = stream->current_word;
-
-    //DEBUG_LOG(userData,AVC_LOGTYPE_INFO,"BitstreamWrite1Bit",code,-1);
-
-    //if(1 <= bit_left) /* more bits left in current_word */
-    /* we can assume that there always be positive bit_left in the current word */
-    stream->current_word = (current_word << 1) | code;
-    stream->bit_left--;
-    if (stream->bit_left == 0) /* prepare for the next word */
-    {
-        status = AVCBitstreamSaveWord(stream);
-        return status;
-    }
-
-    return AVCENC_SUCCESS;
-}
-
-
-/* ======================================================================== */
-/*  Function : BitstreamTrailingBits()                                      */
-/*  Date     : 3/31/2004                                                    */
-/*  Purpose  : Add trailing bits and report the final EBSP size.            */
-/*  In/out   :                                                              */
-/*  Return   : AVCENC_SUCCESS if successed, AVCENC_WRITE_FAIL if buffer is  */
-/*              full.                                                       */
-/*  Modified :                                                              */
-/* ======================================================================== */
-AVCEnc_Status BitstreamTrailingBits(AVCEncBitstream *bitstream, uint *nal_size)
-{
-    (void)(nal_size);
-
-    AVCEnc_Status status;
-    int bit_left = bitstream->bit_left;
-
-    bit_left &= 0x7; /* modulo by 8 */
-    if (bit_left == 0) bit_left = 8;
-    /* bitstream->bit_left == 0 cannot happen here since it would have been Saved already */
-
-    status = BitstreamWriteBits(bitstream, bit_left, trailing_bits[bit_left]);
-
-    if (status != AVCENC_SUCCESS)
-    {
-        return status;
-    }
-
-    /* if it's not saved, save it. */
-    //if(bitstream->bit_left<(WORD_SIZE<<3)) /* in fact, no need to check */
-    {
-        status = AVCBitstreamSaveWord(bitstream);
-    }
-
-    return status;
-}
-
-/* check whether it's byte-aligned */
-bool byte_aligned(AVCEncBitstream *stream)
-{
-    if (stream->bit_left % 8)
-        return false;
-    else
-        return true;
-}
-
-
-/* determine whether overrun buffer can be used or not */
-AVCEnc_Status AVCBitstreamUseOverrunBuffer(AVCEncBitstream* stream, int numExtraBytes)
-{
-    AVCEncObject *encvid = (AVCEncObject*)stream->encvid;
-
-    if (stream->overrunBuffer != NULL) // overrunBuffer is set
-    {
-        if (stream->bitstreamBuffer != stream->overrunBuffer) // not already used
-        {
-            if (stream->write_pos + numExtraBytes >= stream->oBSize)
-            {
-                stream->oBSize = stream->write_pos + numExtraBytes + 100;
-                stream->oBSize &= (~0x3); // make it multiple of 4
-
-                // allocate new overrun Buffer
-                if (encvid->overrunBuffer)
-                {
-                    encvid->avcHandle->CBAVC_Free(encvid->avcHandle->userData,
-                                                  encvid->overrunBuffer);
-                }
-
-                encvid->oBSize = stream->oBSize;
-                encvid->overrunBuffer = (uint8*) encvid->avcHandle->CBAVC_Malloc(encvid->avcHandle->userData,
-                                        stream->oBSize, DEFAULT_ATTR);
-
-                stream->overrunBuffer = encvid->overrunBuffer;
-                if (stream->overrunBuffer == NULL)
-                {
-                    return AVCENC_FAIL;
-                }
-            }
-
-            // copy everything to overrun buffer and start using it.
-            memcpy(stream->overrunBuffer, stream->bitstreamBuffer, stream->write_pos);
-            stream->bitstreamBuffer = stream->overrunBuffer;
-            stream->buf_size = stream->oBSize;
-        }
-        else // overrun buffer is already used
-        {
-            stream->oBSize = stream->write_pos + numExtraBytes + 100;
-            stream->oBSize &= (~0x3); // make it multiple of 4
-
-            // allocate new overrun buffer
-            encvid->oBSize = stream->oBSize;
-            encvid->overrunBuffer = (uint8*) encvid->avcHandle->CBAVC_Malloc(encvid->avcHandle->userData,
-                                    stream->oBSize, DEFAULT_ATTR);
-
-            if (encvid->overrunBuffer == NULL)
-            {
-                return AVCENC_FAIL;
-            }
-
-
-            // copy from the old buffer to new buffer
-            memcpy(encvid->overrunBuffer, stream->overrunBuffer, stream->write_pos);
-            // free old buffer
-            encvid->avcHandle->CBAVC_Free(encvid->avcHandle->userData,
-                                          stream->overrunBuffer);
-
-            // assign pointer to new buffer
-            stream->overrunBuffer = encvid->overrunBuffer;
-            stream->bitstreamBuffer = stream->overrunBuffer;
-            stream->buf_size = stream->oBSize;
-        }
-
-        return AVCENC_SUCCESS;
-    }
-    else // overrunBuffer is not enable.
-    {
-        return AVCENC_FAIL;
-    }
-
-}
-
-
-
diff --git a/media/libstagefright/codecs/avc/enc/src/block.cpp b/media/libstagefright/codecs/avc/enc/src/block.cpp
deleted file mode 100644
index 01e26a6..0000000
--- a/media/libstagefright/codecs/avc/enc/src/block.cpp
+++ /dev/null
@@ -1,1283 +0,0 @@
-/* ------------------------------------------------------------------
- * 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 "avcenc_lib.h"
-
-/* subtract with the prediction and do transformation */
-void trans(uint8 *cur, int pitch, uint8 *predBlock, int16 *dataBlock)
-{
-    int16 *ptr = dataBlock;
-    int r0, r1, r2, r3, j;
-    int curpitch = (uint)pitch >> 16;
-    int predpitch = (pitch & 0xFFFF);
-
-    /* horizontal */
-    j = 4;
-    while (j > 0)
-    {
-        /* calculate the residue first */
-        r0 = cur[0] - predBlock[0];
-        r1 = cur[1] - predBlock[1];
-        r2 = cur[2] - predBlock[2];
-        r3 = cur[3] - predBlock[3];
-
-        r0 += r3;           //ptr[0] + ptr[3];
-        r3 = r0 - (r3 << 1);    //ptr[0] - ptr[3];
-        r1 += r2;           //ptr[1] + ptr[2];
-        r2 = r1 - (r2 << 1);    //ptr[1] - ptr[2];
-
-        ptr[0] = r0 + r1;
-        ptr[2] = r0 - r1;
-        ptr[1] = (r3 << 1) + r2;
-        ptr[3] = r3 - (r2 << 1);
-
-        ptr += 16;
-        predBlock += predpitch;
-        cur += curpitch;
-        j--;
-    }
-    /* vertical */
-    ptr = dataBlock;
-    j = 4;
-    while (j > 0)
-    {
-        r0 = ptr[0] + ptr[48];
-        r3 = ptr[0] - ptr[48];
-        r1 = ptr[16] + ptr[32];
-        r2 = ptr[16] - ptr[32];
-
-        ptr[0] = r0 + r1;
-        ptr[32] = r0 - r1;
-        ptr[16] = (r3 << 1) + r2;
-        ptr[48] = r3 - (r2 << 1);
-
-        ptr++;
-        j--;
-    }
-
-    return ;
-}
-
-
-/* do residue transform quant invquant, invtrans and write output out */
-int dct_luma(AVCEncObject *encvid, int blkidx, uint8 *cur, uint8 *org, int *coef_cost)
-{
-    AVCCommonObj *video = encvid->common;
-    int org_pitch = encvid->currInput->pitch;
-    int pitch = video->currPic->pitch;
-    int16 *coef = video->block;
-    uint8 *pred = video->pred_block; // size 16 for a 4x4 block
-    int pred_pitch = video->pred_pitch;
-    int r0, r1, r2, r3, j, k, idx;
-    int *level, *run;
-    int Qq, Rq, q_bits, qp_const, quant;
-    int data, lev, zero_run;
-    int numcoeff;
-
-    coef += ((blkidx & 0x3) << 2) + ((blkidx >> 2) << 6); /* point to the 4x4 block */
-
-    /* first take a 4x4 transform */
-    /* horizontal */
-    j = 4;
-    while (j > 0)
-    {
-        /* calculate the residue first */
-        r0 = org[0] - pred[0];   /* OPTIMIZEABLE */
-        r1 = org[1] - pred[1];
-        r2 = org[2] - pred[2];
-        r3 = org[3] - pred[3];
-
-        r0 += r3;           //ptr[0] + ptr[3];
-        r3 = r0 - (r3 << 1);    //ptr[0] - ptr[3];
-        r1 += r2;           //ptr[1] + ptr[2];
-        r2 = r1 - (r2 << 1);    //ptr[1] - ptr[2];
-
-        coef[0] = r0 + r1;
-        coef[2] = r0 - r1;
-        coef[1] = (r3 << 1) + r2;
-        coef[3] = r3 - (r2 << 1);
-
-        coef += 16;
-        org += org_pitch;
-        pred += pred_pitch;
-        j--;
-    }
-    /* vertical */
-    coef -= 64;
-    pred -= (pred_pitch << 2);
-    j = 4;
-    while (j > 0)   /* OPTIMIZABLE */
-    {
-        r0 = coef[0] + coef[48];
-        r3 = coef[0] - coef[48];
-        r1 = coef[16] + coef[32];
-        r2 = coef[16] - coef[32];
-
-        coef[0] = r0 + r1;
-        coef[32] = r0 - r1;
-        coef[16] = (r3 << 1) + r2;
-        coef[48] = r3 - (r2 << 1);
-
-        coef++;
-        j--;
-    }
-
-    coef -= 4;
-
-    /* quant */
-    level = encvid->level[ras2dec[blkidx]];
-    run = encvid->run[ras2dec[blkidx]];
-
-    Rq = video->QPy_mod_6;
-    Qq = video->QPy_div_6;
-    qp_const = encvid->qp_const;
-    q_bits = 15 + Qq;
-
-    zero_run = 0;
-    numcoeff = 0;
-    for (k = 0; k < 16; k++)
-    {
-        idx = ZZ_SCAN_BLOCK[k]; /* map back to raster scan order */
-        data = coef[idx];
-        quant = quant_coef[Rq][k];
-        if (data > 0)
-        {
-            lev = data * quant + qp_const;
-        }
-        else
-        {
-            lev = -data * quant + qp_const;
-        }
-        lev >>= q_bits;
-        if (lev)
-        {
-            *coef_cost += ((lev > 1) ? MAX_VALUE : COEFF_COST[DISABLE_THRESHOLDING][zero_run]);
-
-            /* dequant */
-            quant = dequant_coefres[Rq][k];
-            if (data > 0)
-            {
-                level[numcoeff] = lev;
-                coef[idx] = (lev * quant) << Qq;
-            }
-            else
-            {
-                level[numcoeff] = -lev;
-                coef[idx] = (-lev * quant) << Qq;
-            }
-            run[numcoeff++] = zero_run;
-            zero_run = 0;
-        }
-        else
-        {
-            zero_run++;
-            coef[idx] = 0;
-        }
-    }
-
-    if (video->currMB->mb_intra) // only do inverse transform with intra block
-    {
-        if (numcoeff) /* then do inverse transform */
-        {
-            for (j = 4; j > 0; j--) /* horizontal */
-            {
-                r0 = coef[0] + coef[2];
-                r1 = coef[0] - coef[2];
-                r2 = (coef[1] >> 1) - coef[3];
-                r3 = coef[1] + (coef[3] >> 1);
-
-                coef[0] = r0 + r3;
-                coef[1] = r1 + r2;
-                coef[2] = r1 - r2;
-                coef[3] = r0 - r3;
-
-                coef += 16;
-            }
-
-            coef -= 64;
-            for (j = 4; j > 0; j--) /* vertical, has to be done after horizontal */
-            {
-                r0 = coef[0] + coef[32];
-                r1 = coef[0] - coef[32];
-                r2 = (coef[16] >> 1) - coef[48];
-                r3 = coef[16] + (coef[48] >> 1);
-                r0 += r3;
-                r3 = (r0 - (r3 << 1)); /* r0-r3 */
-                r1 += r2;
-                r2 = (r1 - (r2 << 1)); /* r1-r2 */
-                r0 += 32;
-                r1 += 32;
-                r2 += 32;
-                r3 += 32;
-
-                r0 = pred[0] + (r0 >> 6);
-                if ((uint)r0 > 0xFF)   r0 = 0xFF & (~(r0 >> 31));  /* clip */
-                r1 = *(pred += pred_pitch) + (r1 >> 6);
-                if ((uint)r1 > 0xFF)   r1 = 0xFF & (~(r1 >> 31));  /* clip */
-                r2 = *(pred += pred_pitch) + (r2 >> 6);
-                if ((uint)r2 > 0xFF)   r2 = 0xFF & (~(r2 >> 31));  /* clip */
-                r3 = pred[pred_pitch] + (r3 >> 6);
-                if ((uint)r3 > 0xFF)   r3 = 0xFF & (~(r3 >> 31));  /* clip */
-
-                *cur = r0;
-                *(cur += pitch) = r1;
-                *(cur += pitch) = r2;
-                cur[pitch] = r3;
-                cur -= (pitch << 1);
-                cur++;
-                pred -= (pred_pitch << 1);
-                pred++;
-                coef++;
-            }
-        }
-        else  // copy from pred to cur
-        {
-            *((uint32*)cur) = *((uint32*)pred);
-            *((uint32*)(cur += pitch)) = *((uint32*)(pred += pred_pitch));
-            *((uint32*)(cur += pitch)) = *((uint32*)(pred += pred_pitch));
-            *((uint32*)(cur += pitch)) = *((uint32*)(pred += pred_pitch));
-        }
-    }
-
-    return numcoeff;
-}
-
-
-void MBInterIdct(AVCCommonObj *video, uint8 *curL, AVCMacroblock *currMB, int picPitch)
-{
-    int16 *coef, *coef8 = video->block;
-    uint8 *cur;  // the same as curL
-    int b8, b4;
-    int r0, r1, r2, r3, j, blkidx;
-
-    for (b8 = 0; b8 < 4; b8++)
-    {
-        cur = curL;
-        coef = coef8;
-
-        if (currMB->CBP&(1 << b8))
-        {
-            for (b4 = 0; b4 < 4; b4++)
-            {
-                blkidx = blkIdx2blkXY[b8][b4];
-                /* do IDCT */
-                if (currMB->nz_coeff[blkidx])
-                {
-                    for (j = 4; j > 0; j--) /* horizontal */
-                    {
-                        r0 = coef[0] + coef[2];
-                        r1 = coef[0] - coef[2];
-                        r2 = (coef[1] >> 1) - coef[3];
-                        r3 = coef[1] + (coef[3] >> 1);
-
-                        coef[0] = r0 + r3;
-                        coef[1] = r1 + r2;
-                        coef[2] = r1 - r2;
-                        coef[3] = r0 - r3;
-
-                        coef += 16;
-                    }
-
-                    coef -= 64;
-                    for (j = 4; j > 0; j--) /* vertical, has to be done after horizontal */
-                    {
-                        r0 = coef[0] + coef[32];
-                        r1 = coef[0] - coef[32];
-                        r2 = (coef[16] >> 1) - coef[48];
-                        r3 = coef[16] + (coef[48] >> 1);
-                        r0 += r3;
-                        r3 = (r0 - (r3 << 1)); /* r0-r3 */
-                        r1 += r2;
-                        r2 = (r1 - (r2 << 1)); /* r1-r2 */
-                        r0 += 32;
-                        r1 += 32;
-                        r2 += 32;
-                        r3 += 32;
-
-                        r0 = cur[0] + (r0 >> 6);
-                        if ((uint)r0 > 0xFF)   r0 = 0xFF & (~(r0 >> 31));  /* clip */
-                        *cur = r0;
-                        r1 = *(cur += picPitch) + (r1 >> 6);
-                        if ((uint)r1 > 0xFF)   r1 = 0xFF & (~(r1 >> 31));  /* clip */
-                        *cur = r1;
-                        r2 = *(cur += picPitch) + (r2 >> 6);
-                        if ((uint)r2 > 0xFF)   r2 = 0xFF & (~(r2 >> 31));  /* clip */
-                        *cur = r2;
-                        r3 = cur[picPitch] + (r3 >> 6);
-                        if ((uint)r3 > 0xFF)   r3 = 0xFF & (~(r3 >> 31));  /* clip */
-                        cur[picPitch] = r3;
-
-                        cur -= (picPitch << 1);
-                        cur++;
-                        coef++;
-                    }
-                    cur -= 4;
-                    coef -= 4;
-                }
-                if (b4&1)
-                {
-                    cur += ((picPitch << 2) - 4);
-                    coef += 60;
-                }
-                else
-                {
-                    cur += 4;
-                    coef += 4;
-                }
-            }
-        }
-
-        if (b8&1)
-        {
-            curL += ((picPitch << 3) - 8);
-            coef8 += 120;
-        }
-        else
-        {
-            curL += 8;
-            coef8 += 8;
-        }
-    }
-
-    return ;
-}
-
-/* performa dct, quant, iquant, idct for the entire MB */
-void dct_luma_16x16(AVCEncObject *encvid, uint8 *curL, uint8 *orgL)
-{
-    AVCCommonObj *video = encvid->common;
-    int pitch = video->currPic->pitch;
-    int org_pitch = encvid->currInput->pitch;
-    AVCMacroblock *currMB = video->currMB;
-    int16 *coef = video->block;
-    uint8 *pred = encvid->pred_i16[currMB->i16Mode];
-    int blk_x, blk_y, j, k, idx, b8, b4;
-    int r0, r1, r2, r3, m0, m1, m2 , m3;
-    int data, lev;
-    int *level, *run, zero_run, ncoeff;
-    int Rq, Qq, quant, q_bits, qp_const;
-    int offset_cur[4], offset_pred[4], offset;
-
-    /* horizontal */
-    for (j = 16; j > 0; j--)
-    {
-        for (blk_x = 4; blk_x > 0; blk_x--)
-        {
-            /* calculate the residue first */
-            r0 = *orgL++ - *pred++;
-            r1 = *orgL++ - *pred++;
-            r2 = *orgL++ - *pred++;
-            r3 = *orgL++ - *pred++;
-
-            r0 += r3;           //ptr[0] + ptr[3];
-            r3 = r0 - (r3 << 1);    //ptr[0] - ptr[3];
-            r1 += r2;           //ptr[1] + ptr[2];
-            r2 = r1 - (r2 << 1);    //ptr[1] - ptr[2];
-
-            *coef++ = r0 + r1;
-            *coef++ = (r3 << 1) + r2;
-            *coef++ = r0 - r1;
-            *coef++ = r3 - (r2 << 1);
-        }
-        orgL += (org_pitch - 16);
-    }
-    pred -= 256;
-    coef -= 256;
-    /* vertical */
-    for (blk_y = 4; blk_y > 0; blk_y--)
-    {
-        for (j = 16; j > 0; j--)
-        {
-            r0 = coef[0] + coef[48];
-            r3 = coef[0] - coef[48];
-            r1 = coef[16] + coef[32];
-            r2 = coef[16] - coef[32];
-
-            coef[0] = r0 + r1;
-            coef[32] = r0 - r1;
-            coef[16] = (r3 << 1) + r2;
-            coef[48] = r3 - (r2 << 1);
-
-            coef++;
-        }
-        coef += 48;
-    }
-
-    /* then perform DC transform */
-    coef -= 256;
-    for (j = 4; j > 0; j--)
-    {
-        r0 = coef[0] + coef[12];
-        r3 = coef[0] - coef[12];
-        r1 = coef[4] + coef[8];
-        r2 = coef[4] - coef[8];
-
-        coef[0] = r0 + r1;
-        coef[8] = r0 - r1;
-        coef[4] = r3 + r2;
-        coef[12] = r3 - r2;
-        coef += 64;
-    }
-    coef -= 256;
-    for (j = 4; j > 0; j--)
-    {
-        r0 = coef[0] + coef[192];
-        r3 = coef[0] - coef[192];
-        r1 = coef[64] + coef[128];
-        r2 = coef[64] - coef[128];
-
-        coef[0] = (r0 + r1) >> 1;
-        coef[128] = (r0 - r1) >> 1;
-        coef[64] = (r3 + r2) >> 1;
-        coef[192] = (r3 - r2) >> 1;
-        coef += 4;
-    }
-
-    coef -= 16;
-    // then quantize DC
-    level = encvid->leveldc;
-    run = encvid->rundc;
-
-    Rq = video->QPy_mod_6;
-    Qq = video->QPy_div_6;
-    quant = quant_coef[Rq][0];
-    q_bits = 15 + Qq;
-    qp_const = encvid->qp_const;
-
-    zero_run = 0;
-    ncoeff = 0;
-    for (k = 0; k < 16; k++) /* in zigzag scan order */
-    {
-        idx = ZIGZAG2RASTERDC[k];
-        data = coef[idx];
-        if (data > 0)   // quant
-        {
-            lev = data * quant + (qp_const << 1);
-        }
-        else
-        {
-            lev = -data * quant + (qp_const << 1);
-        }
-        lev >>= (q_bits + 1);
-        if (lev) // dequant
-        {
-            if (data > 0)
-            {
-                level[ncoeff] = lev;
-                coef[idx] = lev;
-            }
-            else
-            {
-                level[ncoeff] = -lev;
-                coef[idx] = -lev;
-            }
-            run[ncoeff++] = zero_run;
-            zero_run = 0;
-        }
-        else
-        {
-            zero_run++;
-            coef[idx] = 0;
-        }
-    }
-
-    /* inverse transform DC */
-    encvid->numcoefdc = ncoeff;
-    if (ncoeff)
-    {
-        quant = dequant_coefres[Rq][0];
-
-        for (j = 0; j < 4; j++)
-        {
-            m0 = coef[0] + coef[4];
-            m1 = coef[0] - coef[4];
-            m2 = coef[8] + coef[12];
-            m3 = coef[8] - coef[12];
-
-
-            coef[0] = m0 + m2;
-            coef[4] = m0 - m2;
-            coef[8] = m1 - m3;
-            coef[12] = m1 + m3;
-            coef += 64;
-        }
-
-        coef -= 256;
-
-        if (Qq >= 2)  /* this way should be faster than JM */
-        {           /* they use (((m4*scale)<<(QPy/6))+2)>>2 for both cases. */
-            Qq -= 2;
-            for (j = 0; j < 4; j++)
-            {
-                m0 = coef[0] + coef[64];
-                m1 = coef[0] - coef[64];
-                m2 = coef[128] + coef[192];
-                m3 = coef[128] - coef[192];
-
-                coef[0] = ((m0 + m2) * quant) << Qq;
-                coef[64] = ((m0 - m2) * quant) << Qq;
-                coef[128] = ((m1 - m3) * quant) << Qq;
-                coef[192] = ((m1 + m3) * quant) << Qq;
-                coef += 4;
-            }
-            Qq += 2; /* restore the value */
-        }
-        else
-        {
-            Qq = 2 - Qq;
-            offset = 1 << (Qq - 1);
-
-            for (j = 0; j < 4; j++)
-            {
-                m0 = coef[0] + coef[64];
-                m1 = coef[0] - coef[64];
-                m2 = coef[128] + coef[192];
-                m3 = coef[128] - coef[192];
-
-                coef[0] = (((m0 + m2) * quant + offset) >> Qq);
-                coef[64] = (((m0 - m2) * quant + offset) >> Qq);
-                coef[128] = (((m1 - m3) * quant + offset) >> Qq);
-                coef[192] = (((m1 + m3) * quant + offset) >> Qq);
-                coef += 4;
-            }
-            Qq = 2 - Qq; /* restore the value */
-        }
-        coef -= 16; /* back to the origin */
-    }
-
-    /* now zigzag scan ac coefs, quant, iquant and itrans */
-    run = encvid->run[0];
-    level = encvid->level[0];
-
-    /* offset btw 4x4 block */
-    offset_cur[0] = 0;
-    offset_cur[1] = (pitch << 2) - 8;
-
-    /* offset btw 8x8 block */
-    offset_cur[2] = 8 - (pitch << 3);
-    offset_cur[3] = -8;
-
-    /* similarly for pred */
-    offset_pred[0] = 0;
-    offset_pred[1] = 56;
-    offset_pred[2] = -120;
-    offset_pred[3] = -8;
-
-    currMB->CBP = 0;
-
-    for (b8 = 0; b8 < 4; b8++)
-    {
-        for (b4 = 0; b4 < 4; b4++)
-        {
-
-            zero_run = 0;
-            ncoeff = 0;
-
-            for (k = 1; k < 16; k++)
-            {
-                idx = ZZ_SCAN_BLOCK[k]; /* map back to raster scan order */
-                data = coef[idx];
-                quant = quant_coef[Rq][k];
-                if (data > 0)
-                {
-                    lev = data * quant + qp_const;
-                }
-                else
-                {
-                    lev = -data * quant + qp_const;
-                }
-                lev >>= q_bits;
-                if (lev)
-                {   /* dequant */
-                    quant = dequant_coefres[Rq][k];
-                    if (data > 0)
-                    {
-                        level[ncoeff] = lev;
-                        coef[idx] = (lev * quant) << Qq;
-                    }
-                    else
-                    {
-                        level[ncoeff] = -lev;
-                        coef[idx] = (-lev * quant) << Qq;
-                    }
-                    run[ncoeff++] = zero_run;
-                    zero_run = 0;
-                }
-                else
-                {
-                    zero_run++;
-                    coef[idx] = 0;
-                }
-            }
-
-            currMB->nz_coeff[blkIdx2blkXY[b8][b4]] = ncoeff; /* in raster scan !!! */
-            if (ncoeff)
-            {
-                currMB->CBP |= (1 << b8);
-
-                // do inverse transform here
-                for (j = 4; j > 0; j--)
-                {
-                    r0 = coef[0] + coef[2];
-                    r1 = coef[0] - coef[2];
-                    r2 = (coef[1] >> 1) - coef[3];
-                    r3 = coef[1] + (coef[3] >> 1);
-
-                    coef[0] = r0 + r3;
-                    coef[1] = r1 + r2;
-                    coef[2] = r1 - r2;
-                    coef[3] = r0 - r3;
-
-                    coef += 16;
-                }
-                coef -= 64;
-                for (j = 4; j > 0; j--)
-                {
-                    r0 = coef[0] + coef[32];
-                    r1 = coef[0] - coef[32];
-                    r2 = (coef[16] >> 1) - coef[48];
-                    r3 = coef[16] + (coef[48] >> 1);
-
-                    r0 += r3;
-                    r3 = (r0 - (r3 << 1)); /* r0-r3 */
-                    r1 += r2;
-                    r2 = (r1 - (r2 << 1)); /* r1-r2 */
-                    r0 += 32;
-                    r1 += 32;
-                    r2 += 32;
-                    r3 += 32;
-                    r0 = pred[0] + (r0 >> 6);
-                    if ((uint)r0 > 0xFF)   r0 = 0xFF & (~(r0 >> 31));  /* clip */
-                    r1 = pred[16] + (r1 >> 6);
-                    if ((uint)r1 > 0xFF)   r1 = 0xFF & (~(r1 >> 31));  /* clip */
-                    r2 = pred[32] + (r2 >> 6);
-                    if ((uint)r2 > 0xFF)   r2 = 0xFF & (~(r2 >> 31));  /* clip */
-                    r3 = pred[48] + (r3 >> 6);
-                    if ((uint)r3 > 0xFF)   r3 = 0xFF & (~(r3 >> 31));  /* clip */
-                    *curL = r0;
-                    *(curL += pitch) = r1;
-                    *(curL += pitch) = r2;
-                    curL[pitch] = r3;
-                    curL -= (pitch << 1);
-                    curL++;
-                    pred++;
-                    coef++;
-                }
-            }
-            else  // do DC-only inverse
-            {
-                m0 = coef[0] + 32;
-
-                for (j = 4; j > 0; j--)
-                {
-                    r0 = pred[0] + (m0 >> 6);
-                    if ((uint)r0 > 0xFF)   r0 = 0xFF & (~(r0 >> 31));  /* clip */
-                    r1 = pred[16] + (m0 >> 6);
-                    if ((uint)r1 > 0xFF)   r1 = 0xFF & (~(r1 >> 31));  /* clip */
-                    r2 = pred[32] + (m0 >> 6);
-                    if ((uint)r2 > 0xFF)   r2 = 0xFF & (~(r2 >> 31));  /* clip */
-                    r3 = pred[48] + (m0 >> 6);
-                    if ((uint)r3 > 0xFF)   r3 = 0xFF & (~(r3 >> 31));  /* clip */
-                    *curL = r0;
-                    *(curL += pitch) = r1;
-                    *(curL += pitch) = r2;
-                    curL[pitch] = r3;
-                    curL -= (pitch << 1);
-                    curL++;
-                    pred++;
-                }
-                coef += 4;
-            }
-
-            run += 16;  // follow coding order
-            level += 16;
-            curL += offset_cur[b4&1];
-            pred += offset_pred[b4&1];
-            coef += offset_pred[b4&1];
-        }
-
-        curL += offset_cur[2 + (b8&1)];
-        pred += offset_pred[2 + (b8&1)];
-        coef += offset_pred[2 + (b8&1)];
-    }
-
-    return ;
-}
-
-
-void dct_chroma(AVCEncObject *encvid, uint8 *curC, uint8 *orgC, int cr)
-{
-    AVCCommonObj *video = encvid->common;
-    AVCMacroblock *currMB = video->currMB;
-    int org_pitch = (encvid->currInput->pitch) >> 1;
-    int pitch = (video->currPic->pitch) >> 1;
-    int pred_pitch = 16;
-    int16 *coef = video->block + 256;
-    uint8 *pred = video->pred_block;
-    int j, blk_x, blk_y, k, idx, b4;
-    int r0, r1, r2, r3, m0;
-    int Qq, Rq, qp_const, q_bits, quant;
-    int *level, *run, zero_run, ncoeff;
-    int data, lev;
-    int offset_cur[2], offset_pred[2], offset_coef[2];
-    uint8 nz_temp[4];
-    int  coeff_cost;
-
-    if (cr)
-    {
-        coef += 8;
-        pred += 8;
-    }
-
-    if (currMB->mb_intra == 0) // inter mode
-    {
-        pred = curC;
-        pred_pitch = pitch;
-    }
-
-    /* do 4x4 transform */
-    /* horizontal */
-    for (j = 8; j > 0; j--)
-    {
-        for (blk_x = 2; blk_x > 0; blk_x--)
-        {
-            /* calculate the residue first */
-            r0 = *orgC++ - *pred++;
-            r1 = *orgC++ - *pred++;
-            r2 = *orgC++ - *pred++;
-            r3 = *orgC++ - *pred++;
-
-            r0 += r3;           //ptr[0] + ptr[3];
-            r3 = r0 - (r3 << 1);    //ptr[0] - ptr[3];
-            r1 += r2;           //ptr[1] + ptr[2];
-            r2 = r1 - (r2 << 1);    //ptr[1] - ptr[2];
-
-            *coef++ = r0 + r1;
-            *coef++ = (r3 << 1) + r2;
-            *coef++ = r0 - r1;
-            *coef++ = r3 - (r2 << 1);
-
-        }
-        coef += 8; // coef pitch is 16
-        pred += (pred_pitch - 8); // pred_pitch is 16
-        orgC += (org_pitch - 8);
-    }
-    pred -= (pred_pitch << 3);
-    coef -= 128;
-    /* vertical */
-    for (blk_y = 2; blk_y > 0; blk_y--)
-    {
-        for (j = 8; j > 0; j--)
-        {
-            r0 = coef[0] + coef[48];
-            r3 = coef[0] - coef[48];
-            r1 = coef[16] + coef[32];
-            r2 = coef[16] - coef[32];
-
-            coef[0] = r0 + r1;
-            coef[32] = r0 - r1;
-            coef[16] = (r3 << 1) + r2;
-            coef[48] = r3 - (r2 << 1);
-
-            coef++;
-        }
-        coef += 56;
-    }
-    /* then perform DC transform */
-    coef -= 128;
-
-    /* 2x2 transform of DC components*/
-    r0 = coef[0];
-    r1 = coef[4];
-    r2 = coef[64];
-    r3 = coef[68];
-
-    coef[0] = r0 + r1 + r2 + r3;
-    coef[4] = r0 - r1 + r2 - r3;
-    coef[64] = r0 + r1 - r2 - r3;
-    coef[68] = r0 - r1 - r2 + r3;
-
-    Qq    = video->QPc_div_6;
-    Rq    = video->QPc_mod_6;
-    quant = quant_coef[Rq][0];
-    q_bits    = 15 + Qq;
-    qp_const = encvid->qp_const_c;
-
-    zero_run = 0;
-    ncoeff = 0;
-    run = encvid->runcdc + (cr << 2);
-    level = encvid->levelcdc + (cr << 2);
-
-    /* in zigzag scan order */
-    for (k = 0; k < 4; k++)
-    {
-        idx = ((k >> 1) << 6) + ((k & 1) << 2);
-        data = coef[idx];
-        if (data > 0)
-        {
-            lev = data * quant + (qp_const << 1);
-        }
-        else
-        {
-            lev = -data * quant + (qp_const << 1);
-        }
-        lev >>= (q_bits + 1);
-        if (lev)
-        {
-            if (data > 0)
-            {
-                level[ncoeff] = lev;
-                coef[idx] = lev;
-            }
-            else
-            {
-                level[ncoeff] = -lev;
-                coef[idx] = -lev;
-            }
-            run[ncoeff++] = zero_run;
-            zero_run = 0;
-        }
-        else
-        {
-            zero_run++;
-            coef[idx] = 0;
-        }
-    }
-
-    encvid->numcoefcdc[cr] = ncoeff;
-
-    if (ncoeff)
-    {
-        currMB->CBP |= (1 << 4); // DC present
-        // do inverse transform
-        quant = dequant_coefres[Rq][0];
-
-        r0 = coef[0] + coef[4];
-        r1 = coef[0] - coef[4];
-        r2 = coef[64] + coef[68];
-        r3 = coef[64] - coef[68];
-
-        r0 += r2;
-        r2 = r0 - (r2 << 1);
-        r1 += r3;
-        r3 = r1 - (r3 << 1);
-
-        if (Qq >= 1)
-        {
-            Qq -= 1;
-            coef[0] = (r0 * quant) << Qq;
-            coef[4] = (r1 * quant) << Qq;
-            coef[64] = (r2 * quant) << Qq;
-            coef[68] = (r3 * quant) << Qq;
-            Qq++;
-        }
-        else
-        {
-            coef[0] = (r0 * quant) >> 1;
-            coef[4] = (r1 * quant) >> 1;
-            coef[64] = (r2 * quant) >> 1;
-            coef[68] = (r3 * quant) >> 1;
-        }
-    }
-
-    /* now do AC zigzag scan, quant, iquant and itrans */
-    if (cr)
-    {
-        run = encvid->run[20];
-        level = encvid->level[20];
-    }
-    else
-    {
-        run = encvid->run[16];
-        level = encvid->level[16];
-    }
-
-    /* offset btw 4x4 block */
-    offset_cur[0] = 0;
-    offset_cur[1] = (pitch << 2) - 8;
-    offset_pred[0] = 0;
-    offset_pred[1] = (pred_pitch << 2) - 8;
-    offset_coef[0] = 0;
-    offset_coef[1] = 56;
-
-    coeff_cost = 0;
-
-    for (b4 = 0; b4 < 4; b4++)
-    {
-        zero_run = 0;
-        ncoeff = 0;
-        for (k = 1; k < 16; k++) /* in zigzag scan order */
-        {
-            idx = ZZ_SCAN_BLOCK[k]; /* map back to raster scan order */
-            data = coef[idx];
-            quant = quant_coef[Rq][k];
-            if (data > 0)
-            {
-                lev = data * quant + qp_const;
-            }
-            else
-            {
-                lev = -data * quant + qp_const;
-            }
-            lev >>= q_bits;
-            if (lev)
-            {
-                /* for RD performance*/
-                if (lev > 1)
-                    coeff_cost += MAX_VALUE;                // set high cost, shall not be discarded
-                else
-                    coeff_cost += COEFF_COST[DISABLE_THRESHOLDING][zero_run];
-
-                /* dequant */
-                quant = dequant_coefres[Rq][k];
-                if (data > 0)
-                {
-                    level[ncoeff] = lev;
-                    coef[idx] = (lev * quant) << Qq;
-                }
-                else
-                {
-                    level[ncoeff] = -lev;
-                    coef[idx] = (-lev * quant) << Qq;
-                }
-                run[ncoeff++] = zero_run;
-                zero_run = 0;
-            }
-            else
-            {
-                zero_run++;
-                coef[idx] = 0;
-            }
-        }
-
-        nz_temp[b4] = ncoeff; // raster scan
-
-        // just advance the pointers for now, do IDCT later
-        coef += 4;
-        run += 16;
-        level += 16;
-        coef += offset_coef[b4&1];
-    }
-
-    /* rewind the pointers */
-    coef -= 128;
-
-    if (coeff_cost < _CHROMA_COEFF_COST_)
-    {
-        /* if it's not efficient to encode any blocks.
-        Just do DC only */
-        /* We can reset level and run also, but setting nz to zero should be enough. */
-        currMB->nz_coeff[16+(cr<<1)] = 0;
-        currMB->nz_coeff[17+(cr<<1)] = 0;
-        currMB->nz_coeff[20+(cr<<1)] = 0;
-        currMB->nz_coeff[21+(cr<<1)] = 0;
-
-        for (b4 = 0; b4 < 4; b4++)
-        {
-            // do DC-only inverse
-            m0 = coef[0] + 32;
-
-            for (j = 4; j > 0; j--)
-            {
-                r0 = pred[0] + (m0 >> 6);
-                if ((uint)r0 > 0xFF)   r0 = 0xFF & (~(r0 >> 31));  /* clip */
-                r1 = *(pred += pred_pitch) + (m0 >> 6);
-                if ((uint)r1 > 0xFF)   r1 = 0xFF & (~(r1 >> 31));  /* clip */
-                r2 = pred[pred_pitch] + (m0 >> 6);
-                if ((uint)r2 > 0xFF)   r2 = 0xFF & (~(r2 >> 31));  /* clip */
-                r3 = pred[pred_pitch<<1] + (m0 >> 6);
-                if ((uint)r3 > 0xFF)   r3 = 0xFF & (~(r3 >> 31));  /* clip */
-                *curC = r0;
-                *(curC += pitch) = r1;
-                *(curC += pitch) = r2;
-                curC[pitch] = r3;
-                curC -= (pitch << 1);
-                curC++;
-                pred += (1 - pred_pitch);
-            }
-            coef += 4;
-            curC += offset_cur[b4&1];
-            pred += offset_pred[b4&1];
-            coef += offset_coef[b4&1];
-        }
-    }
-    else // not dropping anything, continue with the IDCT
-    {
-        for (b4 = 0; b4 < 4; b4++)
-        {
-            ncoeff = nz_temp[b4] ; // in raster scan
-            currMB->nz_coeff[16+(b4&1)+(cr<<1)+((b4>>1)<<2)] = ncoeff; // in raster scan
-
-            if (ncoeff) // do a check on the nonzero-coeff
-            {
-                currMB->CBP |= (2 << 4);
-
-                // do inverse transform here
-                for (j = 4; j > 0; j--)
-                {
-                    r0 = coef[0] + coef[2];
-                    r1 = coef[0] - coef[2];
-                    r2 = (coef[1] >> 1) - coef[3];
-                    r3 = coef[1] + (coef[3] >> 1);
-
-                    coef[0] = r0 + r3;
-                    coef[1] = r1 + r2;
-                    coef[2] = r1 - r2;
-                    coef[3] = r0 - r3;
-
-                    coef += 16;
-                }
-                coef -= 64;
-                for (j = 4; j > 0; j--)
-                {
-                    r0 = coef[0] + coef[32];
-                    r1 = coef[0] - coef[32];
-                    r2 = (coef[16] >> 1) - coef[48];
-                    r3 = coef[16] + (coef[48] >> 1);
-
-                    r0 += r3;
-                    r3 = (r0 - (r3 << 1)); /* r0-r3 */
-                    r1 += r2;
-                    r2 = (r1 - (r2 << 1)); /* r1-r2 */
-                    r0 += 32;
-                    r1 += 32;
-                    r2 += 32;
-                    r3 += 32;
-                    r0 = pred[0] + (r0 >> 6);
-                    if ((uint)r0 > 0xFF)   r0 = 0xFF & (~(r0 >> 31));  /* clip */
-                    r1 = *(pred += pred_pitch) + (r1 >> 6);
-                    if ((uint)r1 > 0xFF)   r1 = 0xFF & (~(r1 >> 31));  /* clip */
-                    r2 = pred[pred_pitch] + (r2 >> 6);
-                    if ((uint)r2 > 0xFF)   r2 = 0xFF & (~(r2 >> 31));  /* clip */
-                    r3 = pred[pred_pitch<<1] + (r3 >> 6);
-                    if ((uint)r3 > 0xFF)   r3 = 0xFF & (~(r3 >> 31));  /* clip */
-                    *curC = r0;
-                    *(curC += pitch) = r1;
-                    *(curC += pitch) = r2;
-                    curC[pitch] = r3;
-                    curC -= (pitch << 1);
-                    curC++;
-                    pred += (1 - pred_pitch);
-                    coef++;
-                }
-            }
-            else
-            {
-                // do DC-only inverse
-                m0 = coef[0] + 32;
-
-                for (j = 4; j > 0; j--)
-                {
-                    r0 = pred[0] + (m0 >> 6);
-                    if ((uint)r0 > 0xFF)   r0 = 0xFF & (~(r0 >> 31));  /* clip */
-                    r1 = *(pred += pred_pitch) + (m0 >> 6);
-                    if ((uint)r1 > 0xFF)   r1 = 0xFF & (~(r1 >> 31));  /* clip */
-                    r2 = pred[pred_pitch] + (m0 >> 6);
-                    if ((uint)r2 > 0xFF)   r2 = 0xFF & (~(r2 >> 31));  /* clip */
-                    r3 = pred[pred_pitch<<1] + (m0 >> 6);
-                    if ((uint)r3 > 0xFF)   r3 = 0xFF & (~(r3 >> 31));  /* clip */
-                    *curC = r0;
-                    *(curC += pitch) = r1;
-                    *(curC += pitch) = r2;
-                    curC[pitch] = r3;
-                    curC -= (pitch << 1);
-                    curC++;
-                    pred += (1 - pred_pitch);
-                }
-                coef += 4;
-            }
-            curC += offset_cur[b4&1];
-            pred += offset_pred[b4&1];
-            coef += offset_coef[b4&1];
-        }
-    }
-
-    return ;
-}
-
-
-/* only DC transform */
-int TransQuantIntra16DC(AVCEncObject *encvid)
-{
-    AVCCommonObj *video = encvid->common;
-    int16 *block = video->block;
-    int *level = encvid->leveldc;
-    int *run = encvid->rundc;
-    int16 *ptr = block;
-    int r0, r1, r2, r3, j;
-    int Qq = video->QPy_div_6;
-    int Rq = video->QPy_mod_6;
-    int q_bits, qp_const, quant;
-    int data, lev, zero_run;
-    int k, ncoeff, idx;
-
-    /* DC transform */
-    /* horizontal */
-    j = 4;
-    while (j)
-    {
-        r0 = ptr[0] + ptr[12];
-        r3 = ptr[0] - ptr[12];
-        r1 = ptr[4] + ptr[8];
-        r2 = ptr[4] - ptr[8];
-
-        ptr[0] = r0 + r1;
-        ptr[8] = r0 - r1;
-        ptr[4] = r3 + r2;
-        ptr[12] = r3 - r2;
-        ptr += 64;
-        j--;
-    }
-    /* vertical */
-    ptr = block;
-    j = 4;
-    while (j)
-    {
-        r0 = ptr[0] + ptr[192];
-        r3 = ptr[0] - ptr[192];
-        r1 = ptr[64] + ptr[128];
-        r2 = ptr[64] - ptr[128];
-
-        ptr[0] = (r0 + r1) >> 1;
-        ptr[128] = (r0 - r1) >> 1;
-        ptr[64] = (r3 + r2) >> 1;
-        ptr[192] = (r3 - r2) >> 1;
-        ptr += 4;
-        j--;
-    }
-
-    quant = quant_coef[Rq][0];
-    q_bits    = 15 + Qq;
-    qp_const = (1 << q_bits) / 3;    // intra
-
-    zero_run = 0;
-    ncoeff = 0;
-
-    for (k = 0; k < 16; k++) /* in zigzag scan order */
-    {
-        idx = ZIGZAG2RASTERDC[k];
-        data = block[idx];
-        if (data > 0)
-        {
-            lev = data * quant + (qp_const << 1);
-        }
-        else
-        {
-            lev = -data * quant + (qp_const << 1);
-        }
-        lev >>= (q_bits + 1);
-        if (lev)
-        {
-            if (data > 0)
-            {
-                level[ncoeff] = lev;
-                block[idx] = lev;
-            }
-            else
-            {
-                level[ncoeff] = -lev;
-                block[idx] = -lev;
-            }
-            run[ncoeff++] = zero_run;
-            zero_run = 0;
-        }
-        else
-        {
-            zero_run++;
-            block[idx] = 0;
-        }
-    }
-    return ncoeff;
-}
-
-int TransQuantChromaDC(AVCEncObject *encvid, int16 *block, int slice_type, int cr)
-{
-    AVCCommonObj *video = encvid->common;
-    int *level, *run;
-    int r0, r1, r2, r3;
-    int Qq, Rq, q_bits, qp_const, quant;
-    int data, lev, zero_run;
-    int k, ncoeff, idx;
-
-    level = encvid->levelcdc + (cr << 2); /* cb or cr */
-    run = encvid->runcdc + (cr << 2);
-
-    /* 2x2 transform of DC components*/
-    r0 = block[0];
-    r1 = block[4];
-    r2 = block[64];
-    r3 = block[68];
-
-    block[0] = r0 + r1 + r2 + r3;
-    block[4] = r0 - r1 + r2 - r3;
-    block[64] = r0 + r1 - r2 - r3;
-    block[68] = r0 - r1 - r2 + r3;
-
-    Qq    = video->QPc_div_6;
-    Rq    = video->QPc_mod_6;
-    quant = quant_coef[Rq][0];
-    q_bits    = 15 + Qq;
-    if (slice_type == AVC_I_SLICE)
-    {
-        qp_const = (1 << q_bits) / 3;
-    }
-    else
-    {
-        qp_const = (1 << q_bits) / 6;
-    }
-
-    zero_run = 0;
-    ncoeff = 0;
-
-    for (k = 0; k < 4; k++) /* in zigzag scan order */
-    {
-        idx = ((k >> 1) << 6) + ((k & 1) << 2);
-        data = block[idx];
-        if (data > 0)
-        {
-            lev = data * quant + (qp_const << 1);
-        }
-        else
-        {
-            lev = -data * quant + (qp_const << 1);
-        }
-        lev >>= (q_bits + 1);
-        if (lev)
-        {
-            if (data > 0)
-            {
-                level[ncoeff] = lev;
-                block[idx] = lev;
-            }
-            else
-            {
-                level[ncoeff] = -lev;
-                block[idx] = -lev;
-            }
-            run[ncoeff++] = zero_run;
-            zero_run = 0;
-        }
-        else
-        {
-            zero_run++;
-            block[idx] = 0;
-        }
-    }
-    return ncoeff;
-}
-
-
diff --git a/media/libstagefright/codecs/avc/enc/src/findhalfpel.cpp b/media/libstagefright/codecs/avc/enc/src/findhalfpel.cpp
deleted file mode 100644
index 941ae5a..0000000
--- a/media/libstagefright/codecs/avc/enc/src/findhalfpel.cpp
+++ /dev/null
@@ -1,607 +0,0 @@
-/* ------------------------------------------------------------------
- * 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 "avcenc_lib.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      5 // 2  /* half-pel distance threshold */
-
-#define PREF_16_VEC 129     /* 1MV bias versus 4MVs*/
-
-#define CLIP_RESULT(x)      if((uint)(x) > 0xFF){ \
-                 (x) = 0xFF & (~((x)>>31));}
-
-#define CLIP_UPPER16(x)     if((uint)(x) >= 0x20000000){ \
-        (x) = 0xFF0000 & (~((x)>>31));} \
-        else { \
-        (x) = ((x)>>5)&0xFF0000; \
-        }
-
-/*=====================================================================
-    Function:   AVCFindHalfPelMB
-    Date:       10/31/2007
-    Purpose:    Find half pel resolution MV surrounding the full-pel MV
-=====================================================================*/
-
-int AVCFindHalfPelMB(AVCEncObject *encvid, uint8 *cur, AVCMV *mot, uint8 *ncand,
-                     int xpos, int ypos, int hp_guess, int cmvx, int cmvy)
-{
-    AVCPictureData *currPic = encvid->common->currPic;
-    int lx = currPic->pitch;
-    int d, dmin, satd_min;
-    uint8* cand;
-    int lambda_motion = encvid->lambda_motion;
-    uint8 *mvbits = encvid->mvbits;
-    int mvcost;
-    /* list of candidate to go through for half-pel search*/
-    uint8 *subpel_pred = (uint8*) encvid->subpel_pred; // all 16 sub-pel positions
-    uint8 **hpel_cand = (uint8**) encvid->hpel_cand; /* half-pel position */
-
-    int xh[9] = {0, 0, 2, 2, 2, 0, -2, -2, -2};
-    int yh[9] = {0, -2, -2, 0, 2, 2, 2, 0, -2};
-    int xq[8] = {0, 1, 1, 1, 0, -1, -1, -1};
-    int yq[8] = { -1, -1, 0, 1, 1, 1, 0, -1};
-    int h, hmin, q, qmin;
-
-    OSCL_UNUSED_ARG(xpos);
-    OSCL_UNUSED_ARG(ypos);
-    OSCL_UNUSED_ARG(hp_guess);
-
-    GenerateHalfPelPred(subpel_pred, ncand, lx);
-
-    cur = encvid->currYMB; // pre-load current original MB
-
-    cand = hpel_cand[0];
-
-    // find cost for the current full-pel position
-    dmin = SATD_MB(cand, cur, 65535); // get Hadamaard transform SAD
-    mvcost = MV_COST_S(lambda_motion, mot->x, mot->y, cmvx, cmvy);
-    satd_min = dmin;
-    dmin += mvcost;
-    hmin = 0;
-
-    /* find half-pel */
-    for (h = 1; h < 9; h++)
-    {
-        d = SATD_MB(hpel_cand[h], cur, dmin);
-        mvcost = MV_COST_S(lambda_motion, mot->x + xh[h], mot->y + yh[h], cmvx, cmvy);
-        d += mvcost;
-
-        if (d < dmin)
-        {
-            dmin = d;
-            hmin = h;
-            satd_min = d - mvcost;
-        }
-    }
-
-    mot->sad = dmin;
-    mot->x += xh[hmin];
-    mot->y += yh[hmin];
-    encvid->best_hpel_pos = hmin;
-
-    /*** search for quarter-pel ****/
-    GenerateQuartPelPred(encvid->bilin_base[hmin], &(encvid->qpel_cand[0][0]), hmin);
-
-    encvid->best_qpel_pos = qmin = -1;
-
-    for (q = 0; q < 8; q++)
-    {
-        d = SATD_MB(encvid->qpel_cand[q], cur, dmin);
-        mvcost = MV_COST_S(lambda_motion, mot->x + xq[q], mot->y + yq[q], cmvx, cmvy);
-        d += mvcost;
-        if (d < dmin)
-        {
-            dmin = d;
-            qmin = q;
-            satd_min = d - mvcost;
-        }
-    }
-
-    if (qmin != -1)
-    {
-        mot->sad = dmin;
-        mot->x += xq[qmin];
-        mot->y += yq[qmin];
-        encvid->best_qpel_pos = qmin;
-    }
-
-    return satd_min;
-}
-
-
-
-/** This function generates sub-pel prediction around the full-pel candidate.
-Each sub-pel position array is 20 pixel wide (for word-alignment) and 17 pixel tall. */
-/** The sub-pel position is labeled in spiral manner from the center. */
-
-void GenerateHalfPelPred(uint8* subpel_pred, uint8 *ncand, int lx)
-{
-    /* let's do straightforward way first */
-    uint8 *ref;
-    uint8 *dst;
-    uint8 tmp8;
-    int32 tmp32;
-    int16 tmp_horz[18*22], *dst_16, *src_16;
-    int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0; // temp
-    int i, j;
-
-    /* first copy full-pel to the first array */
-    /* to be optimized later based on byte-offset load */
-    ref = ncand - 3 - lx - (lx << 1); /* move back (-3,-3) */
-    dst = subpel_pred;
-
-    dst -= 4; /* offset */
-    for (j = 0; j < 22; j++) /* 24x22 */
-    {
-        i = 6;
-        while (i > 0)
-        {
-            tmp32 = *ref++;
-            tmp8 = *ref++;
-            tmp32 |= (tmp8 << 8);
-            tmp8 = *ref++;
-            tmp32 |= (tmp8 << 16);
-            tmp8 = *ref++;
-            tmp32 |= (tmp8 << 24);
-            *((uint32*)(dst += 4)) = tmp32;
-            i--;
-        }
-        ref += (lx - 24);
-    }
-
-    /* from the first array, we do horizontal interp */
-    ref = subpel_pred + 2;
-    dst_16 = tmp_horz; /* 17 x 22 */
-
-    for (j = 4; j > 0; j--)
-    {
-        for (i = 16; i > 0; i -= 4)
-        {
-            a = ref[-2];
-            b = ref[-1];
-            c = ref[0];
-            d = ref[1];
-            e = ref[2];
-            f = ref[3];
-            *dst_16++ = a + f - 5 * (b + e) + 20 * (c + d);
-            a = ref[4];
-            *dst_16++ = b + a - 5 * (c + f) + 20 * (d + e);
-            b = ref[5];
-            *dst_16++ = c + b - 5 * (d + a) + 20 * (e + f);
-            c = ref[6];
-            *dst_16++ = d + c - 5 * (e + b) + 20 * (f + a);
-
-            ref += 4;
-        }
-        /* do the 17th column here */
-        d = ref[3];
-        *dst_16 =  e + d - 5 * (f + c) + 20 * (a + b);
-        dst_16 += 2; /* stride for tmp_horz is 18 */
-        ref += 8;  /* stride for ref is 24 */
-        if (j == 3)  // move 18 lines down
-        {
-            dst_16 += 324;//18*18;
-            ref += 432;//18*24;
-        }
-    }
-
-    ref -= 480;//20*24;
-    dst_16 -= 360;//20*18;
-    dst = subpel_pred + V0Q_H2Q * SUBPEL_PRED_BLK_SIZE; /* go to the 14th array 17x18*/
-
-    for (j = 18; j > 0; j--)
-    {
-        for (i = 16; i > 0; i -= 4)
-        {
-            a = ref[-2];
-            b = ref[-1];
-            c = ref[0];
-            d = ref[1];
-            e = ref[2];
-            f = ref[3];
-            tmp32 = a + f - 5 * (b + e) + 20 * (c + d);
-            *dst_16++ = tmp32;
-            tmp32 = (tmp32 + 16) >> 5;
-            CLIP_RESULT(tmp32)
-            *dst++ = tmp32;
-
-            a = ref[4];
-            tmp32 = b + a - 5 * (c + f) + 20 * (d + e);
-            *dst_16++ = tmp32;
-            tmp32 = (tmp32 + 16) >> 5;
-            CLIP_RESULT(tmp32)
-            *dst++ = tmp32;
-
-            b = ref[5];
-            tmp32 = c + b - 5 * (d + a) + 20 * (e + f);
-            *dst_16++ = tmp32;
-            tmp32 = (tmp32 + 16) >> 5;
-            CLIP_RESULT(tmp32)
-            *dst++ = tmp32;
-
-            c = ref[6];
-            tmp32 = d + c - 5 * (e + b) + 20 * (f + a);
-            *dst_16++ = tmp32;
-            tmp32 = (tmp32 + 16) >> 5;
-            CLIP_RESULT(tmp32)
-            *dst++ = tmp32;
-
-            ref += 4;
-        }
-        /* do the 17th column here */
-        d = ref[3];
-        tmp32 =  e + d - 5 * (f + c) + 20 * (a + b);
-        *dst_16 = tmp32;
-        tmp32 = (tmp32 + 16) >> 5;
-        CLIP_RESULT(tmp32)
-        *dst = tmp32;
-
-        dst += 8;  /* stride for dst is 24 */
-        dst_16 += 2; /* stride for tmp_horz is 18 */
-        ref += 8;  /* stride for ref is 24 */
-    }
-
-
-    /* Do middle point filtering*/
-    src_16 = tmp_horz; /* 17 x 22 */
-    dst = subpel_pred + V2Q_H2Q * SUBPEL_PRED_BLK_SIZE; /* 12th array 17x17*/
-    dst -= 24; // offset
-    for (i = 0; i < 17; i++)
-    {
-        for (j = 16; j > 0; j -= 4)
-        {
-            a = *src_16;
-            b = *(src_16 += 18);
-            c = *(src_16 += 18);
-            d = *(src_16 += 18);
-            e = *(src_16 += 18);
-            f = *(src_16 += 18);
-
-            tmp32 = a + f - 5 * (b + e) + 20 * (c + d);
-            tmp32 = (tmp32 + 512) >> 10;
-            CLIP_RESULT(tmp32)
-            *(dst += 24) = tmp32;
-
-            a = *(src_16 += 18);
-            tmp32 = b + a - 5 * (c + f) + 20 * (d + e);
-            tmp32 = (tmp32 + 512) >> 10;
-            CLIP_RESULT(tmp32)
-            *(dst += 24) = tmp32;
-
-            b = *(src_16 += 18);
-            tmp32 = c + b - 5 * (d + a) + 20 * (e + f);
-            tmp32 = (tmp32 + 512) >> 10;
-            CLIP_RESULT(tmp32)
-            *(dst += 24) = tmp32;
-
-            c = *(src_16 += 18);
-            tmp32 = d + c - 5 * (e + b) + 20 * (f + a);
-            tmp32 = (tmp32 + 512) >> 10;
-            CLIP_RESULT(tmp32)
-            *(dst += 24) = tmp32;
-
-            src_16 -= (18 << 2);
-        }
-
-        d = src_16[90]; // 18*5
-        tmp32 = e + d - 5 * (f + c) + 20 * (a + b);
-        tmp32 = (tmp32 + 512) >> 10;
-        CLIP_RESULT(tmp32)
-        dst[24] = tmp32;
-
-        src_16 -= ((18 << 4) - 1);
-        dst -= ((24 << 4) - 1);
-    }
-
-    /* do vertical interpolation */
-    ref = subpel_pred + 2;
-    dst = subpel_pred + V2Q_H0Q * SUBPEL_PRED_BLK_SIZE; /* 10th array 18x17 */
-    dst -= 24; // offset
-
-    for (i = 2; i > 0; i--)
-    {
-        for (j = 16; j > 0; j -= 4)
-        {
-            a = *ref;
-            b = *(ref += 24);
-            c = *(ref += 24);
-            d = *(ref += 24);
-            e = *(ref += 24);
-            f = *(ref += 24);
-
-            tmp32 = a + f - 5 * (b + e) + 20 * (c + d);
-            tmp32 = (tmp32 + 16) >> 5;
-            CLIP_RESULT(tmp32)
-            *(dst += 24) = tmp32;  // 10th
-
-            a = *(ref += 24);
-            tmp32 = b + a - 5 * (c + f) + 20 * (d + e);
-            tmp32 = (tmp32 + 16) >> 5;
-            CLIP_RESULT(tmp32)
-            *(dst += 24) = tmp32;  // 10th
-
-            b = *(ref += 24);
-            tmp32 = c + b - 5 * (d + a) + 20 * (e + f);
-            tmp32 = (tmp32 + 16) >> 5;
-            CLIP_RESULT(tmp32)
-            *(dst += 24) = tmp32;  // 10th
-
-            c = *(ref += 24);
-            tmp32 = d + c - 5 * (e + b) + 20 * (f + a);
-            tmp32 = (tmp32 + 16) >> 5;
-            CLIP_RESULT(tmp32)
-            *(dst += 24) = tmp32;  // 10th
-
-            ref -= (24 << 2);
-        }
-
-        d = ref[120]; // 24*5
-        tmp32 = e + d - 5 * (f + c) + 20 * (a + b);
-        tmp32 = (tmp32 + 16) >> 5;
-        CLIP_RESULT(tmp32)
-        dst[24] = tmp32;  // 10th
-
-        dst -= ((24 << 4) - 1);
-        ref -= ((24 << 4) - 1);
-    }
-
-    // note that using SIMD here doesn't help much, the cycle almost stays the same
-    // one can just use the above code and change the for(i=2 to for(i=18
-    for (i = 16; i > 0; i -= 4)
-    {
-        for (j = 17; j > 0; j--)
-        {
-            a = *((uint32*)ref); /* load 4 bytes */
-            b = (a >> 8) & 0xFF00FF; /* second and fourth byte */
-            a &= 0xFF00FF;
-
-            c = *((uint32*)(ref + 120));
-            d = (c >> 8) & 0xFF00FF;
-            c &= 0xFF00FF;
-
-            a += c;
-            b += d;
-
-            e = *((uint32*)(ref + 72)); /* e, f */
-            f = (e >> 8) & 0xFF00FF;
-            e &= 0xFF00FF;
-
-            c = *((uint32*)(ref + 48)); /* c, d */
-            d = (c >> 8) & 0xFF00FF;
-            c &= 0xFF00FF;
-
-            c += e;
-            d += f;
-
-            a += 20 * c;
-            b += 20 * d;
-            a += 0x100010;
-            b += 0x100010;
-
-            e = *((uint32*)(ref += 24)); /* e, f */
-            f = (e >> 8) & 0xFF00FF;
-            e &= 0xFF00FF;
-
-            c = *((uint32*)(ref + 72)); /* c, d */
-            d = (c >> 8) & 0xFF00FF;
-            c &= 0xFF00FF;
-
-            c += e;
-            d += f;
-
-            a -= 5 * c;
-            b -= 5 * d;
-
-            c = a << 16;
-            d = b << 16;
-            CLIP_UPPER16(a)
-            CLIP_UPPER16(c)
-            CLIP_UPPER16(b)
-            CLIP_UPPER16(d)
-
-            a |= (c >> 16);
-            b |= (d >> 16);
-            //  a>>=5;
-            //  b>>=5;
-            /* clip */
-            //  msk |= b;  msk|=a;
-            //  a &= 0xFF00FF;
-            //  b &= 0xFF00FF;
-            a |= (b << 8);  /* pack it back */
-
-            *((uint16*)(dst += 24)) = a & 0xFFFF; //dst is not word-aligned.
-            *((uint16*)(dst + 2)) = a >> 16;
-
-        }
-        dst -= 404; // 24*17-4
-        ref -= 404;
-        /*      if(msk & 0xFF00FF00) // need clipping
-                {
-                    VertInterpWClip(dst,ref); // re-do 4 column with clip
-                }*/
-    }
-
-    return ;
-}
-
-void VertInterpWClip(uint8 *dst, uint8 *ref)
-{
-    int i, j;
-    int a, b, c, d, e, f;
-    int32 tmp32;
-
-    dst -= 4;
-    ref -= 4;
-
-    for (i = 4; i > 0; i--)
-    {
-        for (j = 16; j > 0; j -= 4)
-        {
-            a = *ref;
-            b = *(ref += 24);
-            c = *(ref += 24);
-            d = *(ref += 24);
-            e = *(ref += 24);
-            f = *(ref += 24);
-
-            tmp32 = a + f - 5 * (b + e) + 20 * (c + d);
-            tmp32 = (tmp32 + 16) >> 5;
-            CLIP_RESULT(tmp32)
-            *(dst += 24) = tmp32;  // 10th
-
-            a = *(ref += 24);
-            tmp32 = b + a - 5 * (c + f) + 20 * (d + e);
-            tmp32 = (tmp32 + 16) >> 5;
-            CLIP_RESULT(tmp32)
-            *(dst += 24) = tmp32;  // 10th
-
-            b = *(ref += 24);
-            tmp32 = c + b - 5 * (d + a) + 20 * (e + f);
-            tmp32 = (tmp32 + 16) >> 5;
-            CLIP_RESULT(tmp32)
-            *(dst += 24) = tmp32;  // 10th
-
-            c = *(ref += 24);
-            tmp32 = d + c - 5 * (e + b) + 20 * (f + a);
-            tmp32 = (tmp32 + 16) >> 5;
-            CLIP_RESULT(tmp32)
-            *(dst += 24) = tmp32;  // 10th
-
-            ref -= (24 << 2);
-        }
-
-        d = ref[120]; // 24*5
-        tmp32 = e + d - 5 * (f + c) + 20 * (a + b);
-        tmp32 = (tmp32 + 16) >> 5;
-        CLIP_RESULT(tmp32)
-        dst[24] = tmp32;  // 10th
-
-        dst -= ((24 << 4) - 1);
-        ref -= ((24 << 4) - 1);
-    }
-
-    return ;
-}
-
-
-void GenerateQuartPelPred(uint8 **bilin_base, uint8 *qpel_cand, int hpel_pos)
-{
-    // for even value of hpel_pos, start with pattern 1, otherwise, start with pattern 2
-    int i, j;
-
-    uint8 *c1 = qpel_cand;
-    uint8 *tl = bilin_base[0];
-    uint8 *tr = bilin_base[1];
-    uint8 *bl = bilin_base[2];
-    uint8 *br = bilin_base[3];
-    int a, b, c, d;
-    int offset = 1 - (384 * 7);
-
-    if (!(hpel_pos&1)) // diamond pattern
-    {
-        j = 16;
-        while (j--)
-        {
-            i = 16;
-            while (i--)
-            {
-                d = tr[24];
-                a = *tr++;
-                b = bl[1];
-                c = *br++;
-
-                *c1 = (c + a + 1) >> 1;
-                *(c1 += 384) = (b + a + 1) >> 1; /* c2 */
-                *(c1 += 384) = (b + c + 1) >> 1; /* c3 */
-                *(c1 += 384) = (b + d + 1) >> 1; /* c4 */
-
-                b = *bl++;
-
-                *(c1 += 384) = (c + d + 1) >> 1;  /* c5 */
-                *(c1 += 384) = (b + d + 1) >> 1;  /* c6 */
-                *(c1 += 384) = (b + c + 1) >> 1;  /* c7 */
-                *(c1 += 384) = (b + a + 1) >> 1;  /* c8 */
-
-                c1 += offset;
-            }
-            // advance to the next line, pitch is 24
-            tl += 8;
-            tr += 8;
-            bl += 8;
-            br += 8;
-            c1 += 8;
-        }
-    }
-    else // star pattern
-    {
-        j = 16;
-        while (j--)
-        {
-            i = 16;
-            while (i--)
-            {
-                a = *br++;
-                b = *tr++;
-                c = tl[1];
-                *c1 = (a + b + 1) >> 1;
-                b = bl[1];
-                *(c1 += 384) = (a + c + 1) >> 1; /* c2 */
-                c = tl[25];
-                *(c1 += 384) = (a + b + 1) >> 1; /* c3 */
-                b = tr[23];
-                *(c1 += 384) = (a + c + 1) >> 1; /* c4 */
-                c = tl[24];
-                *(c1 += 384) = (a + b + 1) >> 1; /* c5 */
-                b = *bl++;
-                *(c1 += 384) = (a + c + 1) >> 1; /* c6 */
-                c = *tl++;
-                *(c1 += 384) = (a + b + 1) >> 1; /* c7 */
-                *(c1 += 384) = (a + c + 1) >> 1; /* c8 */
-
-                c1 += offset;
-            }
-            // advance to the next line, pitch is 24
-            tl += 8;
-            tr += 8;
-            bl += 8;
-            br += 8;
-            c1 += 8;
-        }
-    }
-
-    return ;
-}
-
-
-/* assuming cand always has a pitch of 24 */
-int SATD_MB(uint8 *cand, uint8 *cur, int dmin)
-{
-    int cost;
-
-
-    dmin = (dmin << 16) | 24;
-    cost = AVCSAD_Macroblock_C(cand, cur, dmin, NULL);
-
-    return cost;
-}
-
-
-
-
-
diff --git a/media/libstagefright/codecs/avc/enc/src/header.cpp b/media/libstagefright/codecs/avc/enc/src/header.cpp
deleted file mode 100644
index 9acff9e..0000000
--- a/media/libstagefright/codecs/avc/enc/src/header.cpp
+++ /dev/null
@@ -1,917 +0,0 @@
-/* ------------------------------------------------------------------
- * 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 "avcenc_lib.h"
-#include "avcenc_api.h"
-
-/** see subclause 7.4.2.1 */
-/* no need for checking the valid range , already done in SetEncodeParam(),
-if we have to send another SPS, the ranges should be verified first before
-users call PVAVCEncodeSPS() */
-AVCEnc_Status EncodeSPS(AVCEncObject *encvid, AVCEncBitstream *stream)
-{
-    AVCCommonObj *video = encvid->common;
-    AVCSeqParamSet *seqParam = video->currSeqParams;
-    AVCVUIParams *vui = &(seqParam->vui_parameters);
-    int i;
-    AVCEnc_Status status = AVCENC_SUCCESS;
-
-    //DEBUG_LOG(userData,AVC_LOGTYPE_INFO,"EncodeSPS",-1,-1);
-
-    status = BitstreamWriteBits(stream, 8, seqParam->profile_idc);
-    status = BitstreamWrite1Bit(stream, seqParam->constrained_set0_flag);
-    status = BitstreamWrite1Bit(stream, seqParam->constrained_set1_flag);
-    status = BitstreamWrite1Bit(stream, seqParam->constrained_set2_flag);
-    status = BitstreamWrite1Bit(stream, seqParam->constrained_set3_flag);
-    status = BitstreamWriteBits(stream, 4, 0);  /* forbidden zero bits */
-    if (status != AVCENC_SUCCESS)  /* we can check after each write also */
-    {
-        return status;
-    }
-
-    status = BitstreamWriteBits(stream, 8, seqParam->level_idc);
-    status = ue_v(stream, seqParam->seq_parameter_set_id);
-    status = ue_v(stream, seqParam->log2_max_frame_num_minus4);
-    status = ue_v(stream, seqParam->pic_order_cnt_type);
-    if (status != AVCENC_SUCCESS)
-    {
-        return status;
-    }
-
-    if (seqParam->pic_order_cnt_type == 0)
-    {
-        status = ue_v(stream, seqParam->log2_max_pic_order_cnt_lsb_minus4);
-    }
-    else if (seqParam->pic_order_cnt_type == 1)
-    {
-        status = BitstreamWrite1Bit(stream, seqParam->delta_pic_order_always_zero_flag);
-        status = se_v(stream, seqParam->offset_for_non_ref_pic); /* upto 32 bits */
-        status = se_v(stream, seqParam->offset_for_top_to_bottom_field); /* upto 32 bits */
-        status = ue_v(stream, seqParam->num_ref_frames_in_pic_order_cnt_cycle);
-
-        for (i = 0; i < (int)(seqParam->num_ref_frames_in_pic_order_cnt_cycle); i++)
-        {
-            status = se_v(stream, seqParam->offset_for_ref_frame[i]); /* upto 32 bits */
-        }
-    }
-    if (status != AVCENC_SUCCESS)
-    {
-        return status;
-    }
-
-    status = ue_v(stream, seqParam->num_ref_frames);
-    status = BitstreamWrite1Bit(stream, seqParam->gaps_in_frame_num_value_allowed_flag);
-    status = ue_v(stream, seqParam->pic_width_in_mbs_minus1);
-    status = ue_v(stream, seqParam->pic_height_in_map_units_minus1);
-    status = BitstreamWrite1Bit(stream, seqParam->frame_mbs_only_flag);
-    if (status != AVCENC_SUCCESS)
-    {
-        return status;
-    }
-    /* if frame_mbs_only_flag is 0, then write, mb_adaptive_frame_field_frame here */
-
-    status = BitstreamWrite1Bit(stream, seqParam->direct_8x8_inference_flag);
-    status = BitstreamWrite1Bit(stream, seqParam->frame_cropping_flag);
-    if (seqParam->frame_cropping_flag)
-    {
-        status = ue_v(stream, seqParam->frame_crop_left_offset);
-        status = ue_v(stream, seqParam->frame_crop_right_offset);
-        status = ue_v(stream, seqParam->frame_crop_top_offset);
-        status = ue_v(stream, seqParam->frame_crop_bottom_offset);
-    }
-    if (status != AVCENC_SUCCESS)
-    {
-        return status;
-    }
-
-    status = BitstreamWrite1Bit(stream, seqParam->vui_parameters_present_flag);
-    if (seqParam->vui_parameters_present_flag)
-    {
-        /* not supported */
-        //return AVCENC_SPS_FAIL;
-        EncodeVUI(stream, vui);
-    }
-
-    return status;
-}
-
-
-void EncodeVUI(AVCEncBitstream* stream, AVCVUIParams* vui)
-{
-    int temp;
-
-    temp = vui->aspect_ratio_info_present_flag;
-    BitstreamWrite1Bit(stream, temp);
-    if (temp)
-    {
-        BitstreamWriteBits(stream, 8, vui->aspect_ratio_idc);
-        if (vui->aspect_ratio_idc == 255)
-        {
-            BitstreamWriteBits(stream, 16, vui->sar_width);
-            BitstreamWriteBits(stream, 16, vui->sar_height);
-        }
-    }
-    temp = vui->overscan_info_present_flag;
-    BitstreamWrite1Bit(stream, temp);
-    if (temp)
-    {
-        BitstreamWrite1Bit(stream, vui->overscan_appropriate_flag);
-    }
-    temp = vui->video_signal_type_present_flag;
-    BitstreamWrite1Bit(stream, temp);
-    if (temp)
-    {
-        BitstreamWriteBits(stream, 3, vui->video_format);
-        BitstreamWrite1Bit(stream, vui->video_full_range_flag);
-        temp = vui->colour_description_present_flag;
-        BitstreamWrite1Bit(stream, temp);
-        if (temp)
-        {
-            BitstreamWriteBits(stream, 8, vui->colour_primaries);
-            BitstreamWriteBits(stream, 8, vui->transfer_characteristics);
-            BitstreamWriteBits(stream, 8, vui->matrix_coefficients);
-        }
-    }
-    temp = vui->chroma_location_info_present_flag;
-    BitstreamWrite1Bit(stream, temp);
-    if (temp)
-    {
-        ue_v(stream, vui->chroma_sample_loc_type_top_field);
-        ue_v(stream, vui->chroma_sample_loc_type_bottom_field);
-    }
-
-    temp = vui->timing_info_present_flag;
-    BitstreamWrite1Bit(stream, temp);
-    if (temp)
-    {
-        BitstreamWriteBits(stream, 32, vui->num_units_in_tick);
-        BitstreamWriteBits(stream, 32, vui->time_scale);
-        BitstreamWrite1Bit(stream, vui->fixed_frame_rate_flag);
-    }
-
-    temp = vui->nal_hrd_parameters_present_flag;
-    BitstreamWrite1Bit(stream, temp);
-    if (temp)
-    {
-        EncodeHRD(stream, &(vui->nal_hrd_parameters));
-    }
-    temp = vui->vcl_hrd_parameters_present_flag;
-    BitstreamWrite1Bit(stream, temp);
-    if (temp)
-    {
-        EncodeHRD(stream, &(vui->vcl_hrd_parameters));
-    }
-    if (vui->nal_hrd_parameters_present_flag || vui->vcl_hrd_parameters_present_flag)
-    {
-        BitstreamWrite1Bit(stream, vui->low_delay_hrd_flag);
-    }
-    BitstreamWrite1Bit(stream, vui->pic_struct_present_flag);
-    temp = vui->bitstream_restriction_flag;
-    BitstreamWrite1Bit(stream, temp);
-    if (temp)
-    {
-        BitstreamWrite1Bit(stream, vui->motion_vectors_over_pic_boundaries_flag);
-        ue_v(stream, vui->max_bytes_per_pic_denom);
-        ue_v(stream, vui->max_bits_per_mb_denom);
-        ue_v(stream, vui->log2_max_mv_length_horizontal);
-        ue_v(stream, vui->log2_max_mv_length_vertical);
-        ue_v(stream, vui->max_dec_frame_reordering);
-        ue_v(stream, vui->max_dec_frame_buffering);
-    }
-
-    return ;
-}
-
-
-void EncodeHRD(AVCEncBitstream* stream, AVCHRDParams* hrd)
-{
-    int i;
-
-    ue_v(stream, hrd->cpb_cnt_minus1);
-    BitstreamWriteBits(stream, 4, hrd->bit_rate_scale);
-    BitstreamWriteBits(stream, 4, hrd->cpb_size_scale);
-    for (i = 0; i <= (int)hrd->cpb_cnt_minus1; i++)
-    {
-        ue_v(stream, hrd->bit_rate_value_minus1[i]);
-        ue_v(stream, hrd->cpb_size_value_minus1[i]);
-        ue_v(stream, hrd->cbr_flag[i]);
-    }
-    BitstreamWriteBits(stream, 5, hrd->initial_cpb_removal_delay_length_minus1);
-    BitstreamWriteBits(stream, 5, hrd->cpb_removal_delay_length_minus1);
-    BitstreamWriteBits(stream, 5, hrd->dpb_output_delay_length_minus1);
-    BitstreamWriteBits(stream, 5, hrd->time_offset_length);
-
-    return ;
-}
-
-
-
-/** see subclause 7.4.2.2 */
-/* no need for checking the valid range , already done in SetEncodeParam().
-If we have to send another SPS, the ranges should be verified first before
-users call PVAVCEncodeSPS()*/
-AVCEnc_Status EncodePPS(AVCEncObject *encvid, AVCEncBitstream *stream)
-{
-    AVCCommonObj *video = encvid->common;
-    AVCEnc_Status status = AVCENC_SUCCESS;
-    AVCPicParamSet *picParam = video->currPicParams;
-    int i, iGroup, numBits;
-    uint temp;
-
-    status = ue_v(stream, picParam->pic_parameter_set_id);
-    status = ue_v(stream, picParam->seq_parameter_set_id);
-    status = BitstreamWrite1Bit(stream, picParam->entropy_coding_mode_flag);
-    status = BitstreamWrite1Bit(stream, picParam->pic_order_present_flag);
-    if (status != AVCENC_SUCCESS)
-    {
-        return status;
-    }
-
-    status = ue_v(stream, picParam->num_slice_groups_minus1);
-    if (picParam->num_slice_groups_minus1 > 0)
-    {
-        status = ue_v(stream, picParam->slice_group_map_type);
-        if (picParam->slice_group_map_type == 0)
-        {
-            for (iGroup = 0; iGroup <= (int)picParam->num_slice_groups_minus1; iGroup++)
-            {
-                status = ue_v(stream, picParam->run_length_minus1[iGroup]);
-            }
-        }
-        else if (picParam->slice_group_map_type == 2)
-        {
-            for (iGroup = 0; iGroup < (int)picParam->num_slice_groups_minus1; iGroup++)
-            {
-                status = ue_v(stream, picParam->top_left[iGroup]);
-                status = ue_v(stream, picParam->bottom_right[iGroup]);
-            }
-        }
-        else if (picParam->slice_group_map_type == 3 ||
-                 picParam->slice_group_map_type == 4 ||
-                 picParam->slice_group_map_type == 5)
-        {
-            status = BitstreamWrite1Bit(stream, picParam->slice_group_change_direction_flag);
-            status = ue_v(stream, picParam->slice_group_change_rate_minus1);
-        }
-        else /*if(picParam->slice_group_map_type == 6)*/
-        {
-            status = ue_v(stream, picParam->pic_size_in_map_units_minus1);
-
-            numBits = 0;/* ceil(log2(num_slice_groups_minus1+1)) bits */
-            i = picParam->num_slice_groups_minus1;
-            while (i > 0)
-            {
-                numBits++;
-                i >>= 1;
-            }
-
-            for (i = 0; i <= (int)picParam->pic_size_in_map_units_minus1; i++)
-            {
-                status = BitstreamWriteBits(stream, numBits, picParam->slice_group_id[i]);
-            }
-        }
-    }
-    if (status != AVCENC_SUCCESS)
-    {
-        return status;
-    }
-
-    status = ue_v(stream, picParam->num_ref_idx_l0_active_minus1);
-    status = ue_v(stream, picParam->num_ref_idx_l1_active_minus1);
-    status = BitstreamWrite1Bit(stream, picParam->weighted_pred_flag);
-    status = BitstreamWriteBits(stream, 2, picParam->weighted_bipred_idc);
-    if (status != AVCENC_SUCCESS)
-    {
-        return status;
-    }
-
-    status = se_v(stream, picParam->pic_init_qp_minus26);
-    status = se_v(stream, picParam->pic_init_qs_minus26);
-    status = se_v(stream, picParam->chroma_qp_index_offset);
-
-    temp = picParam->deblocking_filter_control_present_flag << 2;
-    temp |= (picParam->constrained_intra_pred_flag << 1);
-    temp |= picParam->redundant_pic_cnt_present_flag;
-
-    status = BitstreamWriteBits(stream, 3, temp);
-
-    return status;
-}
-
-/** see subclause 7.4.3 */
-AVCEnc_Status EncodeSliceHeader(AVCEncObject *encvid, AVCEncBitstream *stream)
-{
-    AVCCommonObj *video = encvid->common;
-    AVCSliceHeader *sliceHdr = video->sliceHdr;
-    AVCPicParamSet *currPPS = video->currPicParams;
-    AVCSeqParamSet *currSPS = video->currSeqParams;
-    AVCEnc_Status status = AVCENC_SUCCESS;
-    int slice_type, temp, i;
-    int num_bits;
-
-    num_bits = (stream->write_pos << 3) - stream->bit_left;
-
-    status = ue_v(stream, sliceHdr->first_mb_in_slice);
-
-    slice_type = video->slice_type;
-
-    if (video->mbNum == 0) /* first mb in frame */
-    {
-        status = ue_v(stream, sliceHdr->slice_type);
-    }
-    else
-    {
-        status = ue_v(stream, slice_type);
-    }
-
-    status = ue_v(stream, sliceHdr->pic_parameter_set_id);
-
-    status = BitstreamWriteBits(stream, currSPS->log2_max_frame_num_minus4 + 4, sliceHdr->frame_num);
-
-    if (status != AVCENC_SUCCESS)
-    {
-        return status;
-    }
-    /* if frame_mbs_only_flag is 0, encode field_pic_flag, bottom_field_flag here */
-
-    if (video->nal_unit_type == AVC_NALTYPE_IDR)
-    {
-        status = ue_v(stream, sliceHdr->idr_pic_id);
-    }
-
-    if (currSPS->pic_order_cnt_type == 0)
-    {
-        status = BitstreamWriteBits(stream, currSPS->log2_max_pic_order_cnt_lsb_minus4 + 4,
-                                    sliceHdr->pic_order_cnt_lsb);
-
-        if (currPPS->pic_order_present_flag && !sliceHdr->field_pic_flag)
-        {
-            status = se_v(stream, sliceHdr->delta_pic_order_cnt_bottom); /* 32 bits */
-        }
-    }
-    if (currSPS->pic_order_cnt_type == 1 && !currSPS->delta_pic_order_always_zero_flag)
-    {
-        status = se_v(stream, sliceHdr->delta_pic_order_cnt[0]);    /* 32 bits */
-        if (currPPS->pic_order_present_flag && !sliceHdr->field_pic_flag)
-        {
-            status = se_v(stream, sliceHdr->delta_pic_order_cnt[1]); /* 32 bits */
-        }
-    }
-
-    if (currPPS->redundant_pic_cnt_present_flag)
-    {
-        status = ue_v(stream, sliceHdr->redundant_pic_cnt);
-    }
-
-    if (slice_type == AVC_B_SLICE)
-    {
-        status = BitstreamWrite1Bit(stream, sliceHdr->direct_spatial_mv_pred_flag);
-    }
-
-    if (status != AVCENC_SUCCESS)
-    {
-        return status;
-    }
-
-    if (slice_type == AVC_P_SLICE || slice_type == AVC_SP_SLICE || slice_type == AVC_B_SLICE)
-    {
-        status = BitstreamWrite1Bit(stream, sliceHdr->num_ref_idx_active_override_flag);
-        if (sliceHdr->num_ref_idx_active_override_flag)
-        {
-            /* we shouldn't enter this part at all */
-            status = ue_v(stream, sliceHdr->num_ref_idx_l0_active_minus1);
-            if (slice_type == AVC_B_SLICE)
-            {
-                status = ue_v(stream, sliceHdr->num_ref_idx_l1_active_minus1);
-            }
-        }
-    }
-    if (status != AVCENC_SUCCESS)
-    {
-        return status;
-    }
-
-    /* ref_pic_list_reordering() */
-    status = ref_pic_list_reordering(video, stream, sliceHdr, slice_type);
-    if (status != AVCENC_SUCCESS)
-    {
-        return status;
-    }
-
-    if ((currPPS->weighted_pred_flag && (slice_type == AVC_P_SLICE || slice_type == AVC_SP_SLICE)) ||
-            (currPPS->weighted_bipred_idc == 1 && slice_type == AVC_B_SLICE))
-    {
-        //      pred_weight_table(); // not supported !!
-        return AVCENC_PRED_WEIGHT_TAB_FAIL;
-    }
-
-    if (video->nal_ref_idc != 0)
-    {
-        status = dec_ref_pic_marking(video, stream, sliceHdr);
-        if (status != AVCENC_SUCCESS)
-        {
-            return status;
-        }
-    }
-
-    if (currPPS->entropy_coding_mode_flag && slice_type != AVC_I_SLICE && slice_type != AVC_SI_SLICE)
-    {
-        return AVCENC_CABAC_FAIL;
-        /*      ue_v(stream,&(sliceHdr->cabac_init_idc));
-                if(sliceHdr->cabac_init_idc > 2){
-                    // not supported !!!!
-                }*/
-    }
-
-    status = se_v(stream, sliceHdr->slice_qp_delta);
-    if (status != AVCENC_SUCCESS)
-    {
-        return status;
-    }
-
-    if (slice_type == AVC_SP_SLICE || slice_type == AVC_SI_SLICE)
-    {
-        if (slice_type == AVC_SP_SLICE)
-        {
-            status = BitstreamWrite1Bit(stream, sliceHdr->sp_for_switch_flag);
-            /* if sp_for_switch_flag is 0, P macroblocks in SP slice is decoded using
-            SP decoding process for non-switching pictures in 8.6.1 */
-            /* else, P macroblocks in SP slice is decoded using SP and SI decoding
-            process for switching picture in 8.6.2 */
-        }
-        status = se_v(stream, sliceHdr->slice_qs_delta);
-        if (status != AVCENC_SUCCESS)
-        {
-            return status;
-        }
-    }
-
-    if (currPPS->deblocking_filter_control_present_flag)
-    {
-
-        status = ue_v(stream, sliceHdr->disable_deblocking_filter_idc);
-
-        if (sliceHdr->disable_deblocking_filter_idc != 1)
-        {
-            status = se_v(stream, sliceHdr->slice_alpha_c0_offset_div2);
-
-            status = se_v(stream, sliceHdr->slice_beta_offset_div_2);
-        }
-        if (status != AVCENC_SUCCESS)
-        {
-            return status;
-        }
-    }
-
-    if (currPPS->num_slice_groups_minus1 > 0 && currPPS->slice_group_map_type >= 3
-            && currPPS->slice_group_map_type <= 5)
-    {
-        /* Ceil(Log2(PicSizeInMapUnits/(float)SliceGroupChangeRate + 1)) */
-        temp = video->PicSizeInMapUnits / video->SliceGroupChangeRate;
-        if (video->PicSizeInMapUnits % video->SliceGroupChangeRate)
-        {
-            temp++;
-        }
-        i = 0;
-        while (temp > 1)
-        {
-            temp >>= 1;
-            i++;
-        }
-
-        BitstreamWriteBits(stream, i, sliceHdr->slice_group_change_cycle);
-    }
-
-
-    encvid->rateCtrl->NumberofHeaderBits += (stream->write_pos << 3) - stream->bit_left - num_bits;
-
-    return AVCENC_SUCCESS;
-}
-
-/** see subclause 7.4.3.1 */
-AVCEnc_Status ref_pic_list_reordering(AVCCommonObj *video, AVCEncBitstream *stream, AVCSliceHeader *sliceHdr, int slice_type)
-{
-    (void)(video);
-    int i;
-    AVCEnc_Status status = AVCENC_SUCCESS;
-
-    if (slice_type != AVC_I_SLICE && slice_type != AVC_SI_SLICE)
-    {
-        status = BitstreamWrite1Bit(stream, sliceHdr->ref_pic_list_reordering_flag_l0);
-        if (sliceHdr->ref_pic_list_reordering_flag_l0)
-        {
-            i = 0;
-            do
-            {
-                status = ue_v(stream, sliceHdr->reordering_of_pic_nums_idc_l0[i]);
-                if (sliceHdr->reordering_of_pic_nums_idc_l0[i] == 0 ||
-                        sliceHdr->reordering_of_pic_nums_idc_l0[i] == 1)
-                {
-                    status = ue_v(stream, sliceHdr->abs_diff_pic_num_minus1_l0[i]);
-                    /* this check should be in InitSlice(), if we ever use it */
-                    /*if(sliceHdr->reordering_of_pic_nums_idc_l0[i] == 0 &&
-                        sliceHdr->abs_diff_pic_num_minus1_l0[i] > video->MaxPicNum/2 -1)
-                    {
-                        return AVCENC_REF_PIC_REORDER_FAIL; // out of range
-                    }
-                    if(sliceHdr->reordering_of_pic_nums_idc_l0[i] == 1 &&
-                        sliceHdr->abs_diff_pic_num_minus1_l0[i] > video->MaxPicNum/2 -2)
-                    {
-                        return AVCENC_REF_PIC_REORDER_FAIL; // out of range
-                    }*/
-                }
-                else if (sliceHdr->reordering_of_pic_nums_idc_l0[i] == 2)
-                {
-                    status = ue_v(stream, sliceHdr->long_term_pic_num_l0[i]);
-                }
-                i++;
-            }
-            while (sliceHdr->reordering_of_pic_nums_idc_l0[i] != 3
-                    && i <= (int)sliceHdr->num_ref_idx_l0_active_minus1 + 1) ;
-        }
-    }
-    if (slice_type == AVC_B_SLICE)
-    {
-        status = BitstreamWrite1Bit(stream, sliceHdr->ref_pic_list_reordering_flag_l1);
-        if (sliceHdr->ref_pic_list_reordering_flag_l1)
-        {
-            i = 0;
-            do
-            {
-                status = ue_v(stream, sliceHdr->reordering_of_pic_nums_idc_l1[i]);
-                if (sliceHdr->reordering_of_pic_nums_idc_l1[i] == 0 ||
-                        sliceHdr->reordering_of_pic_nums_idc_l1[i] == 1)
-                {
-                    status = ue_v(stream, sliceHdr->abs_diff_pic_num_minus1_l1[i]);
-                    /* This check should be in InitSlice() if we ever use it
-                    if(sliceHdr->reordering_of_pic_nums_idc_l1[i] == 0 &&
-                        sliceHdr->abs_diff_pic_num_minus1_l1[i] > video->MaxPicNum/2 -1)
-                    {
-                        return AVCENC_REF_PIC_REORDER_FAIL; // out of range
-                    }
-                    if(sliceHdr->reordering_of_pic_nums_idc_l1[i] == 1 &&
-                        sliceHdr->abs_diff_pic_num_minus1_l1[i] > video->MaxPicNum/2 -2)
-                    {
-                        return AVCENC_REF_PIC_REORDER_FAIL; // out of range
-                    }*/
-                }
-                else if (sliceHdr->reordering_of_pic_nums_idc_l1[i] == 2)
-                {
-                    status = ue_v(stream, sliceHdr->long_term_pic_num_l1[i]);
-                }
-                i++;
-            }
-            while (sliceHdr->reordering_of_pic_nums_idc_l1[i] != 3
-                    && i <= (int)sliceHdr->num_ref_idx_l1_active_minus1 + 1) ;
-        }
-    }
-
-    return status;
-}
-
-/** see subclause 7.4.3.3 */
-AVCEnc_Status dec_ref_pic_marking(AVCCommonObj *video, AVCEncBitstream *stream, AVCSliceHeader *sliceHdr)
-{
-    int i;
-    AVCEnc_Status status = AVCENC_SUCCESS;
-
-    if (video->nal_unit_type == AVC_NALTYPE_IDR)
-    {
-        status = BitstreamWrite1Bit(stream, sliceHdr->no_output_of_prior_pics_flag);
-        status = BitstreamWrite1Bit(stream, sliceHdr->long_term_reference_flag);
-        if (sliceHdr->long_term_reference_flag == 0) /* used for short-term */
-        {
-            video->MaxLongTermFrameIdx = -1; /* no long-term frame indx */
-        }
-        else /* used for long-term */
-        {
-            video->MaxLongTermFrameIdx = 0;
-            video->LongTermFrameIdx = 0;
-        }
-    }
-    else
-    {
-        status = BitstreamWrite1Bit(stream, sliceHdr->adaptive_ref_pic_marking_mode_flag); /* default to zero */
-        if (sliceHdr->adaptive_ref_pic_marking_mode_flag)
-        {
-            i = 0;
-            do
-            {
-                status = ue_v(stream, sliceHdr->memory_management_control_operation[i]);
-                if (sliceHdr->memory_management_control_operation[i] == 1 ||
-                        sliceHdr->memory_management_control_operation[i] == 3)
-                {
-                    status = ue_v(stream, sliceHdr->difference_of_pic_nums_minus1[i]);
-                }
-                if (sliceHdr->memory_management_control_operation[i] == 2)
-                {
-                    status = ue_v(stream, sliceHdr->long_term_pic_num[i]);
-                }
-                if (sliceHdr->memory_management_control_operation[i] == 3 ||
-                        sliceHdr->memory_management_control_operation[i] == 6)
-                {
-                    status = ue_v(stream, sliceHdr->long_term_frame_idx[i]);
-                }
-                if (sliceHdr->memory_management_control_operation[i] == 4)
-                {
-                    status = ue_v(stream, sliceHdr->max_long_term_frame_idx_plus1[i]);
-                }
-                i++;
-            }
-            while (sliceHdr->memory_management_control_operation[i] != 0 && i < MAX_DEC_REF_PIC_MARKING);
-            if (i >= MAX_DEC_REF_PIC_MARKING && sliceHdr->memory_management_control_operation[i] != 0)
-            {
-                return AVCENC_DEC_REF_PIC_MARK_FAIL; /* we're screwed!!, not enough memory */
-            }
-        }
-    }
-
-    return status;
-}
-
-/* see subclause 8.2.1 Decoding process for picture order count.
-See also PostPOC() for initialization of some variables. */
-AVCEnc_Status InitPOC(AVCEncObject *encvid)
-{
-    AVCCommonObj *video = encvid->common;
-    AVCSeqParamSet *currSPS = video->currSeqParams;
-    AVCSliceHeader *sliceHdr = video->sliceHdr;
-    AVCFrameIO  *currInput = encvid->currInput;
-    int i;
-
-    switch (currSPS->pic_order_cnt_type)
-    {
-        case 0: /* POC MODE 0 , subclause 8.2.1.1 */
-            /* encoding part */
-            if (video->nal_unit_type == AVC_NALTYPE_IDR)
-            {
-                encvid->dispOrdPOCRef = currInput->disp_order;
-            }
-            while (currInput->disp_order < encvid->dispOrdPOCRef)
-            {
-                encvid->dispOrdPOCRef -= video->MaxPicOrderCntLsb;
-            }
-            sliceHdr->pic_order_cnt_lsb = currInput->disp_order - encvid->dispOrdPOCRef;
-            while (sliceHdr->pic_order_cnt_lsb >= video->MaxPicOrderCntLsb)
-            {
-                sliceHdr->pic_order_cnt_lsb -= video->MaxPicOrderCntLsb;
-            }
-            /* decoding part */
-            /* Calculate the MSBs of current picture */
-            if (video->nal_unit_type == AVC_NALTYPE_IDR)
-            {
-                video->prevPicOrderCntMsb = 0;
-                video->prevPicOrderCntLsb = 0;
-            }
-            if (sliceHdr->pic_order_cnt_lsb  <  video->prevPicOrderCntLsb  &&
-                    (video->prevPicOrderCntLsb - sliceHdr->pic_order_cnt_lsb)  >= (video->MaxPicOrderCntLsb / 2))
-                video->PicOrderCntMsb = video->prevPicOrderCntMsb + video->MaxPicOrderCntLsb;
-            else if (sliceHdr->pic_order_cnt_lsb  >  video->prevPicOrderCntLsb  &&
-                     (sliceHdr->pic_order_cnt_lsb - video->prevPicOrderCntLsb)  > (video->MaxPicOrderCntLsb / 2))
-                video->PicOrderCntMsb = video->prevPicOrderCntMsb - video->MaxPicOrderCntLsb;
-            else
-                video->PicOrderCntMsb = video->prevPicOrderCntMsb;
-
-            /* JVT-I010 page 81 is different from JM7.3 */
-            if (!sliceHdr->field_pic_flag || !sliceHdr->bottom_field_flag)
-            {
-                video->PicOrderCnt = video->TopFieldOrderCnt = video->PicOrderCntMsb + sliceHdr->pic_order_cnt_lsb;
-            }
-
-            if (!sliceHdr->field_pic_flag)
-            {
-                video->BottomFieldOrderCnt = video->TopFieldOrderCnt + sliceHdr->delta_pic_order_cnt_bottom;
-            }
-            else if (sliceHdr->bottom_field_flag)
-            {
-                video->PicOrderCnt = video->BottomFieldOrderCnt = video->PicOrderCntMsb + sliceHdr->pic_order_cnt_lsb;
-            }
-
-            if (!sliceHdr->field_pic_flag)
-            {
-                video->PicOrderCnt = AVC_MIN(video->TopFieldOrderCnt, video->BottomFieldOrderCnt);
-            }
-
-            if (video->currPicParams->pic_order_present_flag && !sliceHdr->field_pic_flag)
-            {
-                sliceHdr->delta_pic_order_cnt_bottom = 0; /* defaulted to zero */
-            }
-
-            break;
-        case 1: /* POC MODE 1, subclause 8.2.1.2 */
-            /* calculate FrameNumOffset */
-            if (video->nal_unit_type == AVC_NALTYPE_IDR)
-            {
-                encvid->dispOrdPOCRef = currInput->disp_order;  /* reset the reference point */
-                video->prevFrameNumOffset = 0;
-                video->FrameNumOffset = 0;
-            }
-            else if (video->prevFrameNum > sliceHdr->frame_num)
-            {
-                video->FrameNumOffset = video->prevFrameNumOffset + video->MaxFrameNum;
-            }
-            else
-            {
-                video->FrameNumOffset = video->prevFrameNumOffset;
-            }
-            /* calculate absFrameNum */
-            if (currSPS->num_ref_frames_in_pic_order_cnt_cycle)
-            {
-                video->absFrameNum = video->FrameNumOffset + sliceHdr->frame_num;
-            }
-            else
-            {
-                video->absFrameNum = 0;
-            }
-
-            if (video->absFrameNum > 0 && video->nal_ref_idc == 0)
-            {
-                video->absFrameNum--;
-            }
-
-            /* derive picOrderCntCycleCnt and frameNumInPicOrderCntCycle */
-            if (video->absFrameNum > 0)
-            {
-                video->picOrderCntCycleCnt = (video->absFrameNum - 1) / currSPS->num_ref_frames_in_pic_order_cnt_cycle;
-                video->frameNumInPicOrderCntCycle = (video->absFrameNum - 1) % currSPS->num_ref_frames_in_pic_order_cnt_cycle;
-            }
-            /* derive expectedDeltaPerPicOrderCntCycle, this value can be computed up front. */
-            video->expectedDeltaPerPicOrderCntCycle = 0;
-            for (i = 0; i < (int)currSPS->num_ref_frames_in_pic_order_cnt_cycle; i++)
-            {
-                video->expectedDeltaPerPicOrderCntCycle += currSPS->offset_for_ref_frame[i];
-            }
-            /* derive expectedPicOrderCnt */
-            if (video->absFrameNum)
-            {
-                video->expectedPicOrderCnt = video->picOrderCntCycleCnt * video->expectedDeltaPerPicOrderCntCycle;
-                for (i = 0; i <= video->frameNumInPicOrderCntCycle; i++)
-                {
-                    video->expectedPicOrderCnt += currSPS->offset_for_ref_frame[i];
-                }
-            }
-            else
-            {
-                video->expectedPicOrderCnt = 0;
-            }
-
-            if (video->nal_ref_idc == 0)
-            {
-                video->expectedPicOrderCnt += currSPS->offset_for_non_ref_pic;
-            }
-            /* derive TopFieldOrderCnt and BottomFieldOrderCnt */
-            /* encoding part */
-            if (!currSPS->delta_pic_order_always_zero_flag)
-            {
-                sliceHdr->delta_pic_order_cnt[0] = currInput->disp_order - encvid->dispOrdPOCRef - video->expectedPicOrderCnt;
-
-                if (video->currPicParams->pic_order_present_flag && !sliceHdr->field_pic_flag)
-                {
-                    sliceHdr->delta_pic_order_cnt[1] = sliceHdr->delta_pic_order_cnt[0]; /* should be calculated from currInput->bottom_field->disp_order */
-                }
-                else
-                {
-                    sliceHdr->delta_pic_order_cnt[1] = 0;
-                }
-            }
-            else
-            {
-                sliceHdr->delta_pic_order_cnt[0] = sliceHdr->delta_pic_order_cnt[1] = 0;
-            }
-
-            if (sliceHdr->field_pic_flag == 0)
-            {
-                video->TopFieldOrderCnt = video->expectedPicOrderCnt + sliceHdr->delta_pic_order_cnt[0];
-                video->BottomFieldOrderCnt = video->TopFieldOrderCnt + currSPS->offset_for_top_to_bottom_field + sliceHdr->delta_pic_order_cnt[1];
-
-                video->PicOrderCnt = AVC_MIN(video->TopFieldOrderCnt, video->BottomFieldOrderCnt);
-            }
-            else if (sliceHdr->bottom_field_flag == 0)
-            {
-                video->TopFieldOrderCnt = video->expectedPicOrderCnt + sliceHdr->delta_pic_order_cnt[0];
-                video->PicOrderCnt = video->TopFieldOrderCnt;
-            }
-            else
-            {
-                video->BottomFieldOrderCnt = video->expectedPicOrderCnt + currSPS->offset_for_top_to_bottom_field + sliceHdr->delta_pic_order_cnt[0];
-                video->PicOrderCnt = video->BottomFieldOrderCnt;
-            }
-            break;
-
-
-        case 2: /* POC MODE 2, subclause 8.2.1.3 */
-            /* decoding order must be the same as display order */
-            /* we don't check for that. The decoder will just output in decoding order. */
-            /* Check for 2 consecutive non-reference frame */
-            if (video->nal_ref_idc == 0)
-            {
-                if (encvid->dispOrdPOCRef == 1)
-                {
-                    return AVCENC_CONSECUTIVE_NONREF;
-                }
-                encvid->dispOrdPOCRef = 1;  /* act as a flag for non ref */
-            }
-            else
-            {
-                encvid->dispOrdPOCRef = 0;
-            }
-
-
-            if (video->nal_unit_type == AVC_NALTYPE_IDR)
-            {
-                video->FrameNumOffset = 0;
-            }
-            else if (video->prevFrameNum > sliceHdr->frame_num)
-            {
-                video->FrameNumOffset = video->prevFrameNumOffset + video->MaxFrameNum;
-            }
-            else
-            {
-                video->FrameNumOffset = video->prevFrameNumOffset;
-            }
-            /* derive tempPicOrderCnt, we just use PicOrderCnt */
-            if (video->nal_unit_type == AVC_NALTYPE_IDR)
-            {
-                video->PicOrderCnt = 0;
-            }
-            else if (video->nal_ref_idc == 0)
-            {
-                video->PicOrderCnt = 2 * (video->FrameNumOffset + sliceHdr->frame_num) - 1;
-            }
-            else
-            {
-                video->PicOrderCnt = 2 * (video->FrameNumOffset + sliceHdr->frame_num);
-            }
-            /* derive TopFieldOrderCnt and BottomFieldOrderCnt */
-            if (sliceHdr->field_pic_flag == 0)
-            {
-                video->TopFieldOrderCnt = video->BottomFieldOrderCnt = video->PicOrderCnt;
-            }
-            else if (sliceHdr->bottom_field_flag)
-            {
-                video->BottomFieldOrderCnt = video->PicOrderCnt;
-            }
-            else
-            {
-                video->TopFieldOrderCnt = video->PicOrderCnt;
-            }
-            break;
-        default:
-            return AVCENC_POC_FAIL;
-    }
-
-    return AVCENC_SUCCESS;
-}
-
-/** see subclause 8.2.1 */
-AVCEnc_Status PostPOC(AVCCommonObj *video)
-{
-    AVCSliceHeader *sliceHdr = video->sliceHdr;
-    AVCSeqParamSet *currSPS = video->currSeqParams;
-
-    video->prevFrameNum = sliceHdr->frame_num;
-
-    switch (currSPS->pic_order_cnt_type)
-    {
-        case 0: /* subclause 8.2.1.1 */
-            if (video->mem_mgr_ctrl_eq_5)
-            {
-                video->prevPicOrderCntMsb = 0;
-                video->prevPicOrderCntLsb = video->TopFieldOrderCnt;
-            }
-            else
-            {
-                video->prevPicOrderCntMsb = video->PicOrderCntMsb;
-                video->prevPicOrderCntLsb = sliceHdr->pic_order_cnt_lsb;
-            }
-            break;
-        case 1:  /* subclause 8.2.1.2 and 8.2.1.3 */
-        case 2:
-            if (video->mem_mgr_ctrl_eq_5)
-            {
-                video->prevFrameNumOffset = 0;
-            }
-            else
-            {
-                video->prevFrameNumOffset = video->FrameNumOffset;
-            }
-            break;
-    }
-
-    return AVCENC_SUCCESS;
-}
-
diff --git a/media/libstagefright/codecs/avc/enc/src/init.cpp b/media/libstagefright/codecs/avc/enc/src/init.cpp
deleted file mode 100644
index 6e1413a..0000000
--- a/media/libstagefright/codecs/avc/enc/src/init.cpp
+++ /dev/null
@@ -1,895 +0,0 @@
-/* ------------------------------------------------------------------
- * 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 "avcenc_lib.h"
-#include "avcenc_api.h"
-
-#define LOG2_MAX_FRAME_NUM_MINUS4   12   /* 12 default */
-#define SLICE_GROUP_CHANGE_CYCLE    1    /* default */
-
-/* initialized variables to be used in SPS*/
-AVCEnc_Status  SetEncodeParam(AVCHandle* avcHandle, AVCEncParams* encParam,
-                              void* extSPS, void* extPPS)
-{
-    AVCEncObject *encvid = (AVCEncObject*) avcHandle->AVCObject;
-    AVCCommonObj *video = encvid->common;
-    AVCSeqParamSet *seqParam = video->currSeqParams;
-    AVCPicParamSet *picParam = video->currPicParams;
-    AVCSliceHeader *sliceHdr = video->sliceHdr;
-    AVCRateControl *rateCtrl = encvid->rateCtrl;
-    AVCEnc_Status status;
-    void *userData = avcHandle->userData;
-    int ii, maxFrameNum;
-
-    AVCSeqParamSet* extS = NULL;
-    AVCPicParamSet* extP = NULL;
-
-    if (extSPS) extS = (AVCSeqParamSet*) extSPS;
-    if (extPPS) extP = (AVCPicParamSet*) extPPS;
-
-    /* This part sets the default values of the encoding options this
-    library supports in seqParam, picParam and sliceHdr structures and
-    also copy the values from the encParam into the above 3 structures.
-
-    Some parameters will be assigned later when we encode SPS or PPS such as
-    the seq_parameter_id or pic_parameter_id. Also some of the slice parameters
-    have to be re-assigned per slice basis such as frame_num, slice_type,
-    first_mb_in_slice, pic_order_cnt_lsb, slice_qp_delta, slice_group_change_cycle */
-
-    /* profile_idc, constrained_setx_flag and level_idc is set by VerifyProfile(),
-    and VerifyLevel() functions later. */
-
-    encvid->fullsearch_enable = encParam->fullsearch;
-
-    encvid->outOfBandParamSet = ((encParam->out_of_band_param_set == AVC_ON) ? TRUE : FALSE);
-
-    /* parameters derived from the the encParam that are used in SPS */
-    if (extS)
-    {
-        video->MaxPicOrderCntLsb =  1 << (extS->log2_max_pic_order_cnt_lsb_minus4 + 4);
-        video->PicWidthInMbs = extS->pic_width_in_mbs_minus1 + 1;
-        video->PicHeightInMapUnits = extS->pic_height_in_map_units_minus1 + 1 ;
-        video->FrameHeightInMbs = (2 - extS->frame_mbs_only_flag) * video->PicHeightInMapUnits ;
-    }
-    else
-    {
-        video->MaxPicOrderCntLsb =  1 << (encParam->log2_max_poc_lsb_minus_4 + 4);
-        video->PicWidthInMbs = (encParam->width + 15) >> 4; /* round it to multiple of 16 */
-        video->FrameHeightInMbs = (encParam->height + 15) >> 4; /* round it to multiple of 16 */
-        video->PicHeightInMapUnits = video->FrameHeightInMbs;
-    }
-
-    video->PicWidthInSamplesL = video->PicWidthInMbs * 16 ;
-    if (video->PicWidthInSamplesL + 32 > 0xFFFF)
-    {
-        return AVCENC_NOT_SUPPORTED; // we use 2-bytes for pitch
-    }
-
-    video->PicWidthInSamplesC = video->PicWidthInMbs * 8 ;
-    video->PicHeightInMbs = video->FrameHeightInMbs;
-    video->PicSizeInMapUnits = video->PicWidthInMbs * video->PicHeightInMapUnits ;
-    video->PicHeightInSamplesL = video->PicHeightInMbs * 16;
-    video->PicHeightInSamplesC = video->PicHeightInMbs * 8;
-    video->PicSizeInMbs = video->PicWidthInMbs * video->PicHeightInMbs;
-
-    if (!extS && !extP)
-    {
-        maxFrameNum = (encParam->idr_period == -1) ? (1 << 16) : encParam->idr_period;
-        ii = 0;
-        while (maxFrameNum > 0)
-        {
-            ii++;
-            maxFrameNum >>= 1;
-        }
-        if (ii < 4) ii = 4;
-        else if (ii > 16) ii = 16;
-
-        seqParam->log2_max_frame_num_minus4 = ii - 4;//LOG2_MAX_FRAME_NUM_MINUS4; /* default */
-
-        video->MaxFrameNum = 1 << ii; //(LOG2_MAX_FRAME_NUM_MINUS4 + 4); /* default */
-        video->MaxPicNum = video->MaxFrameNum;
-
-        /************* set the SPS *******************/
-        seqParam->seq_parameter_set_id = 0; /* start with zero */
-        /* POC */
-        seqParam->pic_order_cnt_type = encParam->poc_type; /* POC type */
-        if (encParam->poc_type == 0)
-        {
-            if (/*encParam->log2_max_poc_lsb_minus_4<0 || (no need, it's unsigned)*/
-                encParam->log2_max_poc_lsb_minus_4 > 12)
-            {
-                return AVCENC_INVALID_POC_LSB;
-            }
-            seqParam->log2_max_pic_order_cnt_lsb_minus4 = encParam->log2_max_poc_lsb_minus_4;
-        }
-        else if (encParam->poc_type == 1)
-        {
-            seqParam->delta_pic_order_always_zero_flag = encParam->delta_poc_zero_flag;
-            seqParam->offset_for_non_ref_pic = encParam->offset_poc_non_ref;
-            seqParam->offset_for_top_to_bottom_field = encParam->offset_top_bottom;
-            seqParam->num_ref_frames_in_pic_order_cnt_cycle = encParam->num_ref_in_cycle;
-            if (encParam->offset_poc_ref == NULL)
-            {
-                return AVCENC_ENCPARAM_MEM_FAIL;
-            }
-            for (ii = 0; ii < encParam->num_ref_frame; ii++)
-            {
-                seqParam->offset_for_ref_frame[ii] = encParam->offset_poc_ref[ii];
-            }
-        }
-        /* number of reference frame */
-        if (encParam->num_ref_frame > 16 || encParam->num_ref_frame < 0)
-        {
-            return AVCENC_INVALID_NUM_REF;
-        }
-        seqParam->num_ref_frames = encParam->num_ref_frame; /* num reference frame range 0...16*/
-        seqParam->gaps_in_frame_num_value_allowed_flag = FALSE;
-        seqParam->pic_width_in_mbs_minus1 = video->PicWidthInMbs - 1;
-        seqParam->pic_height_in_map_units_minus1 = video->PicHeightInMapUnits - 1;
-        seqParam->frame_mbs_only_flag = TRUE;
-        seqParam->mb_adaptive_frame_field_flag = FALSE;
-        seqParam->direct_8x8_inference_flag = FALSE; /* default */
-        seqParam->frame_cropping_flag = FALSE;
-        seqParam->frame_crop_bottom_offset = 0;
-        seqParam->frame_crop_left_offset = 0;
-        seqParam->frame_crop_right_offset = 0;
-        seqParam->frame_crop_top_offset = 0;
-        seqParam->vui_parameters_present_flag = FALSE; /* default */
-    }
-    else if (extS) // use external SPS and PPS
-    {
-        seqParam->seq_parameter_set_id = extS->seq_parameter_set_id;
-        seqParam->log2_max_frame_num_minus4 = extS->log2_max_frame_num_minus4;
-        video->MaxFrameNum = 1 << (extS->log2_max_frame_num_minus4 + 4);
-        video->MaxPicNum = video->MaxFrameNum;
-        if (encParam->idr_period > (int)(video->MaxFrameNum) || (encParam->idr_period == -1))
-        {
-            encParam->idr_period = (int)video->MaxFrameNum;
-        }
-
-        seqParam->pic_order_cnt_type = extS->pic_order_cnt_type;
-        if (seqParam->pic_order_cnt_type == 0)
-        {
-            if (/*extS->log2_max_pic_order_cnt_lsb_minus4<0 || (no need it's unsigned)*/
-                extS->log2_max_pic_order_cnt_lsb_minus4 > 12)
-            {
-                return AVCENC_INVALID_POC_LSB;
-            }
-            seqParam->log2_max_pic_order_cnt_lsb_minus4 = extS->log2_max_pic_order_cnt_lsb_minus4;
-        }
-        else if (seqParam->pic_order_cnt_type == 1)
-        {
-            seqParam->delta_pic_order_always_zero_flag = extS->delta_pic_order_always_zero_flag;
-            seqParam->offset_for_non_ref_pic = extS->offset_for_non_ref_pic;
-            seqParam->offset_for_top_to_bottom_field = extS->offset_for_top_to_bottom_field;
-            seqParam->num_ref_frames_in_pic_order_cnt_cycle = extS->num_ref_frames_in_pic_order_cnt_cycle;
-            for (ii = 0; ii < (int) extS->num_ref_frames; ii++)
-            {
-                seqParam->offset_for_ref_frame[ii] = extS->offset_for_ref_frame[ii];
-            }
-        }
-        /* number of reference frame */
-        if (extS->num_ref_frames > 16 /*|| extS->num_ref_frames<0 (no need, it's unsigned)*/)
-        {
-            return AVCENC_INVALID_NUM_REF;
-        }
-        seqParam->num_ref_frames = extS->num_ref_frames; /* num reference frame range 0...16*/
-        seqParam->gaps_in_frame_num_value_allowed_flag = extS->gaps_in_frame_num_value_allowed_flag;
-        seqParam->pic_width_in_mbs_minus1 = extS->pic_width_in_mbs_minus1;
-        seqParam->pic_height_in_map_units_minus1 = extS->pic_height_in_map_units_minus1;
-        seqParam->frame_mbs_only_flag = extS->frame_mbs_only_flag;
-        if (extS->frame_mbs_only_flag != TRUE)
-        {
-            return AVCENC_NOT_SUPPORTED;
-        }
-        seqParam->mb_adaptive_frame_field_flag = extS->mb_adaptive_frame_field_flag;
-        if (extS->mb_adaptive_frame_field_flag != FALSE)
-        {
-            return AVCENC_NOT_SUPPORTED;
-        }
-
-        seqParam->direct_8x8_inference_flag = extS->direct_8x8_inference_flag;
-        seqParam->frame_cropping_flag = extS->frame_cropping_flag ;
-        if (extS->frame_cropping_flag != FALSE)
-        {
-            return AVCENC_NOT_SUPPORTED;
-        }
-
-        seqParam->frame_crop_bottom_offset = 0;
-        seqParam->frame_crop_left_offset = 0;
-        seqParam->frame_crop_right_offset = 0;
-        seqParam->frame_crop_top_offset = 0;
-        seqParam->vui_parameters_present_flag = extS->vui_parameters_present_flag;
-        if (extS->vui_parameters_present_flag)
-        {
-            memcpy(&(seqParam->vui_parameters), &(extS->vui_parameters), sizeof(AVCVUIParams));
-        }
-    }
-    else
-    {
-        return AVCENC_NOT_SUPPORTED;
-    }
-
-    /***************** now PPS ******************************/
-    if (!extP && !extS)
-    {
-        picParam->pic_parameter_set_id = (uint)(-1); /* start with zero */
-        picParam->seq_parameter_set_id = (uint)(-1); /* start with zero */
-        picParam->entropy_coding_mode_flag = 0; /* default to CAVLC */
-        picParam->pic_order_present_flag = 0; /* default for now, will need it for B-slice */
-        /* FMO */
-        if (encParam->num_slice_group < 1 || encParam->num_slice_group > MAX_NUM_SLICE_GROUP)
-        {
-            return AVCENC_INVALID_NUM_SLICEGROUP;
-        }
-        picParam->num_slice_groups_minus1 = encParam->num_slice_group - 1;
-
-        if (picParam->num_slice_groups_minus1 > 0)
-        {
-            picParam->slice_group_map_type = encParam->fmo_type;
-            switch (encParam->fmo_type)
-            {
-                case 0:
-                    for (ii = 0; ii <= (int)picParam->num_slice_groups_minus1; ii++)
-                    {
-                        picParam->run_length_minus1[ii] = encParam->run_length_minus1[ii];
-                    }
-                    break;
-                case 2:
-                    for (ii = 0; ii < (int)picParam->num_slice_groups_minus1; ii++)
-                    {
-                        picParam->top_left[ii] = encParam->top_left[ii];
-                        picParam->bottom_right[ii] = encParam->bottom_right[ii];
-                    }
-                    break;
-                case 3:
-                case 4:
-                case 5:
-                    if (encParam->change_dir_flag == AVC_ON)
-                    {
-                        picParam->slice_group_change_direction_flag = TRUE;
-                    }
-                    else
-                    {
-                        picParam->slice_group_change_direction_flag = FALSE;
-                    }
-                    if (/*encParam->change_rate_minus1 < 0 || (no need it's unsigned) */
-                        encParam->change_rate_minus1 > video->PicSizeInMapUnits - 1)
-                    {
-                        return AVCENC_INVALID_CHANGE_RATE;
-                    }
-                    picParam->slice_group_change_rate_minus1 = encParam->change_rate_minus1;
-                    video->SliceGroupChangeRate = picParam->slice_group_change_rate_minus1 + 1;
-                    break;
-                case 6:
-                    picParam->pic_size_in_map_units_minus1 = video->PicSizeInMapUnits - 1;
-
-                    /* allocate picParam->slice_group_id */
-                    picParam->slice_group_id = (uint*)avcHandle->CBAVC_Malloc(userData, sizeof(uint) * video->PicSizeInMapUnits, DEFAULT_ATTR);
-                    if (picParam->slice_group_id == NULL)
-                    {
-                        return AVCENC_MEMORY_FAIL;
-                    }
-
-                    if (encParam->slice_group == NULL)
-                    {
-                        return AVCENC_ENCPARAM_MEM_FAIL;
-                    }
-                    for (ii = 0; ii < (int)video->PicSizeInMapUnits; ii++)
-                    {
-                        picParam->slice_group_id[ii] = encParam->slice_group[ii];
-                    }
-                    break;
-                default:
-                    return AVCENC_INVALID_FMO_TYPE;
-            }
-        }
-        picParam->num_ref_idx_l0_active_minus1 = encParam->num_ref_frame - 1; /* assume frame only */
-        picParam->num_ref_idx_l1_active_minus1 = 0; /* default value */
-        picParam->weighted_pred_flag = 0; /* no weighted prediction supported */
-        picParam->weighted_bipred_idc = 0; /* range 0,1,2 */
-        if (/*picParam->weighted_bipred_idc < 0 || (no need, it's unsigned) */
-            picParam->weighted_bipred_idc > 2)
-        {
-            return AVCENC_WEIGHTED_BIPRED_FAIL;
-        }
-        picParam->pic_init_qp_minus26 = 0; /* default, will be changed at slice level anyway */
-        if (picParam->pic_init_qp_minus26 < -26 || picParam->pic_init_qp_minus26 > 25)
-        {
-            return AVCENC_INIT_QP_FAIL; /* out of range */
-        }
-        picParam->pic_init_qs_minus26 = 0;
-        if (picParam->pic_init_qs_minus26 < -26 || picParam->pic_init_qs_minus26 > 25)
-        {
-            return AVCENC_INIT_QS_FAIL; /* out of range */
-        }
-
-        picParam->chroma_qp_index_offset = 0; /* default to zero for now */
-        if (picParam->chroma_qp_index_offset < -12 || picParam->chroma_qp_index_offset > 12)
-        {
-            return AVCENC_CHROMA_QP_FAIL; /* out of range */
-        }
-        /* deblocking */
-        picParam->deblocking_filter_control_present_flag = (encParam->db_filter == AVC_ON) ? TRUE : FALSE ;
-        /* constrained intra prediction */
-        picParam->constrained_intra_pred_flag = (encParam->constrained_intra_pred == AVC_ON) ? TRUE : FALSE;
-        picParam->redundant_pic_cnt_present_flag = 0; /* default */
-    }
-    else if (extP)// external PPS
-    {
-        picParam->pic_parameter_set_id = extP->pic_parameter_set_id - 1; /* to be increased by one */
-        picParam->seq_parameter_set_id = extP->seq_parameter_set_id;
-        picParam->entropy_coding_mode_flag = extP->entropy_coding_mode_flag;
-        if (extP->entropy_coding_mode_flag != 0) /* default to CAVLC */
-        {
-            return AVCENC_NOT_SUPPORTED;
-        }
-        picParam->pic_order_present_flag = extP->pic_order_present_flag; /* default for now, will need it for B-slice */
-        if (extP->pic_order_present_flag != 0)
-        {
-            return AVCENC_NOT_SUPPORTED;
-        }
-        /* FMO */
-        if (/*(extP->num_slice_groups_minus1<0) || (no need it's unsigned) */
-            (extP->num_slice_groups_minus1 > MAX_NUM_SLICE_GROUP - 1))
-        {
-            return AVCENC_INVALID_NUM_SLICEGROUP;
-        }
-        picParam->num_slice_groups_minus1 = extP->num_slice_groups_minus1;
-
-        if (picParam->num_slice_groups_minus1 > 0)
-        {
-            picParam->slice_group_map_type = extP->slice_group_map_type;
-            switch (extP->slice_group_map_type)
-            {
-                case 0:
-                    for (ii = 0; ii <= (int)extP->num_slice_groups_minus1; ii++)
-                    {
-                        picParam->run_length_minus1[ii] = extP->run_length_minus1[ii];
-                    }
-                    break;
-                case 2:
-                    for (ii = 0; ii < (int)picParam->num_slice_groups_minus1; ii++)
-                    {
-                        picParam->top_left[ii] = extP->top_left[ii];
-                        picParam->bottom_right[ii] = extP->bottom_right[ii];
-                    }
-                    break;
-                case 3:
-                case 4:
-                case 5:
-                    picParam->slice_group_change_direction_flag = extP->slice_group_change_direction_flag;
-                    if (/*extP->slice_group_change_rate_minus1 < 0 || (no need, it's unsigned) */
-                        extP->slice_group_change_rate_minus1 > video->PicSizeInMapUnits - 1)
-                    {
-                        return AVCENC_INVALID_CHANGE_RATE;
-                    }
-                    picParam->slice_group_change_rate_minus1 = extP->slice_group_change_rate_minus1;
-                    video->SliceGroupChangeRate = picParam->slice_group_change_rate_minus1 + 1;
-                    break;
-                case 6:
-                    if (extP->pic_size_in_map_units_minus1 != video->PicSizeInMapUnits - 1)
-                    {
-                        return AVCENC_NOT_SUPPORTED;
-                    }
-
-                    picParam->pic_size_in_map_units_minus1 = extP->pic_size_in_map_units_minus1;
-
-                    /* allocate picParam->slice_group_id */
-                    picParam->slice_group_id = (uint*)avcHandle->CBAVC_Malloc(userData, sizeof(uint) * video->PicSizeInMapUnits, DEFAULT_ATTR);
-                    if (picParam->slice_group_id == NULL)
-                    {
-                        return AVCENC_MEMORY_FAIL;
-                    }
-
-                    if (extP->slice_group_id == NULL)
-                    {
-                        return AVCENC_ENCPARAM_MEM_FAIL;
-                    }
-                    for (ii = 0; ii < (int)video->PicSizeInMapUnits; ii++)
-                    {
-                        picParam->slice_group_id[ii] = extP->slice_group_id[ii];
-                    }
-                    break;
-                default:
-                    return AVCENC_INVALID_FMO_TYPE;
-            }
-        }
-        picParam->num_ref_idx_l0_active_minus1 = extP->num_ref_idx_l0_active_minus1;
-        picParam->num_ref_idx_l1_active_minus1 = extP->num_ref_idx_l1_active_minus1; /* default value */
-        if (picParam->num_ref_idx_l1_active_minus1 != 0)
-        {
-            return AVCENC_NOT_SUPPORTED;
-        }
-
-        if (extP->weighted_pred_flag)
-        {
-            return AVCENC_NOT_SUPPORTED;
-        }
-
-        picParam->weighted_pred_flag = 0; /* no weighted prediction supported */
-        picParam->weighted_bipred_idc = extP->weighted_bipred_idc; /* range 0,1,2 */
-        if (/*picParam->weighted_bipred_idc < 0 || (no need, it's unsigned) */
-            picParam->weighted_bipred_idc > 2)
-        {
-            return AVCENC_WEIGHTED_BIPRED_FAIL;
-        }
-        picParam->pic_init_qp_minus26 = extP->pic_init_qp_minus26; /* default, will be changed at slice level anyway */
-        if (picParam->pic_init_qp_minus26 < -26 || picParam->pic_init_qp_minus26 > 25)
-        {
-            return AVCENC_INIT_QP_FAIL; /* out of range */
-        }
-        picParam->pic_init_qs_minus26 = extP->pic_init_qs_minus26;
-        if (picParam->pic_init_qs_minus26 < -26 || picParam->pic_init_qs_minus26 > 25)
-        {
-            return AVCENC_INIT_QS_FAIL; /* out of range */
-        }
-
-        picParam->chroma_qp_index_offset = extP->chroma_qp_index_offset; /* default to zero for now */
-        if (picParam->chroma_qp_index_offset < -12 || picParam->chroma_qp_index_offset > 12)
-        {
-            return AVCENC_CHROMA_QP_FAIL; /* out of range */
-        }
-        /* deblocking */
-        picParam->deblocking_filter_control_present_flag = extP->deblocking_filter_control_present_flag;
-        /* constrained intra prediction */
-        picParam->constrained_intra_pred_flag = extP->constrained_intra_pred_flag;
-        if (extP->redundant_pic_cnt_present_flag  != 0)
-        {
-            return AVCENC_NOT_SUPPORTED;
-        }
-        picParam->redundant_pic_cnt_present_flag = extP->redundant_pic_cnt_present_flag; /* default */
-    }
-    else
-    {
-        return AVCENC_NOT_SUPPORTED;
-    }
-
-    /****************** now set up some SliceHeader parameters ***********/
-    if (picParam->deblocking_filter_control_present_flag == TRUE)
-    {
-        /* these values only present when db_filter is ON */
-        if (encParam->disable_db_idc > 2)
-        {
-            return AVCENC_INVALID_DEBLOCK_IDC; /* out of range */
-        }
-        sliceHdr->disable_deblocking_filter_idc = encParam->disable_db_idc;
-
-        if (encParam->alpha_offset < -6 || encParam->alpha_offset > 6)
-        {
-            return AVCENC_INVALID_ALPHA_OFFSET;
-        }
-        sliceHdr->slice_alpha_c0_offset_div2 = encParam->alpha_offset;
-
-        if (encParam->beta_offset < -6 || encParam->beta_offset > 6)
-        {
-            return AVCENC_INVALID_BETA_OFFSET;
-        }
-        sliceHdr->slice_beta_offset_div_2 =  encParam->beta_offset;
-    }
-    if (encvid->outOfBandParamSet == TRUE)
-    {
-        sliceHdr->idr_pic_id = 0;
-    }
-    else
-    {
-        sliceHdr->idr_pic_id = (uint)(-1); /* start with zero */
-    }
-    sliceHdr->field_pic_flag = FALSE;
-    sliceHdr->bottom_field_flag = FALSE;  /* won't be used anyway */
-    video->MbaffFrameFlag = (seqParam->mb_adaptive_frame_field_flag && !sliceHdr->field_pic_flag);
-
-    /* the rest will be set in InitSlice() */
-
-    /* now the rate control and performance related parameters */
-    rateCtrl->scdEnable = (encParam->auto_scd == AVC_ON) ? TRUE : FALSE;
-    rateCtrl->idrPeriod = encParam->idr_period + 1;
-    rateCtrl->intraMBRate = encParam->intramb_refresh;
-    rateCtrl->dpEnable = (encParam->data_par == AVC_ON) ? TRUE : FALSE;
-
-    rateCtrl->subPelEnable = (encParam->sub_pel == AVC_ON) ? TRUE : FALSE;
-    rateCtrl->mvRange = encParam->search_range;
-
-    rateCtrl->subMBEnable = (encParam->submb_pred == AVC_ON) ? TRUE : FALSE;
-    rateCtrl->rdOptEnable = (encParam->rdopt_mode == AVC_ON) ? TRUE : FALSE;
-    rateCtrl->bidirPred = (encParam->bidir_pred == AVC_ON) ? TRUE : FALSE;
-
-    rateCtrl->rcEnable = (encParam->rate_control == AVC_ON) ? TRUE : FALSE;
-    rateCtrl->initQP = encParam->initQP;
-    rateCtrl->initQP = AVC_CLIP3(0, 51, rateCtrl->initQP);
-
-    rateCtrl->bitRate = encParam->bitrate;
-    rateCtrl->cpbSize = encParam->CPB_size;
-    rateCtrl->initDelayOffset = (rateCtrl->bitRate * encParam->init_CBP_removal_delay / 1000);
-
-    if (encParam->frame_rate == 0)
-    {
-        return AVCENC_INVALID_FRAMERATE;
-    }
-
-    rateCtrl->frame_rate = (OsclFloat)(encParam->frame_rate * 1.0 / 1000);
-//  rateCtrl->srcInterval = encParam->src_interval;
-    rateCtrl->first_frame = 1; /* set this flag for the first time */
-
-    /* contrained_setx_flag will be set inside the VerifyProfile called below.*/
-    if (!extS && !extP)
-    {
-        seqParam->profile_idc = encParam->profile;
-        seqParam->constrained_set0_flag = FALSE;
-        seqParam->constrained_set1_flag = FALSE;
-        seqParam->constrained_set2_flag = FALSE;
-        seqParam->constrained_set3_flag = FALSE;
-        seqParam->level_idc = encParam->level;
-    }
-    else
-    {
-        seqParam->profile_idc = extS->profile_idc;
-        seqParam->constrained_set0_flag = extS->constrained_set0_flag;
-        seqParam->constrained_set1_flag = extS->constrained_set1_flag;
-        seqParam->constrained_set2_flag = extS->constrained_set2_flag;
-        seqParam->constrained_set3_flag = extS->constrained_set3_flag;
-        seqParam->level_idc = extS->level_idc;
-    }
-
-
-    status = VerifyProfile(encvid, seqParam, picParam);
-    if (status != AVCENC_SUCCESS)
-    {
-        return status;
-    }
-
-    status = VerifyLevel(encvid, seqParam, picParam);
-    if (status != AVCENC_SUCCESS)
-    {
-        return status;
-    }
-
-    return AVCENC_SUCCESS;
-}
-
-/* verify the profile setting */
-AVCEnc_Status VerifyProfile(AVCEncObject *encvid, AVCSeqParamSet *seqParam, AVCPicParamSet *picParam)
-{
-    AVCRateControl *rateCtrl = encvid->rateCtrl;
-    AVCEnc_Status status = AVCENC_SUCCESS;
-
-    if (seqParam->profile_idc == 0) /* find profile for this setting */
-    {
-        /* find the right profile for it */
-        if (seqParam->direct_8x8_inference_flag == TRUE &&
-                picParam->entropy_coding_mode_flag == FALSE &&
-                picParam->num_slice_groups_minus1 <= 7 /*&&
-            picParam->num_slice_groups_minus1>=0 (no need, it's unsigned) */)
-        {
-            seqParam->profile_idc = AVC_EXTENDED;
-            seqParam->constrained_set2_flag = TRUE;
-        }
-
-        if (rateCtrl->dpEnable == FALSE &&
-                picParam->num_slice_groups_minus1 == 0 &&
-                picParam->redundant_pic_cnt_present_flag == FALSE)
-        {
-            seqParam->profile_idc = AVC_MAIN;
-            seqParam->constrained_set1_flag = TRUE;
-        }
-
-        if (rateCtrl->bidirPred == FALSE &&
-                rateCtrl->dpEnable == FALSE &&
-                seqParam->frame_mbs_only_flag == TRUE &&
-                picParam->weighted_pred_flag == FALSE &&
-                picParam->weighted_bipred_idc == 0 &&
-                picParam->entropy_coding_mode_flag == FALSE &&
-                picParam->num_slice_groups_minus1 <= 7 /*&&
-            picParam->num_slice_groups_minus1>=0 (no need, it's unsigned)*/)
-        {
-            seqParam->profile_idc = AVC_BASELINE;
-            seqParam->constrained_set0_flag = TRUE;
-        }
-
-        if (seqParam->profile_idc == 0) /* still zero */
-        {
-            return AVCENC_PROFILE_NOT_SUPPORTED;
-        }
-    }
-
-    /* check the list of supported profile by this library */
-    switch (seqParam->profile_idc)
-    {
-        case AVC_BASELINE:
-            if (rateCtrl->bidirPred == TRUE ||
-                    rateCtrl->dpEnable == TRUE ||
-                    seqParam->frame_mbs_only_flag != TRUE ||
-                    picParam->weighted_pred_flag == TRUE ||
-                    picParam->weighted_bipred_idc != 0 ||
-                    picParam->entropy_coding_mode_flag == TRUE ||
-                    picParam->num_slice_groups_minus1 > 7 /*||
-            picParam->num_slice_groups_minus1<0 (no need, it's unsigned) */)
-            {
-                status = AVCENC_TOOLS_NOT_SUPPORTED;
-            }
-            break;
-
-        case AVC_MAIN:
-        case AVC_EXTENDED:
-            status = AVCENC_PROFILE_NOT_SUPPORTED;
-    }
-
-    return status;
-}
-
-/* verify the level setting */
-AVCEnc_Status VerifyLevel(AVCEncObject *encvid, AVCSeqParamSet *seqParam, AVCPicParamSet *picParam)
-{
-    (void)(picParam);
-
-    AVCRateControl *rateCtrl = encvid->rateCtrl;
-    AVCCommonObj *video = encvid->common;
-    int mb_per_sec, ii;
-    int lev_idx;
-    int dpb_size;
-
-    mb_per_sec = (int)(video->PicSizeInMbs * rateCtrl->frame_rate + 0.5);
-    dpb_size = (seqParam->num_ref_frames * video->PicSizeInMbs * 3) >> 6;
-
-    if (seqParam->level_idc == 0) /* find level for this setting */
-    {
-        for (ii = 0; ii < MAX_LEVEL_IDX; ii++)
-        {
-            if (mb_per_sec <= MaxMBPS[ii] &&
-                    video->PicSizeInMbs <= (uint)MaxFS[ii] &&
-                    rateCtrl->bitRate <= (int32)MaxBR[ii]*1000 &&
-                    rateCtrl->cpbSize <= (int32)MaxCPB[ii]*1000 &&
-                    rateCtrl->mvRange <= MaxVmvR[ii] &&
-                    dpb_size <= MaxDPBX2[ii]*512)
-            {
-                seqParam->level_idc = mapIdx2Lev[ii];
-                break;
-            }
-        }
-        if (seqParam->level_idc == 0)
-        {
-            return AVCENC_LEVEL_NOT_SUPPORTED;
-        }
-    }
-
-    /* check if this level is supported by this library */
-    lev_idx = mapLev2Idx[seqParam->level_idc];
-    if (seqParam->level_idc == AVC_LEVEL1_B)
-    {
-        seqParam->constrained_set3_flag = 1;
-    }
-
-
-    if (lev_idx == 255) /* not defined */
-    {
-        return AVCENC_LEVEL_NOT_SUPPORTED;
-    }
-
-    /* check if the encoding setting complies with the level */
-    if (mb_per_sec > MaxMBPS[lev_idx] ||
-            video->PicSizeInMbs > (uint)MaxFS[lev_idx] ||
-            rateCtrl->bitRate > (int32)MaxBR[lev_idx]*1000 ||
-            rateCtrl->cpbSize > (int32)MaxCPB[lev_idx]*1000 ||
-            rateCtrl->mvRange > MaxVmvR[lev_idx])
-    {
-        return AVCENC_LEVEL_FAIL;
-    }
-
-    return AVCENC_SUCCESS;
-}
-
-/* initialize variables at the beginning of each frame */
-/* determine the picture type */
-/* encode POC */
-/* maybe we should do more stuff here. MotionEstimation+SCD and generate a new SPS and PPS */
-AVCEnc_Status InitFrame(AVCEncObject *encvid)
-{
-    AVCStatus ret;
-    AVCEnc_Status status;
-    AVCCommonObj *video = encvid->common;
-    AVCSliceHeader *sliceHdr = video->sliceHdr;
-
-    /* look for the next frame in coding_order and look for available picture
-       in the DPB. Note, video->currFS->PicOrderCnt, currFS->FrameNum and currPic->PicNum
-       are set to wrong number in this function (right for decoder). */
-    if (video->nal_unit_type == AVC_NALTYPE_IDR)
-    {
-        // call init DPB in here.
-        ret = AVCConfigureSequence(encvid->avcHandle, video, TRUE);
-        if (ret != AVC_SUCCESS)
-        {
-            return AVCENC_FAIL;
-        }
-    }
-
-    /* flexible macroblock ordering (every frame)*/
-    /* populate video->mapUnitToSliceGroupMap and video->MbToSliceGroupMap */
-    /* It changes once per each PPS. */
-    FMOInit(video);
-
-    ret = DPBInitBuffer(encvid->avcHandle, video); // get new buffer
-
-    if (ret != AVC_SUCCESS)
-    {
-        return (AVCEnc_Status)ret; // AVCENC_PICTURE_READY, FAIL
-    }
-
-    DPBInitPic(video, 0); /* 0 is dummy */
-
-    /************* determine picture type IDR or non-IDR ***********/
-    video->currPicType = AVC_FRAME;
-    video->slice_data_partitioning = FALSE;
-    encvid->currInput->is_reference = 1; /* default to all frames */
-    video->nal_ref_idc = 1;  /* need to set this for InitPOC */
-    video->currPic->isReference = TRUE;
-
-    /************* set frame_num ********************/
-    if (video->nal_unit_type == AVC_NALTYPE_IDR)
-    {
-        video->prevFrameNum = video->MaxFrameNum;
-        video->PrevRefFrameNum = 0;
-        sliceHdr->frame_num = 0;
-    }
-    /* otherwise, it's set to previous reference frame access unit's frame_num in decoding order,
-       see the end of PVAVCDecodeSlice()*/
-    /* There's also restriction on the frame_num, see page 59 of JVT-I1010.doc. */
-    /* Basically, frame_num can't be repeated unless it's opposite fields or non reference fields */
-    else
-    {
-        sliceHdr->frame_num = (video->PrevRefFrameNum + 1) % video->MaxFrameNum;
-    }
-    video->CurrPicNum = sliceHdr->frame_num;  /* for field_pic_flag = 0 */
-    //video->CurrPicNum = 2*sliceHdr->frame_num + 1; /* for field_pic_flag = 1 */
-
-    /* assign pic_order_cnt, video->PicOrderCnt */
-    status = InitPOC(encvid);
-    if (status != AVCENC_SUCCESS)  /* incorrigable fail */
-    {
-        return status;
-    }
-
-    /* Initialize refListIdx for this picture */
-    RefListInit(video);
-
-    /************* motion estimation and scene analysis ************/
-    // , to move this to MB-based MV search for comparison
-    // use sub-optimal QP for mv search
-    AVCMotionEstimation(encvid);  /* AVCENC_SUCCESS or AVCENC_NEW_IDR */
-
-    /* after this point, the picture type will be fixed to either IDR or non-IDR */
-    video->currFS->PicOrderCnt = video->PicOrderCnt;
-    video->currFS->FrameNum = video->sliceHdr->frame_num;
-    video->currPic->PicNum = video->CurrPicNum;
-    video->mbNum = 0; /* start from zero MB */
-    encvid->currSliceGroup = 0; /* start from slice group #0 */
-    encvid->numIntraMB = 0; /* reset this counter */
-
-    if (video->nal_unit_type == AVC_NALTYPE_IDR)
-    {
-        RCInitGOP(encvid);
-
-        /* calculate picture QP */
-        RCInitFrameQP(encvid);
-
-        return AVCENC_NEW_IDR;
-    }
-
-    /* calculate picture QP */
-    RCInitFrameQP(encvid); /* get QP after MV search */
-
-    return AVCENC_SUCCESS;
-}
-
-/* initialize variables for this slice */
-AVCEnc_Status InitSlice(AVCEncObject *encvid)
-{
-    AVCCommonObj *video = encvid->common;
-    AVCSliceHeader *sliceHdr = video->sliceHdr;
-    AVCPicParamSet *currPPS = video->currPicParams;
-    AVCSeqParamSet *currSPS = video->currSeqParams;
-    int slice_type = video->slice_type;
-
-    sliceHdr->first_mb_in_slice = video->mbNum;
-    if (video->mbNum) // not first slice of a frame
-    {
-        video->sliceHdr->slice_type = (AVCSliceType)slice_type;
-    }
-
-    /* sliceHdr->slice_type already set in InitFrame */
-
-    sliceHdr->pic_parameter_set_id = video->currPicParams->pic_parameter_set_id;
-
-    /* sliceHdr->frame_num already set in InitFrame */
-
-    if (!currSPS->frame_mbs_only_flag)  /* we shouldn't need this check */
-    {
-        sliceHdr->field_pic_flag = sliceHdr->bottom_field_flag = FALSE;
-        return AVCENC_TOOLS_NOT_SUPPORTED;
-    }
-
-    /* sliceHdr->idr_pic_id already set in PVAVCEncodeNAL
-
-     sliceHdr->pic_order_cnt_lsb already set in InitFrame..InitPOC
-     sliceHdr->delta_pic_order_cnt_bottom  already set in InitPOC
-
-    sliceHdr->delta_pic_order_cnt[0] already set in InitPOC
-    sliceHdr->delta_pic_order_cnt[1] already set in InitPOC
-    */
-
-    sliceHdr->redundant_pic_cnt = 0; /* default if(currPPS->redundant_pic_cnt_present_flag), range 0..127 */
-    sliceHdr->direct_spatial_mv_pred_flag = 0; // default if(slice_type == AVC_B_SLICE)
-
-    sliceHdr->num_ref_idx_active_override_flag = FALSE; /* default, if(slice_type== P,SP or B)*/
-    sliceHdr->num_ref_idx_l0_active_minus1 = 0; /* default, if (num_ref_idx_active_override_flag) */
-    sliceHdr->num_ref_idx_l1_active_minus1 = 0; /* default, if above and B_slice */
-    /* the above 2 values range from 0..15 for frame picture and 0..31 for field picture */
-
-    /* ref_pic_list_reordering(), currently we don't do anything */
-    sliceHdr->ref_pic_list_reordering_flag_l0 = FALSE; /* default */
-    sliceHdr->ref_pic_list_reordering_flag_l1 = FALSE; /* default */
-    /* if the above are TRUE, some other params must be set */
-
-    if ((currPPS->weighted_pred_flag && (slice_type == AVC_P_SLICE || slice_type == AVC_SP_SLICE)) ||
-            (currPPS->weighted_bipred_idc == 1 && slice_type == AVC_B_SLICE))
-    {
-        //      pred_weight_table(); // not supported !!
-        return AVCENC_TOOLS_NOT_SUPPORTED;
-    }
-
-    /* dec_ref_pic_marking(), this will be done later*/
-    sliceHdr->no_output_of_prior_pics_flag = FALSE; /* default */
-    sliceHdr->long_term_reference_flag = FALSE; /* for IDR frame, do not make it long term */
-    sliceHdr->adaptive_ref_pic_marking_mode_flag = FALSE; /* default */
-    /* other params are not set here because they are not used */
-
-    sliceHdr->cabac_init_idc = 0; /* default, if entropy_coding_mode_flag && slice_type==I or SI, range 0..2  */
-    sliceHdr->slice_qp_delta = 0; /* default for now */
-    sliceHdr->sp_for_switch_flag = FALSE; /* default, if slice_type == SP */
-    sliceHdr->slice_qs_delta = 0; /* default, if slice_type == SP or SI */
-
-    /* derived variables from encParam */
-    /* deblocking filter */
-    video->FilterOffsetA = video->FilterOffsetB = 0;
-    if (currPPS->deblocking_filter_control_present_flag == TRUE)
-    {
-        video->FilterOffsetA = sliceHdr->slice_alpha_c0_offset_div2 << 1;
-        video->FilterOffsetB = sliceHdr->slice_beta_offset_div_2 << 1;
-    }
-
-    /* flexible macroblock ordering */
-    /* populate video->mapUnitToSliceGroupMap and video->MbToSliceGroupMap */
-    /* We already call it at the end of PVAVCEncInitialize(). It changes once per each PPS. */
-    if (video->currPicParams->num_slice_groups_minus1 > 0 && video->currPicParams->slice_group_map_type >= 3
-            && video->currPicParams->slice_group_map_type <= 5)
-    {
-        sliceHdr->slice_group_change_cycle = SLICE_GROUP_CHANGE_CYCLE;  /* default, don't understand how to set it!!!*/
-
-        video->MapUnitsInSliceGroup0 =
-            AVC_MIN(sliceHdr->slice_group_change_cycle * video->SliceGroupChangeRate, video->PicSizeInMapUnits);
-
-        FMOInit(video);
-    }
-
-    /* calculate SliceQPy first  */
-    /* calculate QSy first */
-
-    sliceHdr->slice_qp_delta = video->QPy - 26 - currPPS->pic_init_qp_minus26;
-    //sliceHdr->slice_qs_delta = video->QSy - 26 - currPPS->pic_init_qs_minus26;
-
-    return AVCENC_SUCCESS;
-}
-
diff --git a/media/libstagefright/codecs/avc/enc/src/intra_est.cpp b/media/libstagefright/codecs/avc/enc/src/intra_est.cpp
deleted file mode 100644
index e397805..0000000
--- a/media/libstagefright/codecs/avc/enc/src/intra_est.cpp
+++ /dev/null
@@ -1,2199 +0,0 @@
-/* ------------------------------------------------------------------
- * 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 "avcenc_lib.h"
-
-#define TH_I4  0  /* threshold biasing toward I16 mode instead of I4 mode */
-#define TH_Intra  0 /* threshold biasing toward INTER mode instead of intra mode */
-
-#define FIXED_INTRAPRED_MODE  AVC_I16
-#define FIXED_I16_MODE  AVC_I16_DC
-#define FIXED_I4_MODE   AVC_I4_Diagonal_Down_Left
-#define FIXED_INTRA_CHROMA_MODE AVC_IC_DC
-
-#define CLIP_RESULT(x)      if((uint)(x) > 0xFF){ \
-                 (x) = 0xFF & (~((x)>>31));}
-
-
-bool IntraDecisionABE(AVCEncObject *encvid, int min_cost, uint8 *curL, int picPitch)
-{
-    AVCCommonObj *video = encvid->common;
-    AVCFrameIO *currInput = encvid->currInput;
-    int orgPitch = currInput->pitch;
-    int x_pos = (video->mb_x) << 4;
-    int y_pos = (video->mb_y) << 4;
-    uint8 *orgY = currInput->YCbCr[0] + y_pos * orgPitch + x_pos;
-    int j;
-    uint8 *topL, *leftL, *orgY_2, *orgY_3;
-    int temp, SBE, offset;
-    OsclFloat ABE;
-    bool intra = true;
-
-    if (((x_pos >> 4) != (int)video->PicWidthInMbs - 1) &&
-            ((y_pos >> 4) != (int)video->PicHeightInMbs - 1) &&
-            video->intraAvailA &&
-            video->intraAvailB)
-    {
-        SBE = 0;
-        /* top neighbor */
-        topL = curL - picPitch;
-        /* left neighbor */
-        leftL = curL - 1;
-        orgY_2 = orgY - orgPitch;
-
-        for (j = 0; j < 16; j++)
-        {
-            temp = *topL++ - orgY[j];
-            SBE += ((temp >= 0) ? temp : -temp);
-            temp = *(leftL += picPitch) - *(orgY_2 += orgPitch);
-            SBE += ((temp >= 0) ? temp : -temp);
-        }
-
-        /* calculate chroma */
-        offset = (y_pos >> 2) * picPitch + (x_pos >> 1);
-        topL = video->currPic->Scb + offset;
-        orgY_2 = currInput->YCbCr[1] + offset + (y_pos >> 2) * (orgPitch - picPitch);
-
-        leftL = topL - 1;
-        topL -= (picPitch >> 1);
-        orgY_3 = orgY_2 - (orgPitch >> 1);
-        for (j = 0; j < 8; j++)
-        {
-            temp = *topL++ - orgY_2[j];
-            SBE += ((temp >= 0) ? temp : -temp);
-            temp = *(leftL += (picPitch >> 1)) - *(orgY_3 += (orgPitch >> 1));
-            SBE += ((temp >= 0) ? temp : -temp);
-        }
-
-        topL = video->currPic->Scr + offset;
-        orgY_2 = currInput->YCbCr[2] + offset + (y_pos >> 2) * (orgPitch - picPitch);
-
-        leftL = topL - 1;
-        topL -= (picPitch >> 1);
-        orgY_3 = orgY_2 - (orgPitch >> 1);
-        for (j = 0; j < 8; j++)
-        {
-            temp = *topL++ - orgY_2[j];
-            SBE += ((temp >= 0) ? temp : -temp);
-            temp = *(leftL += (picPitch >> 1)) - *(orgY_3 += (orgPitch >> 1));
-            SBE += ((temp >= 0) ? temp : -temp);
-        }
-
-        /* compare mincost/384 and SBE/64 */
-        ABE = SBE / 64.0;
-        if (ABE*0.8 >= min_cost / 384.0)
-        {
-            intra = false;
-        }
-    }
-
-    return intra;
-}
-
-/* perform searching for MB mode */
-/* assuming that this is done inside the encoding loop,
-no need to call InitNeighborAvailability */
-
-void MBIntraSearch(AVCEncObject *encvid, int mbnum, uint8 *curL, int picPitch)
-{
-    AVCCommonObj *video = encvid->common;
-    AVCFrameIO *currInput = encvid->currInput;
-    AVCMacroblock *currMB = video->currMB;
-    int min_cost;
-    uint8 *orgY;
-    int x_pos = (video->mb_x) << 4;
-    int y_pos = (video->mb_y) << 4;
-    uint32 *saved_inter;
-    int j;
-    int orgPitch = currInput->pitch;
-    bool intra = true;
-
-    currMB->CBP = 0;
-
-    /* first do motion vector and variable block size search */
-    min_cost = encvid->min_cost[mbnum];
-
-    /* now perform intra prediction search */
-    /* need to add the check for encvid->intraSearch[video->mbNum] to skip intra
-       if it's not worth checking. */
-    if (video->slice_type == AVC_P_SLICE)
-    {
-        /* Decide whether intra search is necessary or not */
-        /* This one, we do it in the encoding loop so the neighboring pixel are the
-        actual reconstructed pixels. */
-        intra = IntraDecisionABE(encvid, min_cost, curL, picPitch);
-    }
-
-    if (intra == true || video->slice_type == AVC_I_SLICE)
-    {
-        orgY = currInput->YCbCr[0] + y_pos * orgPitch + x_pos;
-
-        /* i16 mode search */
-        /* generate all the predictions */
-        intrapred_luma_16x16(encvid);
-
-        /* evaluate them one by one */
-        find_cost_16x16(encvid, orgY, &min_cost);
-
-        if (video->slice_type == AVC_P_SLICE)
-        {
-            /* save current inter prediction */
-            saved_inter = encvid->subpel_pred; /* reuse existing buffer */
-            j = 16;
-            curL -= 4;
-            picPitch -= 16;
-            while (j--)
-            {
-                *saved_inter++ = *((uint32*)(curL += 4));
-                *saved_inter++ = *((uint32*)(curL += 4));
-                *saved_inter++ = *((uint32*)(curL += 4));
-                *saved_inter++ = *((uint32*)(curL += 4));
-                curL += picPitch;
-            }
-
-        }
-
-        /* i4 mode search */
-        mb_intra4x4_search(encvid, &min_cost);
-
-        encvid->min_cost[mbnum] = min_cost; /* update min_cost */
-    }
-
-
-    if (currMB->mb_intra)
-    {
-        chroma_intra_search(encvid);
-
-        /* need to set this in order for the MBInterPrediction to work!! */
-        memset(currMB->mvL0, 0, sizeof(int32)*16);
-        currMB->ref_idx_L0[0] = currMB->ref_idx_L0[1] =
-                                    currMB->ref_idx_L0[2] = currMB->ref_idx_L0[3] = -1;
-    }
-    else if (video->slice_type == AVC_P_SLICE && intra == true)
-    {
-        /* restore current inter prediction */
-        saved_inter = encvid->subpel_pred; /* reuse existing buffer */
-        j = 16;
-        curL -= ((picPitch + 16) << 4);
-        while (j--)
-        {
-            *((uint32*)(curL += 4)) = *saved_inter++;
-            *((uint32*)(curL += 4)) = *saved_inter++;
-            *((uint32*)(curL += 4)) = *saved_inter++;
-            *((uint32*)(curL += 4)) = *saved_inter++;
-            curL += picPitch;
-        }
-    }
-
-    return ;
-}
-
-/* generate all the prediction values */
-void intrapred_luma_16x16(AVCEncObject *encvid)
-{
-    AVCCommonObj *video = encvid->common;
-    AVCPictureData *currPic = video->currPic;
-
-    int x_pos = (video->mb_x) << 4;
-    int y_pos = (video->mb_y) << 4;
-    int pitch = currPic->pitch;
-
-    int offset = y_pos * pitch + x_pos;
-
-    uint8 *pred, *top, *left;
-    uint8 *curL = currPic->Sl + offset; /* point to reconstructed frame */
-    uint32 word1, word2, word3, word4;
-    uint32 sum = 0;
-
-    int a_16, b, c, factor_c;
-    uint8 *comp_ref_x0, *comp_ref_x1, *comp_ref_y0, *comp_ref_y1;
-    int H = 0, V = 0, tmp, value;
-    int i;
-
-    if (video->intraAvailB)
-    {
-        //get vertical prediction mode
-        top = curL - pitch;
-
-        pred = encvid->pred_i16[AVC_I16_Vertical] - 16;
-
-        word1 = *((uint32*)(top));  /* read 4 bytes from top */
-        word2 = *((uint32*)(top + 4)); /* read 4 bytes from top */
-        word3 = *((uint32*)(top + 8)); /* read 4 bytes from top */
-        word4 = *((uint32*)(top + 12)); /* read 4 bytes from top */
-
-        for (i = 0; i < 16; i++)
-        {
-            *((uint32*)(pred += 16)) = word1;
-            *((uint32*)(pred + 4)) = word2;
-            *((uint32*)(pred + 8)) = word3;
-            *((uint32*)(pred + 12)) = word4;
-
-        }
-
-        sum = word1 & 0xFF00FF;
-        word1 = (word1 >> 8) & 0xFF00FF;
-        sum += word1;
-        word1 = (word2 & 0xFF00FF);
-        sum += word1;
-        word2 = (word2 >> 8) & 0xFF00FF;
-        sum += word2;
-        word1 = (word3 & 0xFF00FF);
-        sum += word1;
-        word3 = (word3 >> 8) & 0xFF00FF;
-        sum += word3;
-        word1 = (word4 & 0xFF00FF);
-        sum += word1;
-        word4 = (word4 >> 8) & 0xFF00FF;
-        sum += word4;
-
-        sum += (sum >> 16);
-        sum &= 0xFFFF;
-
-        if (!video->intraAvailA)
-        {
-            sum = (sum + 8) >> 4;
-        }
-    }
-
-    if (video->intraAvailA)
-    {
-        // get horizontal mode
-        left = curL - 1 - pitch;
-
-        pred = encvid->pred_i16[AVC_I16_Horizontal] - 16;
-
-        for (i = 0; i < 16; i++)
-        {
-            word1 = *(left += pitch);
-            sum += word1;
-
-            word1 = (word1 << 8) | word1;
-            word1 = (word1 << 16) | word1; /* make it 4 */
-
-            *(uint32*)(pred += 16) = word1;
-            *(uint32*)(pred + 4) = word1;
-            *(uint32*)(pred + 8) = word1;
-            *(uint32*)(pred + 12) = word1;
-        }
-
-        if (!video->intraAvailB)
-        {
-            sum = (sum + 8) >> 4;
-        }
-        else
-        {
-            sum = (sum + 16) >> 5;
-        }
-    }
-
-    // get DC mode
-    if (!video->intraAvailA && !video->intraAvailB)
-    {
-        sum = 0x80808080;
-    }
-    else
-    {
-        sum = (sum << 8) | sum;
-        sum = (sum << 16) | sum;
-    }
-
-    pred = encvid->pred_i16[AVC_I16_DC] - 16;
-    for (i = 0; i < 16; i++)
-    {
-        *((uint32*)(pred += 16)) = sum;
-        *((uint32*)(pred + 4)) = sum;
-        *((uint32*)(pred + 8)) = sum;
-        *((uint32*)(pred + 12)) = sum;
-    }
-
-    // get plane mode
-    if (video->intraAvailA && video->intraAvailB && video->intraAvailD)
-    {
-        pred = encvid->pred_i16[AVC_I16_Plane] - 16;
-
-        comp_ref_x0 = curL - pitch + 8;
-        comp_ref_x1 = curL - pitch + 6;
-        comp_ref_y0 = curL - 1 + (pitch << 3);
-        comp_ref_y1 = curL - 1 + 6 * pitch;
-
-        for (i = 1; i < 8; i++)
-        {
-            H += i * (*comp_ref_x0++ - *comp_ref_x1--);
-            V += i * (*comp_ref_y0 - *comp_ref_y1);
-            comp_ref_y0 += pitch;
-            comp_ref_y1 -= pitch;
-        }
-
-        H += i * (*comp_ref_x0++ - curL[-pitch-1]);
-        V += i * (*comp_ref_y0 - *comp_ref_y1);
-
-
-        a_16 = ((*(curL - pitch + 15) + *(curL - 1 + 15 * pitch)) << 4) + 16;;
-        b = (5 * H + 32) >> 6;
-        c = (5 * V + 32) >> 6;
-
-        tmp = 0;
-        for (i = 0; i < 16; i++)
-        {
-            factor_c = a_16 + c * (tmp++ - 7);
-            factor_c -= 7 * b;
-
-            value = factor_c >> 5;
-            factor_c += b;
-            CLIP_RESULT(value)
-            word1 = value;
-            value = factor_c >> 5;
-            factor_c += b;
-            CLIP_RESULT(value)
-            word1 = (word1) | (value << 8);
-            value = factor_c >> 5;
-            factor_c += b;
-            CLIP_RESULT(value)
-            word1 = (word1) | (value << 16);
-            value = factor_c >> 5;
-            factor_c += b;
-            CLIP_RESULT(value)
-            word1 = (word1) | (value << 24);
-            *((uint32*)(pred += 16)) = word1;
-            value = factor_c >> 5;
-            factor_c += b;
-            CLIP_RESULT(value)
-            word1 = value;
-            value = factor_c >> 5;
-            factor_c += b;
-            CLIP_RESULT(value)
-            word1 = (word1) | (value << 8);
-            value = factor_c >> 5;
-            factor_c += b;
-            CLIP_RESULT(value)
-            word1 = (word1) | (value << 16);
-            value = factor_c >> 5;
-            factor_c += b;
-            CLIP_RESULT(value)
-            word1 = (word1) | (value << 24);
-            *((uint32*)(pred + 4)) = word1;
-            value = factor_c >> 5;
-            factor_c += b;
-            CLIP_RESULT(value)
-            word1 = value;
-            value = factor_c >> 5;
-            factor_c += b;
-            CLIP_RESULT(value)
-            word1 = (word1) | (value << 8);
-            value = factor_c >> 5;
-            factor_c += b;
-            CLIP_RESULT(value)
-            word1 = (word1) | (value << 16);
-            value = factor_c >> 5;
-            factor_c += b;
-            CLIP_RESULT(value)
-            word1 = (word1) | (value << 24);
-            *((uint32*)(pred + 8)) = word1;
-            value = factor_c >> 5;
-            factor_c += b;
-            CLIP_RESULT(value)
-            word1 = value;
-            value = factor_c >> 5;
-            factor_c += b;
-            CLIP_RESULT(value)
-            word1 = (word1) | (value << 8);
-            value = factor_c >> 5;
-            factor_c += b;
-            CLIP_RESULT(value)
-            word1 = (word1) | (value << 16);
-            value = factor_c >> 5;
-            CLIP_RESULT(value)
-            word1 = (word1) | (value << 24);
-            *((uint32*)(pred + 12)) = word1;
-        }
-    }
-
-    return ;
-}
-
-
-/* evaluate each prediction mode of I16 */
-void find_cost_16x16(AVCEncObject *encvid, uint8 *orgY, int *min_cost)
-{
-    AVCCommonObj *video = encvid->common;
-    AVCMacroblock *currMB = video->currMB;
-    int cost;
-    int org_pitch = encvid->currInput->pitch;
-
-    /* evaluate vertical mode */
-    if (video->intraAvailB)
-    {
-        cost = cost_i16(orgY, org_pitch, encvid->pred_i16[AVC_I16_Vertical], *min_cost);
-        if (cost < *min_cost)
-        {
-            *min_cost = cost;
-            currMB->mbMode = AVC_I16;
-            currMB->mb_intra = 1;
-            currMB->i16Mode = AVC_I16_Vertical;
-        }
-    }
-
-
-    /* evaluate horizontal mode */
-    if (video->intraAvailA)
-    {
-        cost = cost_i16(orgY, org_pitch, encvid->pred_i16[AVC_I16_Horizontal], *min_cost);
-        if (cost < *min_cost)
-        {
-            *min_cost = cost;
-            currMB->mbMode = AVC_I16;
-            currMB->mb_intra = 1;
-            currMB->i16Mode = AVC_I16_Horizontal;
-        }
-    }
-
-    /* evaluate DC mode */
-    cost = cost_i16(orgY, org_pitch, encvid->pred_i16[AVC_I16_DC], *min_cost);
-    if (cost < *min_cost)
-    {
-        *min_cost = cost;
-        currMB->mbMode = AVC_I16;
-        currMB->mb_intra = 1;
-        currMB->i16Mode = AVC_I16_DC;
-    }
-
-    /* evaluate plane mode */
-    if (video->intraAvailA && video->intraAvailB && video->intraAvailD)
-    {
-        cost = cost_i16(orgY, org_pitch, encvid->pred_i16[AVC_I16_Plane], *min_cost);
-        if (cost < *min_cost)
-        {
-            *min_cost = cost;
-            currMB->mbMode = AVC_I16;
-            currMB->mb_intra = 1;
-            currMB->i16Mode = AVC_I16_Plane;
-        }
-    }
-
-    return ;
-}
-
-
-int cost_i16(uint8 *org, int org_pitch, uint8 *pred, int min_cost)
-{
-
-    int cost;
-    int j, k;
-    int16 res[256], *pres; // residue
-    int m0, m1, m2, m3;
-
-    // calculate SATD
-    org_pitch -= 16;
-    pres = res;
-    // horizontal transform
-    for (j = 0; j < 16; j++)
-    {
-        k = 4;
-        while (k > 0)
-        {
-            m0 = org[0] - pred[0];
-            m3 = org[3] - pred[3];
-            m0 += m3;
-            m3 = m0 - (m3 << 1);
-            m1 = org[1] - pred[1];
-            m2 = org[2] - pred[2];
-            m1 += m2;
-            m2 = m1 - (m2 << 1);
-            pres[0] = m0 + m1;
-            pres[2] = m0 - m1;
-            pres[1] = m2 + m3;
-            pres[3] = m3 - m2;
-
-            org += 4;
-            pres += 4;
-            pred += 4;
-            k--;
-        }
-        org += org_pitch;
-    }
-    /* vertical transform */
-    cost = 0;
-    for (j = 0; j < 4; j++)
-    {
-        pres = res + (j << 6);
-        k = 16;
-        while (k > 0)
-        {
-            m0 = pres[0];
-            m3 = pres[3<<4];
-            m0 += m3;
-            m3 = m0 - (m3 << 1);
-            m1 = pres[1<<4];
-            m2 = pres[2<<4];
-            m1 += m2;
-            m2 = m1 - (m2 << 1);
-            pres[0] = m0 = m0 + m1;
-
-            if (k&0x3)  // only sum up non DC values.
-            {
-                cost += ((m0 > 0) ? m0 : -m0);
-            }
-
-            m1 = m0 - (m1 << 1);
-            cost += ((m1 > 0) ? m1 : -m1);
-            m3 = m2 + m3;
-            cost += ((m3 > 0) ? m3 : -m3);
-            m2 = m3 - (m2 << 1);
-            cost += ((m2 > 0) ? m2 : -m2);
-
-            pres++;
-            k--;
-        }
-        if ((cost >> 1) > min_cost) /* early drop out */
-        {
-            return (cost >> 1);
-        }
-    }
-
-    /* Hadamard of the DC coefficient */
-    pres = res;
-    k = 4;
-    while (k > 0)
-    {
-        m0 = pres[0];
-        m3 = pres[3<<2];
-        m0 >>= 2;
-        m0 += (m3 >> 2);
-        m3 = m0 - (m3 >> 1);
-        m1 = pres[1<<2];
-        m2 = pres[2<<2];
-        m1 >>= 2;
-        m1 += (m2 >> 2);
-        m2 = m1 - (m2 >> 1);
-        pres[0] = (m0 + m1);
-        pres[2<<2] = (m0 - m1);
-        pres[1<<2] = (m2 + m3);
-        pres[3<<2] = (m3 - m2);
-        pres += (4 << 4);
-        k--;
-    }
-
-    pres = res;
-    k = 4;
-    while (k > 0)
-    {
-        m0 = pres[0];
-        m3 = pres[3<<6];
-        m0 += m3;
-        m3 = m0 - (m3 << 1);
-        m1 = pres[1<<6];
-        m2 = pres[2<<6];
-        m1 += m2;
-        m2 = m1 - (m2 << 1);
-        m0 = m0 + m1;
-        cost += ((m0 >= 0) ? m0 : -m0);
-        m1 = m0 - (m1 << 1);
-        cost += ((m1 >= 0) ? m1 : -m1);
-        m3 = m2 + m3;
-        cost += ((m3 >= 0) ? m3 : -m3);
-        m2 = m3 - (m2 << 1);
-        cost += ((m2 >= 0) ? m2 : -m2);
-        pres += 4;
-
-        if ((cost >> 1) > min_cost) /* early drop out */
-        {
-            return (cost >> 1);
-        }
-
-        k--;
-    }
-
-    return (cost >> 1);
-}
-
-
-void mb_intra4x4_search(AVCEncObject *encvid, int *min_cost)
-{
-    AVCCommonObj *video = encvid->common;
-    AVCMacroblock *currMB = video->currMB;
-    AVCPictureData *currPic = video->currPic;
-    AVCFrameIO *currInput = encvid->currInput;
-    int pitch = currPic->pitch;
-    int org_pitch = currInput->pitch;
-    int offset;
-    uint8 *curL, *comp, *org4, *org8;
-    int y = video->mb_y << 4;
-    int x = video->mb_x << 4;
-
-    int b8, b4, cost4x4, blkidx;
-    int cost = 0;
-    int numcoef;
-    int dummy = 0;
-    int mb_intra = currMB->mb_intra; // save the original value
-
-    offset = y * pitch + x;
-
-    curL = currPic->Sl + offset;
-    org8 = currInput->YCbCr[0] + y * org_pitch + x;
-    video->pred_pitch = 4;
-
-    cost = (int)(6.0 * encvid->lambda_mode + 0.4999);
-    cost <<= 2;
-
-    currMB->mb_intra = 1;  // temporary set this to one to enable the IDCT
-    // operation inside dct_luma
-
-    for (b8 = 0; b8 < 4; b8++)
-    {
-        comp = curL;
-        org4 = org8;
-
-        for (b4 = 0; b4 < 4; b4++)
-        {
-            blkidx = blkIdx2blkXY[b8][b4];
-            cost4x4 = blk_intra4x4_search(encvid, blkidx, comp, org4);
-            cost += cost4x4;
-            if (cost > *min_cost)
-            {
-                currMB->mb_intra = mb_intra; // restore the value
-                return ;
-            }
-
-            /* do residue, Xfrm, Q, invQ, invXfrm, recon and save the DCT coefs.*/
-            video->pred_block = encvid->pred_i4[currMB->i4Mode[blkidx]];
-            numcoef = dct_luma(encvid, blkidx, comp, org4, &dummy);
-            currMB->nz_coeff[blkidx] = numcoef;
-            if (numcoef)
-            {
-                video->cbp4x4 |= (1 << blkidx);
-                currMB->CBP |= (1 << b8);
-            }
-
-            if (b4&1)
-            {
-                comp += ((pitch << 2) - 4);
-                org4 += ((org_pitch << 2) - 4);
-            }
-            else
-            {
-                comp += 4;
-                org4 += 4;
-            }
-        }
-
-        if (b8&1)
-        {
-            curL += ((pitch << 3) - 8);
-            org8 += ((org_pitch << 3) - 8);
-        }
-        else
-        {
-            curL += 8;
-            org8 += 8;
-        }
-    }
-
-    currMB->mb_intra = mb_intra; // restore the value
-
-    if (cost < *min_cost)
-    {
-        *min_cost = cost;
-        currMB->mbMode = AVC_I4;
-        currMB->mb_intra = 1;
-    }
-
-    return ;
-}
-
-
-/* search for i4 mode for a 4x4 block */
-int blk_intra4x4_search(AVCEncObject *encvid, int blkidx, uint8 *cur, uint8 *org)
-{
-    AVCCommonObj *video = encvid->common;
-    AVCNeighborAvailability availability;
-    AVCMacroblock *currMB = video->currMB;
-    bool top_left = FALSE;
-    int pitch = video->currPic->pitch;
-    uint8 mode_avail[AVCNumI4PredMode];
-    uint32 temp, DC;
-    uint8 *pred;
-    int org_pitch = encvid->currInput->pitch;
-    uint16 min_cost, cost;
-
-    int P_x, Q_x, R_x, P_y, Q_y, R_y, D, D0, D1;
-    int P0, Q0, R0, S0, P1, Q1, R1, P2, Q2;
-    uint8 P_A, P_B, P_C, P_D, P_E, P_F, P_G, P_H, P_I, P_J, P_K, P_L, P_X;
-    int r0, r1, r2, r3, r4, r5, r6, r7;
-    int x0, x1, x2, x3, x4, x5;
-    uint32 temp1, temp2;
-
-    int ipmode, mostProbableMode;
-    int fixedcost = 4 * encvid->lambda_mode;
-    int min_sad = 0x7FFF;
-
-    availability.left = TRUE;
-    availability.top = TRUE;
-    if (blkidx <= 3) /* top row block  (!block_y) */
-    { /* check availability up */
-        availability.top = video->intraAvailB ;
-    }
-    if (!(blkidx&0x3)) /* left column block (!block_x)*/
-    { /* check availability left */
-        availability.left = video->intraAvailA ;
-    }
-    availability.top_right = BlkTopRight[blkidx];
-
-    if (availability.top_right == 2)
-    {
-        availability.top_right = video->intraAvailB;
-    }
-    else if (availability.top_right == 3)
-    {
-        availability.top_right = video->intraAvailC;
-    }
-
-    if (availability.top == TRUE)
-    {
-        temp = *(uint32*)(cur - pitch);
-        P_A = temp & 0xFF;
-        P_B = (temp >> 8) & 0xFF;
-        P_C = (temp >> 16) & 0xFF;
-        P_D = (temp >> 24) & 0xFF;
-    }
-    else
-    {
-        P_A = P_B = P_C = P_D = 128;
-    }
-
-    if (availability.top_right == TRUE)
-    {
-        temp = *(uint32*)(cur - pitch + 4);
-        P_E = temp & 0xFF;
-        P_F = (temp >> 8) & 0xFF;
-        P_G = (temp >> 16) & 0xFF;
-        P_H = (temp >> 24) & 0xFF;
-    }
-    else
-    {
-        P_E = P_F = P_G = P_H = 128;
-    }
-
-    if (availability.left == TRUE)
-    {
-        cur--;
-        P_I = *cur;
-        P_J = *(cur += pitch);
-        P_K = *(cur += pitch);
-        P_L = *(cur + pitch);
-        cur -= (pitch << 1);
-        cur++;
-    }
-    else
-    {
-        P_I = P_J = P_K = P_L = 128;
-    }
-
-    /* check if top-left pixel is available */
-    if (((blkidx > 3) && (blkidx&0x3)) || ((blkidx > 3) && video->intraAvailA)
-            || ((blkidx&0x3) && video->intraAvailB)
-            || (video->intraAvailA && video->intraAvailD && video->intraAvailB))
-    {
-        top_left = TRUE;
-        P_X = *(cur - pitch - 1);
-    }
-    else
-    {
-        P_X = 128;
-    }
-
-    //===== INTRA PREDICTION FOR 4x4 BLOCK =====
-    /* vertical */
-    mode_avail[AVC_I4_Vertical] = 0;
-    if (availability.top)
-    {
-        mode_avail[AVC_I4_Vertical] = 1;
-        pred = encvid->pred_i4[AVC_I4_Vertical];
-
-        temp = (P_D << 24) | (P_C << 16) | (P_B << 8) | P_A ;
-        *((uint32*)pred) =  temp; /* write 4 at a time */
-        *((uint32*)(pred += 4)) =  temp;
-        *((uint32*)(pred += 4)) =  temp;
-        *((uint32*)(pred += 4)) =  temp;
-    }
-    /* horizontal */
-    mode_avail[AVC_I4_Horizontal] = 0;
-    mode_avail[AVC_I4_Horizontal_Up] = 0;
-    if (availability.left)
-    {
-        mode_avail[AVC_I4_Horizontal] = 1;
-        pred = encvid->pred_i4[AVC_I4_Horizontal];
-
-        temp = P_I | (P_I << 8);
-        temp = temp | (temp << 16);
-        *((uint32*)pred) = temp;
-        temp = P_J | (P_J << 8);
-        temp = temp | (temp << 16);
-        *((uint32*)(pred += 4)) = temp;
-        temp = P_K | (P_K << 8);
-        temp = temp | (temp << 16);
-        *((uint32*)(pred += 4)) = temp;
-        temp = P_L | (P_L << 8);
-        temp = temp | (temp << 16);
-        *((uint32*)(pred += 4)) = temp;
-
-        mode_avail[AVC_I4_Horizontal_Up] = 1;
-        pred = encvid->pred_i4[AVC_I4_Horizontal_Up];
-
-        Q0 = (P_J + P_K + 1) >> 1;
-        Q1 = (P_J + (P_K << 1) + P_L + 2) >> 2;
-        P0 = ((P_I + P_J + 1) >> 1);
-        P1 = ((P_I + (P_J << 1) + P_K + 2) >> 2);
-
-        temp = P0 | (P1 << 8);      // [P0 P1 Q0 Q1]
-        temp |= (Q0 << 16);     // [Q0 Q1 R0 DO]
-        temp |= (Q1 << 24);     // [R0 D0 D1 D1]
-        *((uint32*)pred) = temp;      // [D1 D1 D1 D1]
-
-        D0 = (P_K + 3 * P_L + 2) >> 2;
-        R0 = (P_K + P_L + 1) >> 1;
-
-        temp = Q0 | (Q1 << 8);
-        temp |= (R0 << 16);
-        temp |= (D0 << 24);
-        *((uint32*)(pred += 4)) = temp;
-
-        D1 = P_L;
-
-        temp = R0 | (D0 << 8);
-        temp |= (D1 << 16);
-        temp |= (D1 << 24);
-        *((uint32*)(pred += 4)) = temp;
-
-        temp = D1 | (D1 << 8);
-        temp |= (temp << 16);
-        *((uint32*)(pred += 4)) = temp;
-    }
-    /* DC */
-    mode_avail[AVC_I4_DC] = 1;
-    pred = encvid->pred_i4[AVC_I4_DC];
-    if (availability.left)
-    {
-        DC = P_I + P_J + P_K + P_L;
-
-        if (availability.top)
-        {
-            DC = (P_A + P_B + P_C + P_D + DC + 4) >> 3;
-        }
-        else
-        {
-            DC = (DC + 2) >> 2;
-
-        }
-    }
-    else if (availability.top)
-    {
-        DC = (P_A + P_B + P_C + P_D + 2) >> 2;
-
-    }
-    else
-    {
-        DC = 128;
-    }
-
-    temp = DC | (DC << 8);
-    temp = temp | (temp << 16);
-    *((uint32*)pred) = temp;
-    *((uint32*)(pred += 4)) = temp;
-    *((uint32*)(pred += 4)) = temp;
-    *((uint32*)(pred += 4)) = temp;
-
-    /* Down-left */
-    mode_avail[AVC_I4_Diagonal_Down_Left] = 0;
-
-    if (availability.top)
-    {
-        mode_avail[AVC_I4_Diagonal_Down_Left] = 1;
-
-        pred = encvid->pred_i4[AVC_I4_Diagonal_Down_Left];
-
-        r0 = P_A;
-        r1 = P_B;
-        r2 = P_C;
-        r3 = P_D;
-
-        r0 += (r1 << 1);
-        r0 += r2;
-        r0 += 2;
-        r0 >>= 2;
-        r1 += (r2 << 1);
-        r1 += r3;
-        r1 += 2;
-        r1 >>= 2;
-
-        if (availability.top_right)
-        {
-            r4 = P_E;
-            r5 = P_F;
-            r6 = P_G;
-            r7 = P_H;
-
-            r2 += (r3 << 1);
-            r2 += r4;
-            r2 += 2;
-            r2 >>= 2;
-            r3 += (r4 << 1);
-            r3 += r5;
-            r3 += 2;
-            r3 >>= 2;
-            r4 += (r5 << 1);
-            r4 += r6;
-            r4 += 2;
-            r4 >>= 2;
-            r5 += (r6 << 1);
-            r5 += r7;
-            r5 += 2;
-            r5 >>= 2;
-            r6 += (3 * r7);
-            r6 += 2;
-            r6 >>= 2;
-            temp = r0 | (r1 << 8);
-            temp |= (r2 << 16);
-            temp |= (r3 << 24);
-            *((uint32*)pred) = temp;
-
-            temp = (temp >> 8) | (r4 << 24);
-            *((uint32*)(pred += 4)) = temp;
-
-            temp = (temp >> 8) | (r5 << 24);
-            *((uint32*)(pred += 4)) = temp;
-
-            temp = (temp >> 8) | (r6 << 24);
-            *((uint32*)(pred += 4)) = temp;
-        }
-        else
-        {
-            r2 += (r3 * 3);
-            r2 += 2;
-            r2 >>= 2;
-            r3 = ((r3 << 2) + 2);
-            r3 >>= 2;
-
-            temp = r0 | (r1 << 8);
-            temp |= (r2 << 16);
-            temp |= (r3 << 24);
-            *((uint32*)pred) = temp;
-
-            temp = (temp >> 8) | (r3 << 24);
-            *((uint32*)(pred += 4)) = temp;
-
-            temp = (temp >> 8) | (r3 << 24);
-            *((uint32*)(pred += 4)) = temp;
-
-            temp = (temp >> 8) | (r3 << 24);
-            *((uint32*)(pred += 4)) = temp;
-
-        }
-    }
-
-    /* Down Right */
-    mode_avail[AVC_I4_Diagonal_Down_Right] = 0;
-    /* Diagonal Vertical Right */
-    mode_avail[AVC_I4_Vertical_Right] = 0;
-    /* Horizontal Down */
-    mode_avail[AVC_I4_Horizontal_Down] = 0;
-
-    if (top_left == TRUE)
-    {
-        /* Down Right */
-        mode_avail[AVC_I4_Diagonal_Down_Right] = 1;
-        pred = encvid->pred_i4[AVC_I4_Diagonal_Down_Right];
-
-        Q_x = (P_A + 2 * P_B + P_C + 2) >> 2;
-        R_x = (P_B + 2 * P_C + P_D + 2) >> 2;
-        P_x = (P_X + 2 * P_A + P_B + 2) >> 2;
-        D   = (P_A + 2 * P_X + P_I + 2) >> 2;
-        P_y = (P_X + 2 * P_I + P_J + 2) >> 2;
-        Q_y = (P_I + 2 * P_J + P_K + 2) >> 2;
-        R_y = (P_J + 2 * P_K + P_L + 2) >> 2;
-
-        /* we can pack these */
-        temp =  D | (P_x << 8);   //[D   P_x Q_x R_x]
-        //[P_y D   P_x Q_x]
-        temp |= (Q_x << 16); //[Q_y P_y D   P_x]
-        temp |= (R_x << 24);  //[R_y Q_y P_y D  ]
-        *((uint32*)pred) = temp;
-
-        temp =  P_y | (D << 8);
-        temp |= (P_x << 16);
-        temp |= (Q_x << 24);
-        *((uint32*)(pred += 4)) = temp;
-
-        temp =  Q_y | (P_y << 8);
-        temp |= (D << 16);
-        temp |= (P_x << 24);
-        *((uint32*)(pred += 4)) = temp;
-
-        temp = R_y | (Q_y << 8);
-        temp |= (P_y << 16);
-        temp |= (D << 24);
-        *((uint32*)(pred += 4)) = temp;
-
-
-        /* Diagonal Vertical Right */
-        mode_avail[AVC_I4_Vertical_Right] = 1;
-        pred = encvid->pred_i4[AVC_I4_Vertical_Right];
-
-        Q0 = P_A + P_B + 1;
-        R0 = P_B + P_C + 1;
-        S0 = P_C + P_D + 1;
-        P0 = P_X + P_A + 1;
-        D = (P_I + 2 * P_X + P_A + 2) >> 2;
-
-        P1 = (P0 + Q0) >> 2;
-        Q1 = (Q0 + R0) >> 2;
-        R1 = (R0 + S0) >> 2;
-
-        P0 >>= 1;
-        Q0 >>= 1;
-        R0 >>= 1;
-        S0 >>= 1;
-
-        P2 = (P_X + 2 * P_I + P_J + 2) >> 2;
-        Q2 = (P_I + 2 * P_J + P_K + 2) >> 2;
-
-        temp =  P0 | (Q0 << 8);  //[P0 Q0 R0 S0]
-        //[D  P1 Q1 R1]
-        temp |= (R0 << 16); //[P2 P0 Q0 R0]
-        temp |= (S0 << 24); //[Q2 D  P1 Q1]
-        *((uint32*)pred) =  temp;
-
-        temp =  D | (P1 << 8);
-        temp |= (Q1 << 16);
-        temp |= (R1 << 24);
-        *((uint32*)(pred += 4)) =  temp;
-
-        temp = P2 | (P0 << 8);
-        temp |= (Q0 << 16);
-        temp |= (R0 << 24);
-        *((uint32*)(pred += 4)) =  temp;
-
-        temp = Q2 | (D << 8);
-        temp |= (P1 << 16);
-        temp |= (Q1 << 24);
-        *((uint32*)(pred += 4)) =  temp;
-
-
-        /* Horizontal Down */
-        mode_avail[AVC_I4_Horizontal_Down] = 1;
-        pred = encvid->pred_i4[AVC_I4_Horizontal_Down];
-
-
-        Q2 = (P_A + 2 * P_B + P_C + 2) >> 2;
-        P2 = (P_X + 2 * P_A + P_B + 2) >> 2;
-        D = (P_I + 2 * P_X + P_A + 2) >> 2;
-        P0 = P_X + P_I + 1;
-        Q0 = P_I + P_J + 1;
-        R0 = P_J + P_K + 1;
-        S0 = P_K + P_L + 1;
-
-        P1 = (P0 + Q0) >> 2;
-        Q1 = (Q0 + R0) >> 2;
-        R1 = (R0 + S0) >> 2;
-
-        P0 >>= 1;
-        Q0 >>= 1;
-        R0 >>= 1;
-        S0 >>= 1;
-
-
-        /* we can pack these */
-        temp = P0 | (D << 8);   //[P0 D  P2 Q2]
-        //[Q0 P1 P0 D ]
-        temp |= (P2 << 16);  //[R0 Q1 Q0 P1]
-        temp |= (Q2 << 24); //[S0 R1 R0 Q1]
-        *((uint32*)pred) = temp;
-
-        temp = Q0 | (P1 << 8);
-        temp |= (P0 << 16);
-        temp |= (D << 24);
-        *((uint32*)(pred += 4)) = temp;
-
-        temp = R0 | (Q1 << 8);
-        temp |= (Q0 << 16);
-        temp |= (P1 << 24);
-        *((uint32*)(pred += 4)) = temp;
-
-        temp = S0 | (R1 << 8);
-        temp |= (R0 << 16);
-        temp |= (Q1 << 24);
-        *((uint32*)(pred += 4)) = temp;
-
-    }
-
-    /* vertical left */
-    mode_avail[AVC_I4_Vertical_Left] = 0;
-    if (availability.top)
-    {
-        mode_avail[AVC_I4_Vertical_Left] = 1;
-        pred = encvid->pred_i4[AVC_I4_Vertical_Left];
-
-        x0 = P_A + P_B + 1;
-        x1 = P_B + P_C + 1;
-        x2 = P_C + P_D + 1;
-        if (availability.top_right)
-        {
-            x3 = P_D + P_E + 1;
-            x4 = P_E + P_F + 1;
-            x5 = P_F + P_G + 1;
-        }
-        else
-        {
-            x3 = x4 = x5 = (P_D << 1) + 1;
-        }
-
-        temp1 = (x0 >> 1);
-        temp1 |= ((x1 >> 1) << 8);
-        temp1 |= ((x2 >> 1) << 16);
-        temp1 |= ((x3 >> 1) << 24);
-
-        *((uint32*)pred) = temp1;
-
-        temp2 = ((x0 + x1) >> 2);
-        temp2 |= (((x1 + x2) >> 2) << 8);
-        temp2 |= (((x2 + x3) >> 2) << 16);
-        temp2 |= (((x3 + x4) >> 2) << 24);
-
-        *((uint32*)(pred += 4)) = temp2;
-
-        temp1 = (temp1 >> 8) | ((x4 >> 1) << 24);   /* rotate out old value */
-        *((uint32*)(pred += 4)) = temp1;
-
-        temp2 = (temp2 >> 8) | (((x4 + x5) >> 2) << 24); /* rotate out old value */
-        *((uint32*)(pred += 4)) = temp2;
-    }
-
-    //===== LOOP OVER ALL 4x4 INTRA PREDICTION MODES =====
-    // can re-order the search here instead of going in order
-
-    // find most probable mode
-    encvid->mostProbableI4Mode[blkidx] = mostProbableMode = FindMostProbableI4Mode(video, blkidx);
-
-    min_cost = 0xFFFF;
-
-    for (ipmode = 0; ipmode < AVCNumI4PredMode; ipmode++)
-    {
-        if (mode_avail[ipmode] == TRUE)
-        {
-            cost  = (ipmode == mostProbableMode) ? 0 : fixedcost;
-            pred = encvid->pred_i4[ipmode];
-
-            cost_i4(org, org_pitch, pred, &cost);
-
-            if (cost < min_cost)
-            {
-                currMB->i4Mode[blkidx] = (AVCIntra4x4PredMode)ipmode;
-                min_cost   = cost;
-                min_sad = cost - ((ipmode == mostProbableMode) ? 0 : fixedcost);
-            }
-        }
-    }
-
-    if (blkidx == 0)
-    {
-        encvid->i4_sad = min_sad;
-    }
-    else
-    {
-        encvid->i4_sad += min_sad;
-    }
-
-    return min_cost;
-}
-
-int FindMostProbableI4Mode(AVCCommonObj *video, int blkidx)
-{
-    int dcOnlyPredictionFlag;
-    AVCMacroblock *currMB = video->currMB;
-    int intra4x4PredModeA, intra4x4PredModeB, predIntra4x4PredMode;
-
-
-    dcOnlyPredictionFlag = 0;
-    if (blkidx&0x3)
-    {
-        intra4x4PredModeA = currMB->i4Mode[blkidx-1]; // block to the left
-    }
-    else /* for blk 0, 4, 8, 12 */
-    {
-        if (video->intraAvailA)
-        {
-            if (video->mblock[video->mbAddrA].mbMode == AVC_I4)
-            {
-                intra4x4PredModeA = video->mblock[video->mbAddrA].i4Mode[blkidx + 3];
-            }
-            else
-            {
-                intra4x4PredModeA = AVC_I4_DC;
-            }
-        }
-        else
-        {
-            dcOnlyPredictionFlag = 1;
-            goto PRED_RESULT_READY;  // skip below
-        }
-    }
-
-    if (blkidx >> 2)
-    {
-        intra4x4PredModeB = currMB->i4Mode[blkidx-4]; // block above
-    }
-    else /* block 0, 1, 2, 3 */
-    {
-        if (video->intraAvailB)
-        {
-            if (video->mblock[video->mbAddrB].mbMode == AVC_I4)
-            {
-                intra4x4PredModeB = video->mblock[video->mbAddrB].i4Mode[blkidx+12];
-            }
-            else
-            {
-                intra4x4PredModeB = AVC_I4_DC;
-            }
-        }
-        else
-        {
-            dcOnlyPredictionFlag = 1;
-        }
-    }
-
-PRED_RESULT_READY:
-    if (dcOnlyPredictionFlag)
-    {
-        intra4x4PredModeA = intra4x4PredModeB = AVC_I4_DC;
-    }
-
-    predIntra4x4PredMode = AVC_MIN(intra4x4PredModeA, intra4x4PredModeB);
-
-    return predIntra4x4PredMode;
-}
-
-void cost_i4(uint8 *org, int org_pitch, uint8 *pred, uint16 *cost)
-{
-    int k;
-    int16 res[16], *pres;
-    int m0, m1, m2, m3, tmp1;
-    int satd = 0;
-
-    pres = res;
-    // horizontal transform
-    k = 4;
-    while (k > 0)
-    {
-        m0 = org[0] - pred[0];
-        m3 = org[3] - pred[3];
-        m0 += m3;
-        m3 = m0 - (m3 << 1);
-        m1 = org[1] - pred[1];
-        m2 = org[2] - pred[2];
-        m1 += m2;
-        m2 = m1 - (m2 << 1);
-        pres[0] = m0 + m1;
-        pres[2] = m0 - m1;
-        pres[1] = m2 + m3;
-        pres[3] = m3 - m2;
-
-        org += org_pitch;
-        pres += 4;
-        pred += 4;
-        k--;
-    }
-    /* vertical transform */
-    pres = res;
-    k = 4;
-    while (k > 0)
-    {
-        m0 = pres[0];
-        m3 = pres[12];
-        m0 += m3;
-        m3 = m0 - (m3 << 1);
-        m1 = pres[4];
-        m2 = pres[8];
-        m1 += m2;
-        m2 = m1 - (m2 << 1);
-        pres[0] = m0 + m1;
-        pres[8] = m0 - m1;
-        pres[4] = m2 + m3;
-        pres[12] = m3 - m2;
-
-        pres++;
-        k--;
-
-    }
-
-    pres = res;
-    k = 4;
-    while (k > 0)
-    {
-        tmp1 = *pres++;
-        satd += ((tmp1 >= 0) ? tmp1 : -tmp1);
-        tmp1 = *pres++;
-        satd += ((tmp1 >= 0) ? tmp1 : -tmp1);
-        tmp1 = *pres++;
-        satd += ((tmp1 >= 0) ? tmp1 : -tmp1);
-        tmp1 = *pres++;
-        satd += ((tmp1 >= 0) ? tmp1 : -tmp1);
-        k--;
-    }
-
-    satd = (satd + 1) >> 1;
-    *cost += satd;
-
-    return ;
-}
-
-void chroma_intra_search(AVCEncObject *encvid)
-{
-    AVCCommonObj *video = encvid->common;
-    AVCPictureData *currPic = video->currPic;
-
-    int x_pos = video->mb_x << 3;
-    int y_pos = video->mb_y << 3;
-    int pitch = currPic->pitch >> 1;
-    int offset = y_pos * pitch + x_pos;
-
-    uint8 *comp_ref_x, *comp_ref_y, *pred;
-    int  sum_x0, sum_x1, sum_y0, sum_y1;
-    int pred_0[2], pred_1[2], pred_2[2], pred_3[2];
-    uint32 pred_a, pred_b, pred_c, pred_d;
-    int i, j, component;
-    int a_16, b, c, factor_c, topleft;
-    int H, V, value;
-    uint8 *comp_ref_x0, *comp_ref_x1,  *comp_ref_y0, *comp_ref_y1;
-
-    uint8 *curCb = currPic->Scb + offset;
-    uint8 *curCr = currPic->Scr + offset;
-
-    uint8 *orgCb, *orgCr;
-    AVCFrameIO *currInput = encvid->currInput;
-    AVCMacroblock *currMB = video->currMB;
-    int org_pitch;
-    int cost, mincost;
-
-    /* evaluate DC mode */
-    if (video->intraAvailB & video->intraAvailA)
-    {
-        comp_ref_x = curCb - pitch;
-        comp_ref_y = curCb - 1;
-
-        for (i = 0; i < 2; i++)
-        {
-            pred_a = *((uint32*)comp_ref_x);
-            comp_ref_x += 4;
-            pred_b = (pred_a >> 8) & 0xFF00FF;
-            pred_a &= 0xFF00FF;
-            pred_a += pred_b;
-            pred_a += (pred_a >> 16);
-            sum_x0 = pred_a & 0xFFFF;
-
-            pred_a = *((uint32*)comp_ref_x);
-            pred_b = (pred_a >> 8) & 0xFF00FF;
-            pred_a &= 0xFF00FF;
-            pred_a += pred_b;
-            pred_a += (pred_a >> 16);
-            sum_x1 = pred_a & 0xFFFF;
-
-            pred_1[i] = (sum_x1 + 2) >> 2;
-
-            sum_y0 = *comp_ref_y;
-            sum_y0 += *(comp_ref_y += pitch);
-            sum_y0 += *(comp_ref_y += pitch);
-            sum_y0 += *(comp_ref_y += pitch);
-
-            sum_y1 = *(comp_ref_y += pitch);
-            sum_y1 += *(comp_ref_y += pitch);
-            sum_y1 += *(comp_ref_y += pitch);
-            sum_y1 += *(comp_ref_y += pitch);
-
-            pred_2[i] = (sum_y1 + 2) >> 2;
-
-            pred_0[i] = (sum_y0 + sum_x0 + 4) >> 3;
-            pred_3[i] = (sum_y1 + sum_x1 + 4) >> 3;
-
-            comp_ref_x = curCr - pitch;
-            comp_ref_y = curCr - 1;
-        }
-    }
-
-    else if (video->intraAvailA)
-    {
-        comp_ref_y = curCb - 1;
-        for (i = 0; i < 2; i++)
-        {
-            sum_y0 = *comp_ref_y;
-            sum_y0 += *(comp_ref_y += pitch);
-            sum_y0 += *(comp_ref_y += pitch);
-            sum_y0 += *(comp_ref_y += pitch);
-
-            sum_y1 = *(comp_ref_y += pitch);
-            sum_y1 += *(comp_ref_y += pitch);
-            sum_y1 += *(comp_ref_y += pitch);
-            sum_y1 += *(comp_ref_y += pitch);
-
-            pred_0[i] = pred_1[i] = (sum_y0 + 2) >> 2;
-            pred_2[i] = pred_3[i] = (sum_y1 + 2) >> 2;
-
-            comp_ref_y = curCr - 1;
-        }
-    }
-    else if (video->intraAvailB)
-    {
-        comp_ref_x = curCb - pitch;
-        for (i = 0; i < 2; i++)
-        {
-            pred_a = *((uint32*)comp_ref_x);
-            comp_ref_x += 4;
-            pred_b = (pred_a >> 8) & 0xFF00FF;
-            pred_a &= 0xFF00FF;
-            pred_a += pred_b;
-            pred_a += (pred_a >> 16);
-            sum_x0 = pred_a & 0xFFFF;
-
-            pred_a = *((uint32*)comp_ref_x);
-            pred_b = (pred_a >> 8) & 0xFF00FF;
-            pred_a &= 0xFF00FF;
-            pred_a += pred_b;
-            pred_a += (pred_a >> 16);
-            sum_x1 = pred_a & 0xFFFF;
-
-            pred_0[i] = pred_2[i] = (sum_x0 + 2) >> 2;
-            pred_1[i] = pred_3[i] = (sum_x1 + 2) >> 2;
-
-            comp_ref_x = curCr - pitch;
-        }
-    }
-    else
-    {
-        pred_0[0] = pred_0[1] = pred_1[0] = pred_1[1] =
-                                                pred_2[0] = pred_2[1] = pred_3[0] = pred_3[1] = 128;
-    }
-
-    pred = encvid->pred_ic[AVC_IC_DC];
-
-    pred_a = pred_0[0];
-    pred_b = pred_1[0];
-    pred_a |= (pred_a << 8);
-    pred_a |= (pred_a << 16);
-    pred_b |= (pred_b << 8);
-    pred_b |= (pred_b << 16);
-
-    pred_c = pred_0[1];
-    pred_d = pred_1[1];
-    pred_c |= (pred_c << 8);
-    pred_c |= (pred_c << 16);
-    pred_d |= (pred_d << 8);
-    pred_d |= (pred_d << 16);
-
-
-    for (j = 0; j < 4; j++) /* 4 lines */
-    {
-        *((uint32*)pred) = pred_a;
-        *((uint32*)(pred + 4)) = pred_b;
-        *((uint32*)(pred + 8)) = pred_c;
-        *((uint32*)(pred + 12)) = pred_d;
-        pred += 16; /* move to the next line */
-    }
-
-    pred_a = pred_2[0];
-    pred_b = pred_3[0];
-    pred_a |= (pred_a << 8);
-    pred_a |= (pred_a << 16);
-    pred_b |= (pred_b << 8);
-    pred_b |= (pred_b << 16);
-
-    pred_c = pred_2[1];
-    pred_d = pred_3[1];
-    pred_c |= (pred_c << 8);
-    pred_c |= (pred_c << 16);
-    pred_d |= (pred_d << 8);
-    pred_d |= (pred_d << 16);
-
-    for (j = 0; j < 4; j++) /* 4 lines */
-    {
-        *((uint32*)pred) = pred_a;
-        *((uint32*)(pred + 4)) = pred_b;
-        *((uint32*)(pred + 8)) = pred_c;
-        *((uint32*)(pred + 12)) = pred_d;
-        pred += 16; /* move to the next line */
-    }
-
-    /* predict horizontal mode */
-    if (video->intraAvailA)
-    {
-        comp_ref_y = curCb - 1;
-        comp_ref_x = curCr - 1;
-        pred = encvid->pred_ic[AVC_IC_Horizontal];
-
-        for (i = 4; i < 6; i++)
-        {
-            for (j = 0; j < 4; j++)
-            {
-                pred_a = *comp_ref_y;
-                comp_ref_y += pitch;
-                pred_a |= (pred_a << 8);
-                pred_a |= (pred_a << 16);
-                *((uint32*)pred) = pred_a;
-                *((uint32*)(pred + 4)) = pred_a;
-
-                pred_a = *comp_ref_x;
-                comp_ref_x += pitch;
-                pred_a |= (pred_a << 8);
-                pred_a |= (pred_a << 16);
-                *((uint32*)(pred + 8)) = pred_a;
-                *((uint32*)(pred + 12)) = pred_a;
-
-                pred += 16;
-            }
-        }
-    }
-
-    /* vertical mode */
-    if (video->intraAvailB)
-    {
-        comp_ref_x = curCb - pitch;
-        comp_ref_y = curCr - pitch;
-        pred = encvid->pred_ic[AVC_IC_Vertical];
-
-        pred_a = *((uint32*)comp_ref_x);
-        pred_b = *((uint32*)(comp_ref_x + 4));
-        pred_c = *((uint32*)comp_ref_y);
-        pred_d = *((uint32*)(comp_ref_y + 4));
-
-        for (j = 0; j < 8; j++)
-        {
-            *((uint32*)pred) = pred_a;
-            *((uint32*)(pred + 4)) = pred_b;
-            *((uint32*)(pred + 8)) = pred_c;
-            *((uint32*)(pred + 12)) = pred_d;
-            pred += 16;
-        }
-    }
-
-    /* Intra_Chroma_Plane */
-    if (video->intraAvailA && video->intraAvailB && video->intraAvailD)
-    {
-        comp_ref_x = curCb - pitch;
-        comp_ref_y = curCb - 1;
-        topleft = curCb[-pitch-1];
-
-        pred = encvid->pred_ic[AVC_IC_Plane];
-        for (component = 0; component < 2; component++)
-        {
-            H = V = 0;
-            comp_ref_x0 = comp_ref_x + 4;
-            comp_ref_x1 = comp_ref_x + 2;
-            comp_ref_y0 = comp_ref_y + (pitch << 2);
-            comp_ref_y1 = comp_ref_y + (pitch << 1);
-            for (i = 1; i < 4; i++)
-            {
-                H += i * (*comp_ref_x0++ - *comp_ref_x1--);
-                V += i * (*comp_ref_y0 - *comp_ref_y1);
-                comp_ref_y0 += pitch;
-                comp_ref_y1 -= pitch;
-            }
-            H += i * (*comp_ref_x0++ - topleft);
-            V += i * (*comp_ref_y0 - *comp_ref_y1);
-
-            a_16 = ((*(comp_ref_x + 7) + *(comp_ref_y + 7 * pitch)) << 4) + 16;
-            b = (17 * H + 16) >> 5;
-            c = (17 * V + 16) >> 5;
-
-            pred_a = 0;
-            for (i = 4; i < 6; i++)
-            {
-                for (j = 0; j < 4; j++)
-                {
-                    factor_c = a_16 + c * (pred_a++ - 3);
-
-                    factor_c -= 3 * b;
-
-                    value = factor_c >> 5;
-                    factor_c += b;
-                    CLIP_RESULT(value)
-                    pred_b = value;
-                    value = factor_c >> 5;
-                    factor_c += b;
-                    CLIP_RESULT(value)
-                    pred_b |= (value << 8);
-                    value = factor_c >> 5;
-                    factor_c += b;
-                    CLIP_RESULT(value)
-                    pred_b |= (value << 16);
-                    value = factor_c >> 5;
-                    factor_c += b;
-                    CLIP_RESULT(value)
-                    pred_b |= (value << 24);
-                    *((uint32*)pred) = pred_b;
-
-                    value = factor_c >> 5;
-                    factor_c += b;
-                    CLIP_RESULT(value)
-                    pred_b = value;
-                    value = factor_c >> 5;
-                    factor_c += b;
-                    CLIP_RESULT(value)
-                    pred_b |= (value << 8);
-                    value = factor_c >> 5;
-                    factor_c += b;
-                    CLIP_RESULT(value)
-                    pred_b |= (value << 16);
-                    value = factor_c >> 5;
-                    factor_c += b;
-                    CLIP_RESULT(value)
-                    pred_b |= (value << 24);
-                    *((uint32*)(pred + 4)) = pred_b;
-                    pred += 16;
-                }
-            }
-
-            pred -= 120; /* point to cr */
-            comp_ref_x = curCr - pitch;
-            comp_ref_y = curCr - 1;
-            topleft = curCr[-pitch-1];
-        }
-    }
-
-    /* now evaluate it */
-
-    org_pitch = (currInput->pitch) >> 1;
-    offset = x_pos + y_pos * org_pitch;
-
-    orgCb = currInput->YCbCr[1] + offset;
-    orgCr = currInput->YCbCr[2] + offset;
-
-    mincost = 0x7fffffff;
-    cost = SATDChroma(orgCb, orgCr, org_pitch, encvid->pred_ic[AVC_IC_DC], mincost);
-    if (cost < mincost)
-    {
-        mincost = cost;
-        currMB->intra_chroma_pred_mode = AVC_IC_DC;
-    }
-
-    if (video->intraAvailA)
-    {
-        cost = SATDChroma(orgCb, orgCr, org_pitch, encvid->pred_ic[AVC_IC_Horizontal], mincost);
-        if (cost < mincost)
-        {
-            mincost = cost;
-            currMB->intra_chroma_pred_mode = AVC_IC_Horizontal;
-        }
-    }
-
-    if (video->intraAvailB)
-    {
-        cost = SATDChroma(orgCb, orgCr, org_pitch, encvid->pred_ic[AVC_IC_Vertical], mincost);
-        if (cost < mincost)
-        {
-            mincost = cost;
-            currMB->intra_chroma_pred_mode = AVC_IC_Vertical;
-        }
-    }
-
-    if (video->intraAvailA && video->intraAvailB && video->intraAvailD)
-    {
-        cost = SATDChroma(orgCb, orgCr, org_pitch, encvid->pred_ic[AVC_IC_Plane], mincost);
-        if (cost < mincost)
-        {
-            mincost = cost;
-            currMB->intra_chroma_pred_mode = AVC_IC_Plane;
-        }
-    }
-
-
-    return ;
-}
-
-
-int SATDChroma(uint8 *orgCb, uint8 *orgCr, int org_pitch, uint8 *pred, int min_cost)
-{
-    int cost;
-    /* first take difference between orgCb, orgCr and pred */
-    int16 res[128], *pres; // residue
-    int m0, m1, m2, m3, tmp1;
-    int j, k;
-
-    pres = res;
-    org_pitch -= 8;
-    // horizontal transform
-    for (j = 0; j < 8; j++)
-    {
-        k = 2;
-        while (k > 0)
-        {
-            m0 = orgCb[0] - pred[0];
-            m3 = orgCb[3] - pred[3];
-            m0 += m3;
-            m3 = m0 - (m3 << 1);
-            m1 = orgCb[1] - pred[1];
-            m2 = orgCb[2] - pred[2];
-            m1 += m2;
-            m2 = m1 - (m2 << 1);
-            pres[0] = m0 + m1;
-            pres[2] = m0 - m1;
-            pres[1] = m2 + m3;
-            pres[3] = m3 - m2;
-
-            orgCb += 4;
-            pres += 4;
-            pred += 4;
-            k--;
-        }
-        orgCb += org_pitch;
-        k = 2;
-        while (k > 0)
-        {
-            m0 = orgCr[0] - pred[0];
-            m3 = orgCr[3] - pred[3];
-            m0 += m3;
-            m3 = m0 - (m3 << 1);
-            m1 = orgCr[1] - pred[1];
-            m2 = orgCr[2] - pred[2];
-            m1 += m2;
-            m2 = m1 - (m2 << 1);
-            pres[0] = m0 + m1;
-            pres[2] = m0 - m1;
-            pres[1] = m2 + m3;
-            pres[3] = m3 - m2;
-
-            orgCr += 4;
-            pres += 4;
-            pred += 4;
-            k--;
-        }
-        orgCr += org_pitch;
-    }
-
-    /* vertical transform */
-    for (j = 0; j < 2; j++)
-    {
-        pres = res + (j << 6);
-        k = 16;
-        while (k > 0)
-        {
-            m0 = pres[0];
-            m3 = pres[3<<4];
-            m0 += m3;
-            m3 = m0 - (m3 << 1);
-            m1 = pres[1<<4];
-            m2 = pres[2<<4];
-            m1 += m2;
-            m2 = m1 - (m2 << 1);
-            pres[0] = m0 + m1;
-            pres[2<<4] = m0 - m1;
-            pres[1<<4] = m2 + m3;
-            pres[3<<4] = m3 - m2;
-
-            pres++;
-            k--;
-        }
-    }
-
-    /* now sum of absolute value */
-    pres = res;
-    cost = 0;
-    k = 128;
-    while (k > 0)
-    {
-        tmp1 = *pres++;
-        cost += ((tmp1 >= 0) ? tmp1 : -tmp1);
-        tmp1 = *pres++;
-        cost += ((tmp1 >= 0) ? tmp1 : -tmp1);
-        tmp1 = *pres++;
-        cost += ((tmp1 >= 0) ? tmp1 : -tmp1);
-        tmp1 = *pres++;
-        cost += ((tmp1 >= 0) ? tmp1 : -tmp1);
-        tmp1 = *pres++;
-        cost += ((tmp1 >= 0) ? tmp1 : -tmp1);
-        tmp1 = *pres++;
-        cost += ((tmp1 >= 0) ? tmp1 : -tmp1);
-        tmp1 = *pres++;
-        cost += ((tmp1 >= 0) ? tmp1 : -tmp1);
-        tmp1 = *pres++;
-        cost += ((tmp1 >= 0) ? tmp1 : -tmp1);
-        k -= 8;
-        if (cost > min_cost) /* early drop out */
-        {
-            return cost;
-        }
-    }
-
-    return cost;
-}
-
-
-
-///////////////////////////////// old code, unused
-/* find the best intra mode based on original (unencoded) frame */
-/* output is
-    currMB->mb_intra, currMB->mbMode,
-    currMB->i16Mode  (if currMB->mbMode == AVC_I16)
-    currMB->i4Mode[..] (if currMB->mbMode == AVC_I4) */
-
-#ifdef FIXED_INTRAPRED_MODE
-void MBIntraSearch(AVCEncObject *encvid, AVCMacroblock *currMB, int mbNum)
-{
-    (void)(mbNum);
-
-    AVCCommonObj *video = encvid->common;
-    int indx, block_x, block_y;
-
-    video->intraAvailA = video->intraAvailB = video->intraAvailC = video->intraAvailD = 0;
-
-    if (!video->currPicParams->constrained_intra_pred_flag)
-    {
-        video->intraAvailA = video->mbAvailA;
-        video->intraAvailB = video->mbAvailB;
-        video->intraAvailC = video->mbAvailC;
-        video->intraAvailD = video->mbAvailD;
-    }
-    else
-    {
-        if (video->mbAvailA)
-        {
-            video->intraAvailA = video->mblock[video->mbAddrA].mb_intra;
-        }
-        if (video->mbAvailB)
-        {
-            video->intraAvailB = video->mblock[video->mbAddrB].mb_intra ;
-        }
-        if (video->mbAvailC)
-        {
-            video->intraAvailC = video->mblock[video->mbAddrC].mb_intra;
-        }
-        if (video->mbAvailD)
-        {
-            video->intraAvailD = video->mblock[video->mbAddrD].mb_intra;
-        }
-    }
-
-    currMB->mb_intra = TRUE;
-    currMB->mbMode = FIXED_INTRAPRED_MODE;
-
-    if (currMB->mbMode == AVC_I16)
-    {
-        currMB->i16Mode = FIXED_I16_MODE;
-
-        if (FIXED_I16_MODE == AVC_I16_Vertical && !video->intraAvailB)
-        {
-            currMB->i16Mode = AVC_I16_DC;
-        }
-
-        if (FIXED_I16_MODE == AVC_I16_Horizontal && !video->intraAvailA)
-        {
-            currMB->i16Mode = AVC_I16_DC;
-        }
-
-        if (FIXED_I16_MODE == AVC_I16_Plane && !(video->intraAvailA && video->intraAvailB && video->intraAvailD))
-        {
-            currMB->i16Mode = AVC_I16_DC;
-        }
-    }
-    else //if(currMB->mbMode == AVC_I4)
-    {
-        for (indx = 0; indx < 16; indx++)
-        {
-            block_x = blkIdx2blkX[indx];
-            block_y = blkIdx2blkY[indx];
-
-            currMB->i4Mode[(block_y<<2)+block_x] = FIXED_I4_MODE;
-
-            if (FIXED_I4_MODE == AVC_I4_Vertical && !(block_y > 0 || video->intraAvailB))
-            {
-                currMB->i4Mode[(block_y<<2)+block_x] = AVC_I4_DC;
-            }
-
-            if (FIXED_I4_MODE == AVC_I4_Horizontal && !(block_x || video->intraAvailA))
-            {
-                currMB->i4Mode[(block_y<<2)+block_x] = AVC_I4_DC;
-            }
-
-            if (FIXED_I4_MODE == AVC_I4_Diagonal_Down_Left &&
-                    (block_y == 0 && !video->intraAvailB))
-            {
-                currMB->i4Mode[(block_y<<2)+block_x] = AVC_I4_DC;
-            }
-
-            if (FIXED_I4_MODE == AVC_I4_Diagonal_Down_Right &&
-                    !((block_y && block_x)
-                      || (block_y && video->intraAvailA)
-                      || (block_x && video->intraAvailB)
-                      || (video->intraAvailA && video->intraAvailD && video->intraAvailB)))
-            {
-                currMB->i4Mode[(block_y<<2)+block_x] = AVC_I4_DC;
-            }
-
-            if (FIXED_I4_MODE == AVC_I4_Vertical_Right &&
-                    !((block_y && block_x)
-                      || (block_y && video->intraAvailA)
-                      || (block_x && video->intraAvailB)
-                      || (video->intraAvailA && video->intraAvailD && video->intraAvailB)))
-            {
-                currMB->i4Mode[(block_y<<2)+block_x] = AVC_I4_DC;
-            }
-
-            if (FIXED_I4_MODE == AVC_I4_Horizontal_Down &&
-                    !((block_y && block_x)
-                      || (block_y && video->intraAvailA)
-                      || (block_x && video->intraAvailB)
-                      || (video->intraAvailA && video->intraAvailD && video->intraAvailB)))
-            {
-                currMB->i4Mode[(block_y<<2)+block_x] = AVC_I4_DC;
-            }
-
-            if (FIXED_I4_MODE == AVC_I4_Vertical_Left &&
-                    (block_y == 0 && !video->intraAvailB))
-            {
-                currMB->i4Mode[(block_y<<2)+block_x] = AVC_I4_DC;
-            }
-
-            if (FIXED_I4_MODE == AVC_I4_Horizontal_Up && !(block_x || video->intraAvailA))
-            {
-                currMB->i4Mode[(block_y<<2)+block_x] = AVC_I4_DC;
-            }
-        }
-    }
-
-    currMB->intra_chroma_pred_mode = FIXED_INTRA_CHROMA_MODE;
-
-    if (FIXED_INTRA_CHROMA_MODE == AVC_IC_Horizontal && !(video->intraAvailA))
-    {
-        currMB->intra_chroma_pred_mode = AVC_IC_DC;
-    }
-
-    if (FIXED_INTRA_CHROMA_MODE == AVC_IC_Vertical && !(video->intraAvailB))
-    {
-        currMB->intra_chroma_pred_mode = AVC_IC_DC;
-    }
-
-    if (FIXED_INTRA_CHROMA_MODE == AVC_IC_Plane && !(video->intraAvailA && video->intraAvailB && video->intraAvailD))
-    {
-        currMB->intra_chroma_pred_mode = AVC_IC_DC;
-    }
-
-    /* also reset the motion vectors */
-    /* set MV and Ref_Idx codes of Intra blocks in P-slices */
-    memset(currMB->mvL0, 0, sizeof(int32)*16);
-    currMB->ref_idx_L0[0] = -1;
-    currMB->ref_idx_L0[1] = -1;
-    currMB->ref_idx_L0[2] = -1;
-    currMB->ref_idx_L0[3] = -1;
-
-    // output from this function, currMB->mbMode should be set to either
-    // AVC_I4, AVC_I16, or else in AVCMBMode enum, mbType, mb_intra, intra_chroma_pred_mode */
-    return ;
-}
-#else // faster combined prediction+SAD calculation
-void MBIntraSearch(AVCEncObject *encvid, AVCMacroblock *currMB, int mbNum)
-{
-    AVCCommonObj *video = encvid->common;
-    AVCFrameIO *currInput = encvid->currInput;
-    uint8 *curL, *curCb, *curCr;
-    uint8 *comp, *pred_block;
-    int block_x, block_y, offset;
-    uint sad, sad4, sadI4, sadI16;
-    int component, SubBlock_indx, temp;
-    int pitch = video->currPic->pitch;
-
-    /* calculate the cost of each intra prediction mode  and compare to the
-    inter mode */
-    /* full search for all intra prediction */
-    offset = (video->mb_y << 4) * pitch + (video->mb_x << 4);
-    curL = currInput->YCbCr[0] + offset;
-    pred_block = video->pred_block + 84;
-
-    /* Assuming that InitNeighborAvailability has been called prior to this function */
-    video->intraAvailA = video->intraAvailB = video->intraAvailC = video->intraAvailD = 0;
-
-    if (!video->currPicParams->constrained_intra_pred_flag)
-    {
-        video->intraAvailA = video->mbAvailA;
-        video->intraAvailB = video->mbAvailB;
-        video->intraAvailC = video->mbAvailC;
-        video->intraAvailD = video->mbAvailD;
-    }
-    else
-    {
-        if (video->mbAvailA)
-        {
-            video->intraAvailA = video->mblock[video->mbAddrA].mb_intra;
-        }
-        if (video->mbAvailB)
-        {
-            video->intraAvailB = video->mblock[video->mbAddrB].mb_intra ;
-        }
-        if (video->mbAvailC)
-        {
-            video->intraAvailC = video->mblock[video->mbAddrC].mb_intra;
-        }
-        if (video->mbAvailD)
-        {
-            video->intraAvailD = video->mblock[video->mbAddrD].mb_intra;
-        }
-    }
-
-    /* currently we're doing exhaustive search. Smart search will be used later */
-
-    /* I16 modes */
-    curL = currInput->YCbCr[0] + offset;
-    video->pintra_pred_top = curL - pitch;
-    video->pintra_pred_left = curL - 1;
-    if (video->mb_y)
-    {
-        video->intra_pred_topleft = *(curL - pitch - 1);
-    }
-
-    /* Intra_16x16_Vertical */
-    sadI16 = 65536;
-    /* check availability of top */
-    if (video->intraAvailB)
-    {
-        sad = SAD_I16_Vert(video, curL, sadI16);
-
-        if (sad < sadI16)
-        {
-            sadI16 = sad;
-            currMB->i16Mode = AVC_I16_Vertical;
-        }
-    }
-    /* Intra_16x16_Horizontal */
-    /* check availability of left */
-    if (video->intraAvailA)
-    {
-        sad = SAD_I16_HorzDC(video, curL, AVC_I16_Horizontal, sadI16);
-
-        if (sad < sadI16)
-        {
-            sadI16 = sad;
-            currMB->i16Mode = AVC_I16_Horizontal;
-        }
-    }
-
-    /* Intra_16x16_DC, default mode */
-    sad = SAD_I16_HorzDC(video, curL, AVC_I16_DC, sadI16);
-    if (sad < sadI16)
-    {
-        sadI16 = sad;
-        currMB->i16Mode = AVC_I16_DC;
-    }
-
-    /* Intra_16x16_Plane */
-    if (video->intraAvailA && video->intraAvailB && video->intraAvailD)
-    {
-        sad = SAD_I16_Plane(video, curL, sadI16);
-
-        if (sad < sadI16)
-        {
-            sadI16 = sad;
-            currMB->i16Mode = AVC_I16_Plane;
-        }
-    }
-
-    sadI16 >>= 1;  /* before comparison */
-
-    /* selection between intra4, intra16 or inter mode */
-    if (sadI16 < encvid->min_cost)
-    {
-        currMB->mb_intra = TRUE;
-        currMB->mbMode = AVC_I16;
-        encvid->min_cost = sadI16;
-    }
-
-    if (currMB->mb_intra) /* only do the chrominance search when intra is decided */
-    {
-        /* Note that we might be able to guess the type of prediction from
-        the luma prediction type */
-
-        /* now search for the best chroma intra prediction */
-        offset = (offset >> 2) + (video->mb_x << 2);
-        curCb = currInput->YCbCr[1] + offset;
-        curCr = currInput->YCbCr[2] + offset;
-
-        pitch >>= 1;
-        video->pintra_pred_top_cb = curCb - pitch;
-        video->pintra_pred_left_cb = curCb - 1;
-        video->pintra_pred_top_cr = curCr - pitch;
-        video->pintra_pred_left_cr = curCr - 1;
-
-        if (video->mb_y)
-        {
-            video->intra_pred_topleft_cb = *(curCb - pitch - 1);
-            video->intra_pred_topleft_cr = *(curCr - pitch - 1);
-        }
-
-        /* Intra_Chroma_DC */
-        sad4 = SAD_Chroma_DC(video, curCb, curCr, 65536);
-        currMB->intra_chroma_pred_mode = AVC_IC_DC;
-
-        /* Intra_Chroma_Horizontal */
-        if (video->intraAvailA)
-        {
-            /* check availability of left */
-            sad = SAD_Chroma_Horz(video, curCb, curCr, sad4);
-            if (sad < sad4)
-            {
-                sad4 = sad;
-                currMB->intra_chroma_pred_mode = AVC_IC_Horizontal;
-            }
-        }
-
-        /* Intra_Chroma_Vertical */
-        if (video->intraAvailB)
-        {
-            /* check availability of top */
-            sad = SAD_Chroma_Vert(video, curCb, curCr, sad4);
-
-            if (sad < sad4)
-            {
-                sad4 = sad;
-                currMB->intra_chroma_pred_mode = AVC_IC_Vertical;
-            }
-        }
-
-        /* Intra_Chroma_Plane */
-        if (video->intraAvailA && video->intraAvailB && video->intraAvailD)
-        {
-            /* check availability of top and left */
-            Intra_Chroma_Plane(video, pitch);
-
-            sad = SADChroma(pred_block + 452, curCb, curCr, pitch);
-
-            if (sad < sad4)
-            {
-                sad4 = sad;
-                currMB->intra_chroma_pred_mode = AVC_IC_Plane;
-            }
-        }
-
-        /* also reset the motion vectors */
-        /* set MV and Ref_Idx codes of Intra blocks in P-slices */
-        memset(currMB->mvL0, 0, sizeof(int32)*16);
-        memset(currMB->ref_idx_L0, -1, sizeof(int16)*4);
-
-    }
-
-    // output from this function, currMB->mbMode should be set to either
-    // AVC_I4, AVC_I16, or else in AVCMBMode enum, mbType, mb_intra, intra_chroma_pred_mode */
-
-    return ;
-}
-#endif
-
-
diff --git a/media/libstagefright/codecs/avc/enc/src/motion_comp.cpp b/media/libstagefright/codecs/avc/enc/src/motion_comp.cpp
deleted file mode 100644
index d19125f..0000000
--- a/media/libstagefright/codecs/avc/enc/src/motion_comp.cpp
+++ /dev/null
@@ -1,2152 +0,0 @@
-/* ------------------------------------------------------------------
- * 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 "avcenc_lib.h"
-#include "avcenc_int.h"
-
-
-#define CLIP_RESULT(x)      if((uint)(x) > 0xFF){ \
-                 (x) = 0xFF & (~((x)>>31));}
-
-/* (blkwidth << 2) + (dy << 1) + dx */
-static void (*const eChromaMC_SIMD[8])(uint8 *, int , int , int , uint8 *, int, int , int) =
-{
-    &eChromaFullMC_SIMD,
-    &eChromaHorizontalMC_SIMD,
-    &eChromaVerticalMC_SIMD,
-    &eChromaDiagonalMC_SIMD,
-    &eChromaFullMC_SIMD,
-    &eChromaHorizontalMC2_SIMD,
-    &eChromaVerticalMC2_SIMD,
-    &eChromaDiagonalMC2_SIMD
-};
-/* Perform motion prediction and compensation with residue if exist. */
-void AVCMBMotionComp(AVCEncObject *encvid, AVCCommonObj *video)
-{
-    (void)(encvid);
-
-    AVCMacroblock *currMB = video->currMB;
-    AVCPictureData *currPic = video->currPic;
-    int mbPartIdx, subMbPartIdx;
-    int ref_idx;
-    int offset_MbPart_indx = 0;
-    int16 *mv;
-    uint32 x_pos, y_pos;
-    uint8 *curL, *curCb, *curCr;
-    uint8 *ref_l, *ref_Cb, *ref_Cr;
-    uint8 *predBlock, *predCb, *predCr;
-    int block_x, block_y, offset_x, offset_y, offsetP, offset;
-    int x_position = (video->mb_x << 4);
-    int y_position = (video->mb_y << 4);
-    int MbHeight, MbWidth, mbPartIdx_X, mbPartIdx_Y, offset_indx;
-    int picWidth = currPic->width;
-    int picPitch = currPic->pitch;
-    int picHeight = currPic->height;
-    uint32 tmp_word;
-
-    tmp_word = y_position * picPitch;
-    curL = currPic->Sl + tmp_word + x_position;
-    offset = (tmp_word >> 2) + (x_position >> 1);
-    curCb = currPic->Scb + offset;
-    curCr = currPic->Scr + offset;
-
-    predBlock = curL;
-    predCb = curCb;
-    predCr = curCr;
-
-    GetMotionVectorPredictor(video, 1);
-
-    for (mbPartIdx = 0; mbPartIdx < currMB->NumMbPart; mbPartIdx++)
-    {
-        MbHeight = currMB->SubMbPartHeight[mbPartIdx];
-        MbWidth = currMB->SubMbPartWidth[mbPartIdx];
-        mbPartIdx_X = ((mbPartIdx + offset_MbPart_indx) & 1);
-        mbPartIdx_Y = (mbPartIdx + offset_MbPart_indx) >> 1;
-        ref_idx = currMB->ref_idx_L0[(mbPartIdx_Y << 1) + mbPartIdx_X];
-        offset_indx = 0;
-
-        ref_l = video->RefPicList0[ref_idx]->Sl;
-        ref_Cb = video->RefPicList0[ref_idx]->Scb;
-        ref_Cr = video->RefPicList0[ref_idx]->Scr;
-
-        for (subMbPartIdx = 0; subMbPartIdx < currMB->NumSubMbPart[mbPartIdx]; subMbPartIdx++)
-        {
-            block_x = (mbPartIdx_X << 1) + ((subMbPartIdx + offset_indx) & 1);
-            block_y = (mbPartIdx_Y << 1) + (((subMbPartIdx + offset_indx) >> 1) & 1);
-            mv = (int16*)(currMB->mvL0 + block_x + (block_y << 2));
-            offset_x = x_position + (block_x << 2);
-            offset_y = y_position + (block_y << 2);
-            x_pos = (offset_x << 2) + *mv++;   /*quarter pel */
-            y_pos = (offset_y << 2) + *mv;   /*quarter pel */
-
-            //offset = offset_y * currPic->width;
-            //offsetC = (offset >> 2) + (offset_x >> 1);
-            offsetP = (block_y << 2) * picPitch + (block_x << 2);
-            eLumaMotionComp(ref_l, picPitch, picHeight, x_pos, y_pos,
-                            /*comp_Sl + offset + offset_x,*/
-                            predBlock + offsetP, picPitch, MbWidth, MbHeight);
-
-            offsetP = (block_y * picWidth) + (block_x << 1);
-            eChromaMotionComp(ref_Cb, picWidth >> 1, picHeight >> 1, x_pos, y_pos,
-                              /*comp_Scb +  offsetC,*/
-                              predCb + offsetP, picPitch >> 1, MbWidth >> 1, MbHeight >> 1);
-            eChromaMotionComp(ref_Cr, picWidth >> 1, picHeight >> 1, x_pos, y_pos,
-                              /*comp_Scr +  offsetC,*/
-                              predCr + offsetP, picPitch >> 1, MbWidth >> 1, MbHeight >> 1);
-
-            offset_indx = currMB->SubMbPartWidth[mbPartIdx] >> 3;
-        }
-        offset_MbPart_indx = currMB->MbPartWidth >> 4;
-    }
-
-    return ;
-}
-
-
-/* preform the actual  motion comp here */
-void eLumaMotionComp(uint8 *ref, int picpitch, int picheight,
-                     int x_pos, int y_pos,
-                     uint8 *pred, int pred_pitch,
-                     int blkwidth, int blkheight)
-{
-    (void)(picheight);
-
-    int dx, dy;
-    int temp2[21][21]; /* for intermediate results */
-    uint8 *ref2;
-
-    dx = x_pos & 3;
-    dy = y_pos & 3;
-    x_pos = x_pos >> 2;  /* round it to full-pel resolution */
-    y_pos = y_pos >> 2;
-
-    /* perform actual motion compensation */
-    if (dx == 0 && dy == 0)
-    {  /* fullpel position *//* G */
-
-        ref += y_pos * picpitch + x_pos;
-
-        eFullPelMC(ref, picpitch, pred, pred_pitch, blkwidth, blkheight);
-
-    }   /* other positions */
-    else  if (dy == 0)
-    { /* no vertical interpolation *//* a,b,c*/
-
-        ref += y_pos * picpitch + x_pos;
-
-        eHorzInterp1MC(ref, picpitch, pred, pred_pitch, blkwidth, blkheight, dx);
-    }
-    else if (dx == 0)
-    { /*no horizontal interpolation *//* d,h,n */
-
-        ref += y_pos * picpitch + x_pos;
-
-        eVertInterp1MC(ref, picpitch, pred, pred_pitch, blkwidth, blkheight, dy);
-    }
-    else if (dy == 2)
-    {  /* horizontal cross *//* i, j, k */
-
-        ref += y_pos * picpitch + x_pos - 2; /* move to the left 2 pixels */
-
-        eVertInterp2MC(ref, picpitch, &temp2[0][0], 21, blkwidth + 5, blkheight);
-
-        eHorzInterp2MC(&temp2[0][2], 21, pred, pred_pitch, blkwidth, blkheight, dx);
-    }
-    else if (dx == 2)
-    { /* vertical cross */ /* f,q */
-
-        ref += (y_pos - 2) * picpitch + x_pos; /* move to up 2 lines */
-
-        eHorzInterp3MC(ref, picpitch, &temp2[0][0], 21, blkwidth, blkheight + 5);
-        eVertInterp3MC(&temp2[2][0], 21, pred, pred_pitch, blkwidth, blkheight, dy);
-    }
-    else
-    { /* diagonal *//* e,g,p,r */
-
-        ref2 = ref + (y_pos + (dy / 2)) * picpitch + x_pos;
-
-        ref += (y_pos * picpitch) + x_pos + (dx / 2);
-
-        eDiagonalInterpMC(ref2, ref, picpitch, pred, pred_pitch, blkwidth, blkheight);
-    }
-
-    return ;
-}
-
-void eCreateAlign(uint8 *ref, int picpitch, int y_pos,
-                  uint8 *out, int blkwidth, int blkheight)
-{
-    int i, j;
-    int offset, out_offset;
-    uint32 prev_pix, result, pix1, pix2, pix4;
-
-    ref += y_pos * picpitch;// + x_pos;
-    out_offset = 24 - blkwidth;
-
-    //switch(x_pos&0x3){
-    switch (((intptr_t)ref)&0x3)
-    {
-        case 1:
-            offset =  picpitch - blkwidth - 3;
-            for (j = 0; j < blkheight; j++)
-            {
-                pix1 = *ref++;
-                pix2 = *((uint16*)ref);
-                ref += 2;
-                result = (pix2 << 8) | pix1;
-
-                for (i = 3; i < blkwidth; i += 4)
-                {
-                    pix4 = *((uint32*)ref);
-                    ref += 4;
-                    prev_pix = (pix4 << 24) & 0xFF000000; /* mask out byte belong to previous word */
-                    result |= prev_pix;
-                    *((uint32*)out) = result;  /* write 4 bytes */
-                    out += 4;
-                    result = pix4 >> 8; /* for the next loop */
-                }
-                ref += offset;
-                out += out_offset;
-            }
-            break;
-        case 2:
-            offset =  picpitch - blkwidth - 2;
-            for (j = 0; j < blkheight; j++)
-            {
-                result = *((uint16*)ref);
-                ref += 2;
-                for (i = 2; i < blkwidth; i += 4)
-                {
-                    pix4 = *((uint32*)ref);
-                    ref += 4;
-                    prev_pix = (pix4 << 16) & 0xFFFF0000; /* mask out byte belong to previous word */
-                    result |= prev_pix;
-                    *((uint32*)out) = result;  /* write 4 bytes */
-                    out += 4;
-                    result = pix4 >> 16; /* for the next loop */
-                }
-                ref += offset;
-                out += out_offset;
-            }
-            break;
-        case 3:
-            offset =  picpitch - blkwidth - 1;
-            for (j = 0; j < blkheight; j++)
-            {
-                result = *ref++;
-                for (i = 1; i < blkwidth; i += 4)
-                {
-                    pix4 = *((uint32*)ref);
-                    ref += 4;
-                    prev_pix = (pix4 << 8) & 0xFFFFFF00; /* mask out byte belong to previous word */
-                    result |= prev_pix;
-                    *((uint32*)out) = result;  /* write 4 bytes */
-                    out += 4;
-                    result = pix4 >> 24; /* for the next loop */
-                }
-                ref += offset;
-                out += out_offset;
-            }
-            break;
-    }
-}
-
-void eHorzInterp1MC(uint8 *in, int inpitch, uint8 *out, int outpitch,
-                    int blkwidth, int blkheight, int dx)
-{
-    uint8 *p_ref, *tmp;
-    uint32 *p_cur;
-    uint32 pkres;
-    int result, curr_offset, ref_offset;
-    int j;
-    int32 r0, r1, r2, r3, r4, r5;
-    int32 r13, r6;
-
-    p_cur = (uint32*)out; /* assume it's word aligned */
-    curr_offset = (outpitch - blkwidth) >> 2;
-    p_ref = in;
-    ref_offset = inpitch - blkwidth;
-
-    if (dx&1)
-    {
-        dx = ((dx >> 1) ? -3 : -4); /* use in 3/4 pel */
-        p_ref -= 2;
-        r13 = 0;
-        for (j = blkheight; j > 0; j--)
-        {
-            tmp = p_ref + blkwidth;
-            r0 = p_ref[0];
-            r1 = p_ref[2];
-            r0 |= (r1 << 16);           /* 0,c,0,a */
-            r1 = p_ref[1];
-            r2 = p_ref[3];
-            r1 |= (r2 << 16);           /* 0,d,0,b */
-            while (p_ref < tmp)
-            {
-                r2 = *(p_ref += 4); /* move pointer to e */
-                r3 = p_ref[2];
-                r2 |= (r3 << 16);           /* 0,g,0,e */
-                r3 = p_ref[1];
-                r4 = p_ref[3];
-                r3 |= (r4 << 16);           /* 0,h,0,f */
-
-                r4 = r0 + r3;       /* c+h, a+f */
-                r5 = r0 + r1;   /* c+d, a+b */
-                r6 = r2 + r3;   /* g+h, e+f */
-                r5 >>= 16;
-                r5 |= (r6 << 16);   /* e+f, c+d */
-                r4 += r5 * 20;      /* c+20*e+20*f+h, a+20*c+20*d+f */
-                r4 += 0x100010; /* +16, +16 */
-                r5 = r1 + r2;       /* d+g, b+e */
-                r4 -= r5 * 5;       /* c-5*d+20*e+20*f-5*g+h, a-5*b+20*c+20*d-5*e+f */
-                r4 >>= 5;
-                r13 |= r4;      /* check clipping */
-
-                r5 = p_ref[dx+2];
-                r6 = p_ref[dx+4];
-                r5 |= (r6 << 16);
-                r4 += r5;
-                r4 += 0x10001;
-                r4 = (r4 >> 1) & 0xFF00FF;
-
-                r5 = p_ref[4];  /* i */
-                r6 = (r5 << 16);
-                r5 = r6 | (r2 >> 16);/* 0,i,0,g */
-                r5 += r1;       /* d+i, b+g */ /* r5 not free */
-                r1 >>= 16;
-                r1 |= (r3 << 16); /* 0,f,0,d */ /* r1 has changed */
-                r1 += r2;       /* f+g, d+e */
-                r5 += 20 * r1;  /* d+20f+20g+i, b+20d+20e+g */
-                r0 >>= 16;
-                r0 |= (r2 << 16); /* 0,e,0,c */ /* r0 has changed */
-                r0 += r3;       /* e+h, c+f */
-                r5 += 0x100010; /* 16,16 */
-                r5 -= r0 * 5;       /* d-5e+20f+20g-5h+i, b-5c+20d+20e-5f+g */
-                r5 >>= 5;
-                r13 |= r5;      /* check clipping */
-
-                r0 = p_ref[dx+3];
-                r1 = p_ref[dx+5];
-                r0 |= (r1 << 16);
-                r5 += r0;
-                r5 += 0x10001;
-                r5 = (r5 >> 1) & 0xFF00FF;
-
-                r4 |= (r5 << 8);    /* pack them together */
-                *p_cur++ = r4;
-                r1 = r3;
-                r0 = r2;
-            }
-            p_cur += curr_offset; /* move to the next line */
-            p_ref += ref_offset;  /*    ref_offset = inpitch-blkwidth; */
-
-            if (r13&0xFF000700) /* need clipping */
-            {
-                /* move back to the beginning of the line */
-                p_ref -= (ref_offset + blkwidth);   /* input */
-                p_cur -= (outpitch >> 2);
-
-                tmp = p_ref + blkwidth;
-                for (; p_ref < tmp;)
-                {
-
-                    r0 = *p_ref++;
-                    r1 = *p_ref++;
-                    r2 = *p_ref++;
-                    r3 = *p_ref++;
-                    r4 = *p_ref++;
-                    /* first pixel */
-                    r5 = *p_ref++;
-                    result = (r0 + r5);
-                    r0 = (r1 + r4);
-                    result -= (r0 * 5);//result -= r0;  result -= (r0<<2);
-                    r0 = (r2 + r3);
-                    result += (r0 * 20);//result += (r0<<4);    result += (r0<<2);
-                    result = (result + 16) >> 5;
-                    CLIP_RESULT(result)
-                    /* 3/4 pel,  no need to clip */
-                    result = (result + p_ref[dx] + 1);
-                    pkres = (result >> 1) ;
-                    /* second pixel */
-                    r0 = *p_ref++;
-                    result = (r1 + r0);
-                    r1 = (r2 + r5);
-                    result -= (r1 * 5);//result -= r1;  result -= (r1<<2);
-                    r1 = (r3 + r4);
-                    result += (r1 * 20);//result += (r1<<4);    result += (r1<<2);
-                    result = (result + 16) >> 5;
-                    CLIP_RESULT(result)
-                    /* 3/4 pel,  no need to clip */
-                    result = (result + p_ref[dx] + 1);
-                    result = (result >> 1);
-                    pkres  |= (result << 8);
-                    /* third pixel */
-                    r1 = *p_ref++;
-                    result = (r2 + r1);
-                    r2 = (r3 + r0);
-                    result -= (r2 * 5);//result -= r2;  result -= (r2<<2);
-                    r2 = (r4 + r5);
-                    result += (r2 * 20);//result += (r2<<4);    result += (r2<<2);
-                    result = (result + 16) >> 5;
-                    CLIP_RESULT(result)
-                    /* 3/4 pel,  no need to clip */
-                    result = (result + p_ref[dx] + 1);
-                    result = (result >> 1);
-                    pkres  |= (result << 16);
-                    /* fourth pixel */
-                    r2 = *p_ref++;
-                    result = (r3 + r2);
-                    r3 = (r4 + r1);
-                    result -= (r3 * 5);//result -= r3;  result -= (r3<<2);
-                    r3 = (r5 + r0);
-                    result += (r3 * 20);//result += (r3<<4);    result += (r3<<2);
-                    result = (result + 16) >> 5;
-                    CLIP_RESULT(result)
-                    /* 3/4 pel,  no need to clip */
-                    result = (result + p_ref[dx] + 1);
-                    result = (result >> 1);
-                    pkres  |= (result << 24);
-                    *p_cur++ = pkres; /* write 4 pixels */
-                    p_ref -= 5;  /* offset back to the middle of filter */
-                }
-                p_cur += curr_offset;  /* move to the next line */
-                p_ref += ref_offset;    /* move to the next line */
-            }
-        }
-    }
-    else
-    {
-        p_ref -= 2;
-        r13 = 0;
-        for (j = blkheight; j > 0; j--)
-        {
-            tmp = p_ref + blkwidth;
-            r0 = p_ref[0];
-            r1 = p_ref[2];
-            r0 |= (r1 << 16);           /* 0,c,0,a */
-            r1 = p_ref[1];
-            r2 = p_ref[3];
-            r1 |= (r2 << 16);           /* 0,d,0,b */
-            while (p_ref < tmp)
-            {
-                r2 = *(p_ref += 4); /* move pointer to e */
-                r3 = p_ref[2];
-                r2 |= (r3 << 16);           /* 0,g,0,e */
-                r3 = p_ref[1];
-                r4 = p_ref[3];
-                r3 |= (r4 << 16);           /* 0,h,0,f */
-
-                r4 = r0 + r3;       /* c+h, a+f */
-                r5 = r0 + r1;   /* c+d, a+b */
-                r6 = r2 + r3;   /* g+h, e+f */
-                r5 >>= 16;
-                r5 |= (r6 << 16);   /* e+f, c+d */
-                r4 += r5 * 20;      /* c+20*e+20*f+h, a+20*c+20*d+f */
-                r4 += 0x100010; /* +16, +16 */
-                r5 = r1 + r2;       /* d+g, b+e */
-                r4 -= r5 * 5;       /* c-5*d+20*e+20*f-5*g+h, a-5*b+20*c+20*d-5*e+f */
-                r4 >>= 5;
-                r13 |= r4;      /* check clipping */
-                r4 &= 0xFF00FF; /* mask */
-
-                r5 = p_ref[4];  /* i */
-                r6 = (r5 << 16);
-                r5 = r6 | (r2 >> 16);/* 0,i,0,g */
-                r5 += r1;       /* d+i, b+g */ /* r5 not free */
-                r1 >>= 16;
-                r1 |= (r3 << 16); /* 0,f,0,d */ /* r1 has changed */
-                r1 += r2;       /* f+g, d+e */
-                r5 += 20 * r1;  /* d+20f+20g+i, b+20d+20e+g */
-                r0 >>= 16;
-                r0 |= (r2 << 16); /* 0,e,0,c */ /* r0 has changed */
-                r0 += r3;       /* e+h, c+f */
-                r5 += 0x100010; /* 16,16 */
-                r5 -= r0 * 5;       /* d-5e+20f+20g-5h+i, b-5c+20d+20e-5f+g */
-                r5 >>= 5;
-                r13 |= r5;      /* check clipping */
-                r5 &= 0xFF00FF; /* mask */
-
-                r4 |= (r5 << 8);    /* pack them together */
-                *p_cur++ = r4;
-                r1 = r3;
-                r0 = r2;
-            }
-            p_cur += curr_offset; /* move to the next line */
-            p_ref += ref_offset;  /*    ref_offset = inpitch-blkwidth; */
-
-            if (r13&0xFF000700) /* need clipping */
-            {
-                /* move back to the beginning of the line */
-                p_ref -= (ref_offset + blkwidth);   /* input */
-                p_cur -= (outpitch >> 2);
-
-                tmp = p_ref + blkwidth;
-                for (; p_ref < tmp;)
-                {
-
-                    r0 = *p_ref++;
-                    r1 = *p_ref++;
-                    r2 = *p_ref++;
-                    r3 = *p_ref++;
-                    r4 = *p_ref++;
-                    /* first pixel */
-                    r5 = *p_ref++;
-                    result = (r0 + r5);
-                    r0 = (r1 + r4);
-                    result -= (r0 * 5);//result -= r0;  result -= (r0<<2);
-                    r0 = (r2 + r3);
-                    result += (r0 * 20);//result += (r0<<4);    result += (r0<<2);
-                    result = (result + 16) >> 5;
-                    CLIP_RESULT(result)
-                    pkres  = result;
-                    /* second pixel */
-                    r0 = *p_ref++;
-                    result = (r1 + r0);
-                    r1 = (r2 + r5);
-                    result -= (r1 * 5);//result -= r1;  result -= (r1<<2);
-                    r1 = (r3 + r4);
-                    result += (r1 * 20);//result += (r1<<4);    result += (r1<<2);
-                    result = (result + 16) >> 5;
-                    CLIP_RESULT(result)
-                    pkres  |= (result << 8);
-                    /* third pixel */
-                    r1 = *p_ref++;
-                    result = (r2 + r1);
-                    r2 = (r3 + r0);
-                    result -= (r2 * 5);//result -= r2;  result -= (r2<<2);
-                    r2 = (r4 + r5);
-                    result += (r2 * 20);//result += (r2<<4);    result += (r2<<2);
-                    result = (result + 16) >> 5;
-                    CLIP_RESULT(result)
-                    pkres  |= (result << 16);
-                    /* fourth pixel */
-                    r2 = *p_ref++;
-                    result = (r3 + r2);
-                    r3 = (r4 + r1);
-                    result -= (r3 * 5);//result -= r3;  result -= (r3<<2);
-                    r3 = (r5 + r0);
-                    result += (r3 * 20);//result += (r3<<4);    result += (r3<<2);
-                    result = (result + 16) >> 5;
-                    CLIP_RESULT(result)
-                    pkres  |= (result << 24);
-                    *p_cur++ = pkres;   /* write 4 pixels */
-                    p_ref -= 5;
-                }
-                p_cur += curr_offset; /* move to the next line */
-                p_ref += ref_offset;
-            }
-        }
-    }
-
-    return ;
-}
-
-void eHorzInterp2MC(int *in, int inpitch, uint8 *out, int outpitch,
-                    int blkwidth, int blkheight, int dx)
-{
-    int *p_ref, *tmp;
-    uint32 *p_cur;
-    uint32 pkres;
-    int result, result2, curr_offset, ref_offset;
-    int j, r0, r1, r2, r3, r4, r5;
-
-    p_cur = (uint32*)out; /* assume it's word aligned */
-    curr_offset = (outpitch - blkwidth) >> 2;
-    p_ref = in;
-    ref_offset = inpitch - blkwidth;
-
-    if (dx&1)
-    {
-        dx = ((dx >> 1) ? -3 : -4); /* use in 3/4 pel */
-
-        for (j = blkheight; j > 0 ; j--)
-        {
-            tmp = p_ref + blkwidth;
-            for (; p_ref < tmp;)
-            {
-
-                r0 = p_ref[-2];
-                r1 = p_ref[-1];
-                r2 = *p_ref++;
-                r3 = *p_ref++;
-                r4 = *p_ref++;
-                /* first pixel */
-                r5 = *p_ref++;
-                result = (r0 + r5);
-                r0 = (r1 + r4);
-                result -= (r0 * 5);//result -= r0;  result -= (r0<<2);
-                r0 = (r2 + r3);
-                result += (r0 * 20);//result += (r0<<4);    result += (r0<<2);
-                result = (result + 512) >> 10;
-                CLIP_RESULT(result)
-                result2 = ((p_ref[dx] + 16) >> 5);
-                CLIP_RESULT(result2)
-                /* 3/4 pel,  no need to clip */
-                result = (result + result2 + 1);
-                pkres = (result >> 1);
-                /* second pixel */
-                r0 = *p_ref++;
-                result = (r1 + r0);
-                r1 = (r2 + r5);
-                result -= (r1 * 5);//result -= r1;  result -= (r1<<2);
-                r1 = (r3 + r4);
-                result += (r1 * 20);//result += (r1<<4);    result += (r1<<2);
-                result = (result + 512) >> 10;
-                CLIP_RESULT(result)
-                result2 = ((p_ref[dx] + 16) >> 5);
-                CLIP_RESULT(result2)
-                /* 3/4 pel,  no need to clip */
-                result = (result + result2 + 1);
-                result = (result >> 1);
-                pkres  |= (result << 8);
-                /* third pixel */
-                r1 = *p_ref++;
-                result = (r2 + r1);
-                r2 = (r3 + r0);
-                result -= (r2 * 5);//result -= r2;  result -= (r2<<2);
-                r2 = (r4 + r5);
-                result += (r2 * 20);//result += (r2<<4);    result += (r2<<2);
-                result = (result + 512) >> 10;
-                CLIP_RESULT(result)
-                result2 = ((p_ref[dx] + 16) >> 5);
-                CLIP_RESULT(result2)
-                /* 3/4 pel,  no need to clip */
-                result = (result + result2 + 1);
-                result = (result >> 1);
-                pkres  |= (result << 16);
-                /* fourth pixel */
-                r2 = *p_ref++;
-                result = (r3 + r2);
-                r3 = (r4 + r1);
-                result -= (r3 * 5);//result -= r3;  result -= (r3<<2);
-                r3 = (r5 + r0);
-                result += (r3 * 20);//result += (r3<<4);    result += (r3<<2);
-                result = (result + 512) >> 10;
-                CLIP_RESULT(result)
-                result2 = ((p_ref[dx] + 16) >> 5);
-                CLIP_RESULT(result2)
-                /* 3/4 pel,  no need to clip */
-                result = (result + result2 + 1);
-                result = (result >> 1);
-                pkres  |= (result << 24);
-                *p_cur++ = pkres; /* write 4 pixels */
-                p_ref -= 3;  /* offset back to the middle of filter */
-            }
-            p_cur += curr_offset;  /* move to the next line */
-            p_ref += ref_offset;    /* move to the next line */
-        }
-    }
-    else
-    {
-        for (j = blkheight; j > 0 ; j--)
-        {
-            tmp = p_ref + blkwidth;
-            for (; p_ref < tmp;)
-            {
-
-                r0 = p_ref[-2];
-                r1 = p_ref[-1];
-                r2 = *p_ref++;
-                r3 = *p_ref++;
-                r4 = *p_ref++;
-                /* first pixel */
-                r5 = *p_ref++;
-                result = (r0 + r5);
-                r0 = (r1 + r4);
-                result -= (r0 * 5);//result -= r0;  result -= (r0<<2);
-                r0 = (r2 + r3);
-                result += (r0 * 20);//result += (r0<<4);    result += (r0<<2);
-                result = (result + 512) >> 10;
-                CLIP_RESULT(result)
-                pkres  = result;
-                /* second pixel */
-                r0 = *p_ref++;
-                result = (r1 + r0);
-                r1 = (r2 + r5);
-                result -= (r1 * 5);//result -= r1;  result -= (r1<<2);
-                r1 = (r3 + r4);
-                result += (r1 * 20);//result += (r1<<4);    result += (r1<<2);
-                result = (result + 512) >> 10;
-                CLIP_RESULT(result)
-                pkres  |= (result << 8);
-                /* third pixel */
-                r1 = *p_ref++;
-                result = (r2 + r1);
-                r2 = (r3 + r0);
-                result -= (r2 * 5);//result -= r2;  result -= (r2<<2);
-                r2 = (r4 + r5);
-                result += (r2 * 20);//result += (r2<<4);    result += (r2<<2);
-                result = (result + 512) >> 10;
-                CLIP_RESULT(result)
-                pkres  |= (result << 16);
-                /* fourth pixel */
-                r2 = *p_ref++;
-                result = (r3 + r2);
-                r3 = (r4 + r1);
-                result -= (r3 * 5);//result -= r3;  result -= (r3<<2);
-                r3 = (r5 + r0);
-                result += (r3 * 20);//result += (r3<<4);    result += (r3<<2);
-                result = (result + 512) >> 10;
-                CLIP_RESULT(result)
-                pkres  |= (result << 24);
-                *p_cur++ = pkres; /* write 4 pixels */
-                p_ref -= 3;  /* offset back to the middle of filter */
-            }
-            p_cur += curr_offset;  /* move to the next line */
-            p_ref += ref_offset;    /* move to the next line */
-        }
-    }
-
-    return ;
-}
-
-void eHorzInterp3MC(uint8 *in, int inpitch, int *out, int outpitch,
-                    int blkwidth, int blkheight)
-{
-    uint8 *p_ref, *tmp;
-    int   *p_cur;
-    int result, curr_offset, ref_offset;
-    int j, r0, r1, r2, r3, r4, r5;
-
-    p_cur = out;
-    curr_offset = (outpitch - blkwidth);
-    p_ref = in;
-    ref_offset = inpitch - blkwidth;
-
-    for (j = blkheight; j > 0 ; j--)
-    {
-        tmp = p_ref + blkwidth;
-        for (; p_ref < tmp;)
-        {
-
-            r0 = p_ref[-2];
-            r1 = p_ref[-1];
-            r2 = *p_ref++;
-            r3 = *p_ref++;
-            r4 = *p_ref++;
-            /* first pixel */
-            r5 = *p_ref++;
-            result = (r0 + r5);
-            r0 = (r1 + r4);
-            result -= (r0 * 5);//result -= r0;  result -= (r0<<2);
-            r0 = (r2 + r3);
-            result += (r0 * 20);//result += (r0<<4);    result += (r0<<2);
-            *p_cur++ = result;
-            /* second pixel */
-            r0 = *p_ref++;
-            result = (r1 + r0);
-            r1 = (r2 + r5);
-            result -= (r1 * 5);//result -= r1;  result -= (r1<<2);
-            r1 = (r3 + r4);
-            result += (r1 * 20);//result += (r1<<4);    result += (r1<<2);
-            *p_cur++ = result;
-            /* third pixel */
-            r1 = *p_ref++;
-            result = (r2 + r1);
-            r2 = (r3 + r0);
-            result -= (r2 * 5);//result -= r2;  result -= (r2<<2);
-            r2 = (r4 + r5);
-            result += (r2 * 20);//result += (r2<<4);    result += (r2<<2);
-            *p_cur++ = result;
-            /* fourth pixel */
-            r2 = *p_ref++;
-            result = (r3 + r2);
-            r3 = (r4 + r1);
-            result -= (r3 * 5);//result -= r3;  result -= (r3<<2);
-            r3 = (r5 + r0);
-            result += (r3 * 20);//result += (r3<<4);    result += (r3<<2);
-            *p_cur++ = result;
-            p_ref -= 3; /* move back to the middle of the filter */
-        }
-        p_cur += curr_offset; /* move to the next line */
-        p_ref += ref_offset;
-    }
-
-    return ;
-}
-void eVertInterp1MC(uint8 *in, int inpitch, uint8 *out, int outpitch,
-                    int blkwidth, int blkheight, int dy)
-{
-    uint8 *p_cur, *p_ref, *tmp;
-    int result, curr_offset, ref_offset;
-    int j, i;
-    int32 r0, r1, r2, r3, r4, r5, r6, r7, r8, r13;
-    uint8  tmp_in[24][24];
-
-    /* not word-aligned */
-    if (((intptr_t)in)&0x3)
-    {
-        eCreateAlign(in, inpitch, -2, &tmp_in[0][0], blkwidth, blkheight + 5);
-        in = &tmp_in[2][0];
-        inpitch = 24;
-    }
-    p_cur = out;
-    curr_offset = 1 - outpitch * (blkheight - 1); /* offset vertically back up and one pixel to right */
-    ref_offset = blkheight * inpitch; /* for limit */
-
-    curr_offset += 3;
-
-    if (dy&1)
-    {
-        dy = (dy >> 1) ? 0 : -inpitch;
-
-        for (j = 0; j < blkwidth; j += 4, in += 4)
-        {
-            r13 = 0;
-            p_ref = in;
-            p_cur -= outpitch;  /* compensate for the first offset */
-            tmp = p_ref + ref_offset; /* limit */
-            while (p_ref < tmp)  /* the loop un-rolled  */
-            {
-                r0 = *((uint32*)(p_ref - (inpitch << 1))); /* load 4 bytes */
-                p_ref += inpitch;
-                r6 = (r0 >> 8) & 0xFF00FF; /* second and fourth byte */
-                r0 &= 0xFF00FF;
-
-                r1 = *((uint32*)(p_ref + (inpitch << 1)));  /* r1, r7, ref[3] */
-                r7 = (r1 >> 8) & 0xFF00FF;
-                r1 &= 0xFF00FF;
-
-                r0 += r1;
-                r6 += r7;
-
-                r2 = *((uint32*)p_ref); /* r2, r8, ref[1] */
-                r8 = (r2 >> 8) & 0xFF00FF;
-                r2 &= 0xFF00FF;
-
-                r1 = *((uint32*)(p_ref - inpitch)); /* r1, r7, ref[0] */
-                r7 = (r1 >> 8) & 0xFF00FF;
-                r1 &= 0xFF00FF;
-                r1 += r2;
-
-                r7 += r8;
-
-                r0 += 20 * r1;
-                r6 += 20 * r7;
-                r0 += 0x100010;
-                r6 += 0x100010;
-
-                r2 = *((uint32*)(p_ref - (inpitch << 1))); /* r2, r8, ref[-1] */
-                r8 = (r2 >> 8) & 0xFF00FF;
-                r2 &= 0xFF00FF;
-
-                r1 = *((uint32*)(p_ref + inpitch)); /* r1, r7, ref[2] */
-                r7 = (r1 >> 8) & 0xFF00FF;
-                r1 &= 0xFF00FF;
-                r1 += r2;
-
-                r7 += r8;
-
-                r0 -= 5 * r1;
-                r6 -= 5 * r7;
-
-                r0 >>= 5;
-                r6 >>= 5;
-                /* clip */
-                r13 |= r6;
-                r13 |= r0;
-                //CLIPPACK(r6,result)
-
-                r1 = *((uint32*)(p_ref + dy));
-                r2 = (r1 >> 8) & 0xFF00FF;
-                r1 &= 0xFF00FF;
-                r0 += r1;
-                r6 += r2;
-                r0 += 0x10001;
-                r6 += 0x10001;
-                r0 = (r0 >> 1) & 0xFF00FF;
-                r6 = (r6 >> 1) & 0xFF00FF;
-
-                r0 |= (r6 << 8);  /* pack it back */
-                *((uint32*)(p_cur += outpitch)) = r0;
-            }
-            p_cur += curr_offset; /* offset to the next pixel */
-            if (r13 & 0xFF000700) /* this column need clipping */
-            {
-                p_cur -= 4;
-                for (i = 0; i < 4; i++)
-                {
-                    p_ref = in + i;
-                    p_cur -= outpitch;  /* compensate for the first offset */
-
-                    tmp = p_ref + ref_offset; /* limit */
-                    while (p_ref < tmp)
-                    {                           /* loop un-rolled */
-                        r0 = *(p_ref - (inpitch << 1));
-                        r1 = *(p_ref - inpitch);
-                        r2 = *p_ref;
-                        r3 = *(p_ref += inpitch);  /* modify pointer before loading */
-                        r4 = *(p_ref += inpitch);
-                        /* first pixel */
-                        r5 = *(p_ref += inpitch);
-                        result = (r0 + r5);
-                        r0 = (r1 + r4);
-                        result -= (r0 * 5);//result -= r0;  result -= (r0<<2);
-                        r0 = (r2 + r3);
-                        result += (r0 * 20);//result += (r0<<4);    result += (r0<<2);
-                        result = (result + 16) >> 5;
-                        CLIP_RESULT(result)
-                        /* 3/4 pel,  no need to clip */
-                        result = (result + p_ref[dy-(inpitch<<1)] + 1);
-                        result = (result >> 1);
-                        *(p_cur += outpitch) = result;
-                        /* second pixel */
-                        r0 = *(p_ref += inpitch);
-                        result = (r1 + r0);
-                        r1 = (r2 + r5);
-                        result -= (r1 * 5);//result -= r1;  result -= (r1<<2);
-                        r1 = (r3 + r4);
-                        result += (r1 * 20);//result += (r1<<4);    result += (r1<<2);
-                        result = (result + 16) >> 5;
-                        CLIP_RESULT(result)
-                        /* 3/4 pel,  no need to clip */
-                        result = (result + p_ref[dy-(inpitch<<1)] + 1);
-                        result = (result >> 1);
-                        *(p_cur += outpitch) = result;
-                        /* third pixel */
-                        r1 = *(p_ref += inpitch);
-                        result = (r2 + r1);
-                        r2 = (r3 + r0);
-                        result -= (r2 * 5);//result -= r2;  result -= (r2<<2);
-                        r2 = (r4 + r5);
-                        result += (r2 * 20);//result += (r2<<4);    result += (r2<<2);
-                        result = (result + 16) >> 5;
-                        CLIP_RESULT(result)
-                        /* 3/4 pel,  no need to clip */
-                        result = (result + p_ref[dy-(inpitch<<1)] + 1);
-                        result = (result >> 1);
-                        *(p_cur += outpitch) = result;
-                        /* fourth pixel */
-                        r2 = *(p_ref += inpitch);
-                        result = (r3 + r2);
-                        r3 = (r4 + r1);
-                        result -= (r3 * 5);//result -= r3;  result -= (r3<<2);
-                        r3 = (r5 + r0);
-                        result += (r3 * 20);//result += (r3<<4);    result += (r3<<2);
-                        result = (result + 16) >> 5;
-                        CLIP_RESULT(result)
-                        /* 3/4 pel,  no need to clip */
-                        result = (result + p_ref[dy-(inpitch<<1)] + 1);
-                        result = (result >> 1);
-                        *(p_cur += outpitch) = result;
-                        p_ref -= (inpitch << 1);  /* move back to center of the filter of the next one */
-                    }
-                    p_cur += (curr_offset - 3);
-                }
-            }
-        }
-    }
-    else
-    {
-        for (j = 0; j < blkwidth; j += 4, in += 4)
-        {
-            r13 = 0;
-            p_ref = in;
-            p_cur -= outpitch;  /* compensate for the first offset */
-            tmp = p_ref + ref_offset; /* limit */
-            while (p_ref < tmp)  /* the loop un-rolled  */
-            {
-                r0 = *((uint32*)(p_ref - (inpitch << 1))); /* load 4 bytes */
-                p_ref += inpitch;
-                r6 = (r0 >> 8) & 0xFF00FF; /* second and fourth byte */
-                r0 &= 0xFF00FF;
-
-                r1 = *((uint32*)(p_ref + (inpitch << 1)));  /* r1, r7, ref[3] */
-                r7 = (r1 >> 8) & 0xFF00FF;
-                r1 &= 0xFF00FF;
-
-                r0 += r1;
-                r6 += r7;
-
-                r2 = *((uint32*)p_ref); /* r2, r8, ref[1] */
-                r8 = (r2 >> 8) & 0xFF00FF;
-                r2 &= 0xFF00FF;
-
-                r1 = *((uint32*)(p_ref - inpitch)); /* r1, r7, ref[0] */
-                r7 = (r1 >> 8) & 0xFF00FF;
-                r1 &= 0xFF00FF;
-                r1 += r2;
-
-                r7 += r8;
-
-                r0 += 20 * r1;
-                r6 += 20 * r7;
-                r0 += 0x100010;
-                r6 += 0x100010;
-
-                r2 = *((uint32*)(p_ref - (inpitch << 1))); /* r2, r8, ref[-1] */
-                r8 = (r2 >> 8) & 0xFF00FF;
-                r2 &= 0xFF00FF;
-
-                r1 = *((uint32*)(p_ref + inpitch)); /* r1, r7, ref[2] */
-                r7 = (r1 >> 8) & 0xFF00FF;
-                r1 &= 0xFF00FF;
-                r1 += r2;
-
-                r7 += r8;
-
-                r0 -= 5 * r1;
-                r6 -= 5 * r7;
-
-                r0 >>= 5;
-                r6 >>= 5;
-                /* clip */
-                r13 |= r6;
-                r13 |= r0;
-                //CLIPPACK(r6,result)
-                r0 &= 0xFF00FF;
-                r6 &= 0xFF00FF;
-                r0 |= (r6 << 8);  /* pack it back */
-                *((uint32*)(p_cur += outpitch)) = r0;
-            }
-            p_cur += curr_offset; /* offset to the next pixel */
-            if (r13 & 0xFF000700) /* this column need clipping */
-            {
-                p_cur -= 4;
-                for (i = 0; i < 4; i++)
-                {
-                    p_ref = in + i;
-                    p_cur -= outpitch;  /* compensate for the first offset */
-                    tmp = p_ref + ref_offset; /* limit */
-                    while (p_ref < tmp)
-                    {                           /* loop un-rolled */
-                        r0 = *(p_ref - (inpitch << 1));
-                        r1 = *(p_ref - inpitch);
-                        r2 = *p_ref;
-                        r3 = *(p_ref += inpitch);  /* modify pointer before loading */
-                        r4 = *(p_ref += inpitch);
-                        /* first pixel */
-                        r5 = *(p_ref += inpitch);
-                        result = (r0 + r5);
-                        r0 = (r1 + r4);
-                        result -= (r0 * 5);//result -= r0;  result -= (r0<<2);
-                        r0 = (r2 + r3);
-                        result += (r0 * 20);//result += (r0<<4);    result += (r0<<2);
-                        result = (result + 16) >> 5;
-                        CLIP_RESULT(result)
-                        *(p_cur += outpitch) = result;
-                        /* second pixel */
-                        r0 = *(p_ref += inpitch);
-                        result = (r1 + r0);
-                        r1 = (r2 + r5);
-                        result -= (r1 * 5);//result -= r1;  result -= (r1<<2);
-                        r1 = (r3 + r4);
-                        result += (r1 * 20);//result += (r1<<4);    result += (r1<<2);
-                        result = (result + 16) >> 5;
-                        CLIP_RESULT(result)
-                        *(p_cur += outpitch) = result;
-                        /* third pixel */
-                        r1 = *(p_ref += inpitch);
-                        result = (r2 + r1);
-                        r2 = (r3 + r0);
-                        result -= (r2 * 5);//result -= r2;  result -= (r2<<2);
-                        r2 = (r4 + r5);
-                        result += (r2 * 20);//result += (r2<<4);    result += (r2<<2);
-                        result = (result + 16) >> 5;
-                        CLIP_RESULT(result)
-                        *(p_cur += outpitch) = result;
-                        /* fourth pixel */
-                        r2 = *(p_ref += inpitch);
-                        result = (r3 + r2);
-                        r3 = (r4 + r1);
-                        result -= (r3 * 5);//result -= r3;  result -= (r3<<2);
-                        r3 = (r5 + r0);
-                        result += (r3 * 20);//result += (r3<<4);    result += (r3<<2);
-                        result = (result + 16) >> 5;
-                        CLIP_RESULT(result)
-                        *(p_cur += outpitch) = result;
-                        p_ref -= (inpitch << 1);  /* move back to center of the filter of the next one */
-                    }
-                    p_cur += (curr_offset - 3);
-                }
-            }
-        }
-    }
-
-    return ;
-}
-
-void eVertInterp2MC(uint8 *in, int inpitch, int *out, int outpitch,
-                    int blkwidth, int blkheight)
-{
-    int *p_cur;
-    uint8 *p_ref, *tmp;
-    int result, curr_offset, ref_offset;
-    int j, r0, r1, r2, r3, r4, r5;
-
-    p_cur = out;
-    curr_offset = 1 - outpitch * (blkheight - 1); /* offset vertically back up and one pixel to right */
-    ref_offset = blkheight * inpitch; /* for limit */
-
-    for (j = 0; j < blkwidth; j++)
-    {
-        p_cur -= outpitch; /* compensate for the first offset */
-        p_ref = in++;
-
-        tmp = p_ref + ref_offset; /* limit */
-        while (p_ref < tmp)
-        {                           /* loop un-rolled */
-            r0 = *(p_ref - (inpitch << 1));
-            r1 = *(p_ref - inpitch);
-            r2 = *p_ref;
-            r3 = *(p_ref += inpitch);  /* modify pointer before loading */
-            r4 = *(p_ref += inpitch);
-            /* first pixel */
-            r5 = *(p_ref += inpitch);
-            result = (r0 + r5);
-            r0 = (r1 + r4);
-            result -= (r0 * 5);//result -= r0;  result -= (r0<<2);
-            r0 = (r2 + r3);
-            result += (r0 * 20);//result += (r0<<4);    result += (r0<<2);
-            *(p_cur += outpitch) = result;
-            /* second pixel */
-            r0 = *(p_ref += inpitch);
-            result = (r1 + r0);
-            r1 = (r2 + r5);
-            result -= (r1 * 5);//result -= r1;  result -= (r1<<2);
-            r1 = (r3 + r4);
-            result += (r1 * 20);//result += (r1<<4);    result += (r1<<2);
-            *(p_cur += outpitch) = result;
-            /* third pixel */
-            r1 = *(p_ref += inpitch);
-            result = (r2 + r1);
-            r2 = (r3 + r0);
-            result -= (r2 * 5);//result -= r2;  result -= (r2<<2);
-            r2 = (r4 + r5);
-            result += (r2 * 20);//result += (r2<<4);    result += (r2<<2);
-            *(p_cur += outpitch) = result;
-            /* fourth pixel */
-            r2 = *(p_ref += inpitch);
-            result = (r3 + r2);
-            r3 = (r4 + r1);
-            result -= (r3 * 5);//result -= r3;  result -= (r3<<2);
-            r3 = (r5 + r0);
-            result += (r3 * 20);//result += (r3<<4);    result += (r3<<2);
-            *(p_cur += outpitch) = result;
-            p_ref -= (inpitch << 1);  /* move back to center of the filter of the next one */
-        }
-        p_cur += curr_offset;
-    }
-
-    return ;
-}
-
-void eVertInterp3MC(int *in, int inpitch, uint8 *out, int outpitch,
-                    int blkwidth, int blkheight, int dy)
-{
-    uint8 *p_cur;
-    int *p_ref, *tmp;
-    int result, result2, curr_offset, ref_offset;
-    int j, r0, r1, r2, r3, r4, r5;
-
-    p_cur = out;
-    curr_offset = 1 - outpitch * (blkheight - 1); /* offset vertically back up and one pixel to right */
-    ref_offset = blkheight * inpitch; /* for limit */
-
-    if (dy&1)
-    {
-        dy = (dy >> 1) ? -(inpitch << 1) : -(inpitch << 1) - inpitch;
-
-        for (j = 0; j < blkwidth; j++)
-        {
-            p_cur -= outpitch; /* compensate for the first offset */
-            p_ref = in++;
-
-            tmp = p_ref + ref_offset; /* limit */
-            while (p_ref < tmp)
-            {                           /* loop un-rolled */
-                r0 = *(p_ref - (inpitch << 1));
-                r1 = *(p_ref - inpitch);
-                r2 = *p_ref;
-                r3 = *(p_ref += inpitch);  /* modify pointer before loading */
-                r4 = *(p_ref += inpitch);
-                /* first pixel */
-                r5 = *(p_ref += inpitch);
-                result = (r0 + r5);
-                r0 = (r1 + r4);
-                result -= (r0 * 5);//result -= r0;  result -= (r0<<2);
-                r0 = (r2 + r3);
-                result += (r0 * 20);//result += (r0<<4);    result += (r0<<2);
-                result = (result + 512) >> 10;
-                CLIP_RESULT(result)
-                result2 = ((p_ref[dy] + 16) >> 5);
-                CLIP_RESULT(result2)
-                /* 3/4 pel,  no need to clip */
-                result = (result + result2 + 1);
-                result = (result >> 1);
-                *(p_cur += outpitch) = result;
-                /* second pixel */
-                r0 = *(p_ref += inpitch);
-                result = (r1 + r0);
-                r1 = (r2 + r5);
-                result -= (r1 * 5);//result -= r1;  result -= (r1<<2);
-                r1 = (r3 + r4);
-                result += (r1 * 20);//result += (r1<<4);    result += (r1<<2);
-                result = (result + 512) >> 10;
-                CLIP_RESULT(result)
-                result2 = ((p_ref[dy] + 16) >> 5);
-                CLIP_RESULT(result2)
-                /* 3/4 pel,  no need to clip */
-                result = (result + result2 + 1);
-                result = (result >> 1);
-                *(p_cur += outpitch) = result;
-                /* third pixel */
-                r1 = *(p_ref += inpitch);
-                result = (r2 + r1);
-                r2 = (r3 + r0);
-                result -= (r2 * 5);//result -= r2;  result -= (r2<<2);
-                r2 = (r4 + r5);
-                result += (r2 * 20);//result += (r2<<4);    result += (r2<<2);
-                result = (result + 512) >> 10;
-                CLIP_RESULT(result)
-                result2 = ((p_ref[dy] + 16) >> 5);
-                CLIP_RESULT(result2)
-                /* 3/4 pel,  no need to clip */
-                result = (result + result2 + 1);
-                result = (result >> 1);
-                *(p_cur += outpitch) = result;
-                /* fourth pixel */
-                r2 = *(p_ref += inpitch);
-                result = (r3 + r2);
-                r3 = (r4 + r1);
-                result -= (r3 * 5);//result -= r3;  result -= (r3<<2);
-                r3 = (r5 + r0);
-                result += (r3 * 20);//result += (r3<<4);    result += (r3<<2);
-                result = (result + 512) >> 10;
-                CLIP_RESULT(result)
-                result2 = ((p_ref[dy] + 16) >> 5);
-                CLIP_RESULT(result2)
-                /* 3/4 pel,  no need to clip */
-                result = (result + result2 + 1);
-                result = (result >> 1);
-                *(p_cur += outpitch) = result;
-                p_ref -= (inpitch << 1);  /* move back to center of the filter of the next one */
-            }
-            p_cur += curr_offset;
-        }
-    }
-    else
-    {
-        for (j = 0; j < blkwidth; j++)
-        {
-            p_cur -= outpitch; /* compensate for the first offset */
-            p_ref = in++;
-
-            tmp = p_ref + ref_offset; /* limit */
-            while (p_ref < tmp)
-            {                           /* loop un-rolled */
-                r0 = *(p_ref - (inpitch << 1));
-                r1 = *(p_ref - inpitch);
-                r2 = *p_ref;
-                r3 = *(p_ref += inpitch);  /* modify pointer before loading */
-                r4 = *(p_ref += inpitch);
-                /* first pixel */
-                r5 = *(p_ref += inpitch);
-                result = (r0 + r5);
-                r0 = (r1 + r4);
-                result -= (r0 * 5);//result -= r0;  result -= (r0<<2);
-                r0 = (r2 + r3);
-                result += (r0 * 20);//result += (r0<<4);    result += (r0<<2);
-                result = (result + 512) >> 10;
-                CLIP_RESULT(result)
-                *(p_cur += outpitch) = result;
-                /* second pixel */
-                r0 = *(p_ref += inpitch);
-                result = (r1 + r0);
-                r1 = (r2 + r5);
-                result -= (r1 * 5);//result -= r1;  result -= (r1<<2);
-                r1 = (r3 + r4);
-                result += (r1 * 20);//result += (r1<<4);    result += (r1<<2);
-                result = (result + 512) >> 10;
-                CLIP_RESULT(result)
-                *(p_cur += outpitch) = result;
-                /* third pixel */
-                r1 = *(p_ref += inpitch);
-                result = (r2 + r1);
-                r2 = (r3 + r0);
-                result -= (r2 * 5);//result -= r2;  result -= (r2<<2);
-                r2 = (r4 + r5);
-                result += (r2 * 20);//result += (r2<<4);    result += (r2<<2);
-                result = (result + 512) >> 10;
-                CLIP_RESULT(result)
-                *(p_cur += outpitch) = result;
-                /* fourth pixel */
-                r2 = *(p_ref += inpitch);
-                result = (r3 + r2);
-                r3 = (r4 + r1);
-                result -= (r3 * 5);//result -= r3;  result -= (r3<<2);
-                r3 = (r5 + r0);
-                result += (r3 * 20);//result += (r3<<4);    result += (r3<<2);
-                result = (result + 512) >> 10;
-                CLIP_RESULT(result)
-                *(p_cur += outpitch) = result;
-                p_ref -= (inpitch << 1);  /* move back to center of the filter of the next one */
-            }
-            p_cur += curr_offset;
-        }
-    }
-
-    return ;
-}
-
-void eDiagonalInterpMC(uint8 *in1, uint8 *in2, int inpitch,
-                       uint8 *out, int outpitch,
-                       int blkwidth, int blkheight)
-{
-    int j, i;
-    int result;
-    uint8 *p_cur, *p_ref, *p_tmp8, *tmp;
-    int curr_offset, ref_offset;
-    uint8 tmp_res[24][24], tmp_in[24][24];
-    uint32 *p_tmp;
-    uint32 pkres, tmp_result;
-    int32 r0, r1, r2, r3, r4, r5;
-    int32 r6, r7, r8, r9, r10, r13;
-
-    ref_offset = inpitch - blkwidth;
-    p_ref = in1 - 2;
-    /* perform horizontal interpolation */
-    /* not word-aligned */
-    /* It is faster to read 1 byte at time to avoid calling CreateAlign */
-    /*  if(((uint32)p_ref)&0x3)
-        {
-            CreateAlign(p_ref,inpitch,0,&tmp_in[0][0],blkwidth+8,blkheight);
-            p_ref = &tmp_in[0][0];
-            ref_offset = 24-blkwidth;
-        }*/
-
-    p_tmp = (uint32*) & (tmp_res[0][0]);
-    for (j = blkheight; j > 0; j--)
-    {
-        r13 = 0;
-        tmp = p_ref + blkwidth;
-
-        //r0 = *((uint32*)p_ref);   /* d,c,b,a */
-        //r1 = (r0>>8)&0xFF00FF;    /* 0,d,0,b */
-        //r0 &= 0xFF00FF;           /* 0,c,0,a */
-        /* It is faster to read 1 byte at a time */
-        r0 = p_ref[0];
-        r1 = p_ref[2];
-        r0 |= (r1 << 16);           /* 0,c,0,a */
-        r1 = p_ref[1];
-        r2 = p_ref[3];
-        r1 |= (r2 << 16);           /* 0,d,0,b */
-
-        while (p_ref < tmp)
-        {
-            //r2 = *((uint32*)(p_ref+=4));/* h,g,f,e */
-            //r3 = (r2>>8)&0xFF00FF;  /* 0,h,0,f */
-            //r2 &= 0xFF00FF;           /* 0,g,0,e */
-            /* It is faster to read 1 byte at a time */
-            r2 = *(p_ref += 4);
-            r3 = p_ref[2];
-            r2 |= (r3 << 16);           /* 0,g,0,e */
-            r3 = p_ref[1];
-            r4 = p_ref[3];
-            r3 |= (r4 << 16);           /* 0,h,0,f */
-
-            r4 = r0 + r3;       /* c+h, a+f */
-            r5 = r0 + r1;   /* c+d, a+b */
-            r6 = r2 + r3;   /* g+h, e+f */
-            r5 >>= 16;
-            r5 |= (r6 << 16);   /* e+f, c+d */
-            r4 += r5 * 20;      /* c+20*e+20*f+h, a+20*c+20*d+f */
-            r4 += 0x100010; /* +16, +16 */
-            r5 = r1 + r2;       /* d+g, b+e */
-            r4 -= r5 * 5;       /* c-5*d+20*e+20*f-5*g+h, a-5*b+20*c+20*d-5*e+f */
-            r4 >>= 5;
-            r13 |= r4;      /* check clipping */
-            r4 &= 0xFF00FF; /* mask */
-
-            r5 = p_ref[4];  /* i */
-            r6 = (r5 << 16);
-            r5 = r6 | (r2 >> 16);/* 0,i,0,g */
-            r5 += r1;       /* d+i, b+g */ /* r5 not free */
-            r1 >>= 16;
-            r1 |= (r3 << 16); /* 0,f,0,d */ /* r1 has changed */
-            r1 += r2;       /* f+g, d+e */
-            r5 += 20 * r1;  /* d+20f+20g+i, b+20d+20e+g */
-            r0 >>= 16;
-            r0 |= (r2 << 16); /* 0,e,0,c */ /* r0 has changed */
-            r0 += r3;       /* e+h, c+f */
-            r5 += 0x100010; /* 16,16 */
-            r5 -= r0 * 5;       /* d-5e+20f+20g-5h+i, b-5c+20d+20e-5f+g */
-            r5 >>= 5;
-            r13 |= r5;      /* check clipping */
-            r5 &= 0xFF00FF; /* mask */
-
-            r4 |= (r5 << 8);    /* pack them together */
-            *p_tmp++ = r4;
-            r1 = r3;
-            r0 = r2;
-        }
-        p_tmp += ((24 - blkwidth) >> 2); /* move to the next line */
-        p_ref += ref_offset;  /*    ref_offset = inpitch-blkwidth; */
-
-        if (r13&0xFF000700) /* need clipping */
-        {
-            /* move back to the beginning of the line */
-            p_ref -= (ref_offset + blkwidth);   /* input */
-            p_tmp -= 6; /* intermediate output */
-            tmp = p_ref + blkwidth;
-            while (p_ref < tmp)
-            {
-                r0 = *p_ref++;
-                r1 = *p_ref++;
-                r2 = *p_ref++;
-                r3 = *p_ref++;
-                r4 = *p_ref++;
-                /* first pixel */
-                r5 = *p_ref++;
-                result = (r0 + r5);
-                r0 = (r1 + r4);
-                result -= (r0 * 5);//result -= r0;  result -= (r0<<2);
-                r0 = (r2 + r3);
-                result += (r0 * 20);//result += (r0<<4);    result += (r0<<2);
-                result = (result + 16) >> 5;
-                CLIP_RESULT(result)
-                pkres = result;
-                /* second pixel */
-                r0 = *p_ref++;
-                result = (r1 + r0);
-                r1 = (r2 + r5);
-                result -= (r1 * 5);//result -= r1;  result -= (r1<<2);
-                r1 = (r3 + r4);
-                result += (r1 * 20);//result += (r1<<4);    result += (r1<<2);
-                result = (result + 16) >> 5;
-                CLIP_RESULT(result)
-                pkres |= (result << 8);
-                /* third pixel */
-                r1 = *p_ref++;
-                result = (r2 + r1);
-                r2 = (r3 + r0);
-                result -= (r2 * 5);//result -= r2;  result -= (r2<<2);
-                r2 = (r4 + r5);
-                result += (r2 * 20);//result += (r2<<4);    result += (r2<<2);
-                result = (result + 16) >> 5;
-                CLIP_RESULT(result)
-                pkres |= (result << 16);
-                /* fourth pixel */
-                r2 = *p_ref++;
-                result = (r3 + r2);
-                r3 = (r4 + r1);
-                result -= (r3 * 5);//result -= r3;  result -= (r3<<2);
-                r3 = (r5 + r0);
-                result += (r3 * 20);//result += (r3<<4);    result += (r3<<2);
-                result = (result + 16) >> 5;
-                CLIP_RESULT(result)
-                pkres |= (result << 24);
-
-                *p_tmp++ = pkres; /* write 4 pixel */
-                p_ref -= 5;
-            }
-            p_tmp += ((24 - blkwidth) >> 2); /* move to the next line */
-            p_ref += ref_offset;  /*    ref_offset = inpitch-blkwidth; */
-        }
-    }
-
-    /*  perform vertical interpolation */
-    /* not word-aligned */
-    if (((intptr_t)in2)&0x3)
-    {
-        eCreateAlign(in2, inpitch, -2, &tmp_in[0][0], blkwidth, blkheight + 5);
-        in2 = &tmp_in[2][0];
-        inpitch = 24;
-    }
-
-    p_cur = out;
-    curr_offset = 1 - outpitch * (blkheight - 1); /* offset vertically up and one pixel right */
-    pkres = blkheight * inpitch; /* reuse it for limit */
-
-    curr_offset += 3;
-
-    for (j = 0; j < blkwidth; j += 4, in2 += 4)
-    {
-        r13 = 0;
-        p_ref = in2;
-        p_tmp8 = &(tmp_res[0][j]); /* intermediate result */
-        p_tmp8 -= 24;  /* compensate for the first offset */
-        p_cur -= outpitch;  /* compensate for the first offset */
-        tmp = p_ref + pkres; /* limit */
-        while (p_ref < tmp)  /* the loop un-rolled  */
-        {
-            /* Read 1 byte at a time is too slow, too many read and pack ops, need to call CreateAlign */
-            /*p_ref8 = p_ref-(inpitch<<1);          r0 = p_ref8[0];         r1 = p_ref8[2];
-            r0 |= (r1<<16);         r6 = p_ref8[1];         r1 = p_ref8[3];
-            r6 |= (r1<<16);         p_ref+=inpitch; */
-            r0 = *((uint32*)(p_ref - (inpitch << 1))); /* load 4 bytes */
-            p_ref += inpitch;
-            r6 = (r0 >> 8) & 0xFF00FF; /* second and fourth byte */
-            r0 &= 0xFF00FF;
-
-            /*p_ref8 = p_ref+(inpitch<<1);
-            r1 = p_ref8[0];         r7 = p_ref8[2];         r1 |= (r7<<16);
-            r7 = p_ref8[1];         r2 = p_ref8[3];         r7 |= (r2<<16);*/
-            r1 = *((uint32*)(p_ref + (inpitch << 1)));  /* r1, r7, ref[3] */
-            r7 = (r1 >> 8) & 0xFF00FF;
-            r1 &= 0xFF00FF;
-
-            r0 += r1;
-            r6 += r7;
-
-            /*r2 = p_ref[0];            r8 = p_ref[2];          r2 |= (r8<<16);
-            r8 = p_ref[1];          r1 = p_ref[3];          r8 |= (r1<<16);*/
-            r2 = *((uint32*)p_ref); /* r2, r8, ref[1] */
-            r8 = (r2 >> 8) & 0xFF00FF;
-            r2 &= 0xFF00FF;
-
-            /*p_ref8 = p_ref-inpitch;           r1 = p_ref8[0];         r7 = p_ref8[2];
-            r1 |= (r7<<16);         r1 += r2;           r7 = p_ref8[1];
-            r2 = p_ref8[3];         r7 |= (r2<<16);*/
-            r1 = *((uint32*)(p_ref - inpitch)); /* r1, r7, ref[0] */
-            r7 = (r1 >> 8) & 0xFF00FF;
-            r1 &= 0xFF00FF;
-            r1 += r2;
-
-            r7 += r8;
-
-            r0 += 20 * r1;
-            r6 += 20 * r7;
-            r0 += 0x100010;
-            r6 += 0x100010;
-
-            /*p_ref8 = p_ref-(inpitch<<1);          r2 = p_ref8[0];         r8 = p_ref8[2];
-            r2 |= (r8<<16);         r8 = p_ref8[1];         r1 = p_ref8[3];         r8 |= (r1<<16);*/
-            r2 = *((uint32*)(p_ref - (inpitch << 1))); /* r2, r8, ref[-1] */
-            r8 = (r2 >> 8) & 0xFF00FF;
-            r2 &= 0xFF00FF;
-
-            /*p_ref8 = p_ref+inpitch;           r1 = p_ref8[0];         r7 = p_ref8[2];
-            r1 |= (r7<<16);         r1 += r2;           r7 = p_ref8[1];
-            r2 = p_ref8[3];         r7 |= (r2<<16);*/
-            r1 = *((uint32*)(p_ref + inpitch)); /* r1, r7, ref[2] */
-            r7 = (r1 >> 8) & 0xFF00FF;
-            r1 &= 0xFF00FF;
-            r1 += r2;
-
-            r7 += r8;
-
-            r0 -= 5 * r1;
-            r6 -= 5 * r7;
-
-            r0 >>= 5;
-            r6 >>= 5;
-            /* clip */
-            r13 |= r6;
-            r13 |= r0;
-            //CLIPPACK(r6,result)
-            /* add with horizontal results */
-            r10 = *((uint32*)(p_tmp8 += 24));
-            r9 = (r10 >> 8) & 0xFF00FF;
-            r10 &= 0xFF00FF;
-
-            r0 += r10;
-            r0 += 0x10001;
-            r0 = (r0 >> 1) & 0xFF00FF;   /* mask to 8 bytes */
-
-            r6 += r9;
-            r6 += 0x10001;
-            r6 = (r6 >> 1) & 0xFF00FF;   /* mask to 8 bytes */
-
-            r0 |= (r6 << 8);  /* pack it back */
-            *((uint32*)(p_cur += outpitch)) = r0;
-        }
-        p_cur += curr_offset; /* offset to the next pixel */
-        if (r13 & 0xFF000700) /* this column need clipping */
-        {
-            p_cur -= 4;
-            for (i = 0; i < 4; i++)
-            {
-                p_ref = in2 + i;
-                p_tmp8 = &(tmp_res[0][j+i]); /* intermediate result */
-                p_tmp8 -= 24;  /* compensate for the first offset */
-                p_cur -= outpitch;  /* compensate for the first offset */
-                tmp = p_ref + pkres; /* limit */
-                while (p_ref < tmp)  /* the loop un-rolled  */
-                {
-                    r0 = *(p_ref - (inpitch << 1));
-                    r1 = *(p_ref - inpitch);
-                    r2 = *p_ref;
-                    r3 = *(p_ref += inpitch);  /* modify pointer before loading */
-                    r4 = *(p_ref += inpitch);
-                    /* first pixel */
-                    r5 = *(p_ref += inpitch);
-                    result = (r0 + r5);
-                    r0 = (r1 + r4);
-                    result -= (r0 * 5);//result -= r0;  result -= (r0<<2);
-                    r0 = (r2 + r3);
-                    result += (r0 * 20);//result += (r0<<4);    result += (r0<<2);
-                    result = (result + 16) >> 5;
-                    CLIP_RESULT(result)
-                    tmp_result = *(p_tmp8 += 24);  /* modify pointer before loading */
-                    result = (result + tmp_result + 1);  /* no clip */
-                    result = (result >> 1);
-                    *(p_cur += outpitch) = result;
-                    /* second pixel */
-                    r0 = *(p_ref += inpitch);
-                    result = (r1 + r0);
-                    r1 = (r2 + r5);
-                    result -= (r1 * 5);//result -= r1;  result -= (r1<<2);
-                    r1 = (r3 + r4);
-                    result += (r1 * 20);//result += (r1<<4);    result += (r1<<2);
-                    result = (result + 16) >> 5;
-                    CLIP_RESULT(result)
-                    tmp_result = *(p_tmp8 += 24);  /* intermediate result */
-                    result = (result + tmp_result + 1);  /* no clip */
-                    result = (result >> 1);
-                    *(p_cur += outpitch) = result;
-                    /* third pixel */
-                    r1 = *(p_ref += inpitch);
-                    result = (r2 + r1);
-                    r2 = (r3 + r0);
-                    result -= (r2 * 5);//result -= r2;  result -= (r2<<2);
-                    r2 = (r4 + r5);
-                    result += (r2 * 20);//result += (r2<<4);    result += (r2<<2);
-                    result = (result + 16) >> 5;
-                    CLIP_RESULT(result)
-                    tmp_result = *(p_tmp8 += 24);  /* intermediate result */
-                    result = (result + tmp_result + 1);  /* no clip */
-                    result = (result >> 1);
-                    *(p_cur += outpitch) = result;
-                    /* fourth pixel */
-                    r2 = *(p_ref += inpitch);
-                    result = (r3 + r2);
-                    r3 = (r4 + r1);
-                    result -= (r3 * 5);//result -= r3;  result -= (r3<<2);
-                    r3 = (r5 + r0);
-                    result += (r3 * 20);//result += (r3<<4);    result += (r3<<2);
-                    result = (result + 16) >> 5;
-                    CLIP_RESULT(result)
-                    tmp_result = *(p_tmp8 += 24);  /* intermediate result */
-                    result = (result + tmp_result + 1);  /* no clip */
-                    result = (result >> 1);
-                    *(p_cur += outpitch) = result;
-                    p_ref -= (inpitch << 1);  /* move back to center of the filter of the next one */
-                }
-                p_cur += (curr_offset - 3);
-            }
-        }
-    }
-
-    return ;
-}
-
-/* position G */
-void eFullPelMC(uint8 *in, int inpitch, uint8 *out, int outpitch,
-                int blkwidth, int blkheight)
-{
-    int i, j;
-    int offset_in = inpitch - blkwidth;
-    int offset_out = outpitch - blkwidth;
-    uint32 temp;
-    uint8 byte;
-
-    if (((intptr_t)in)&3)
-    {
-        for (j = blkheight; j > 0; j--)
-        {
-            for (i = blkwidth; i > 0; i -= 4)
-            {
-                temp = *in++;
-                byte = *in++;
-                temp |= (byte << 8);
-                byte = *in++;
-                temp |= (byte << 16);
-                byte = *in++;
-                temp |= (byte << 24);
-
-                *((uint32*)out) = temp; /* write 4 bytes */
-                out += 4;
-            }
-            out += offset_out;
-            in += offset_in;
-        }
-    }
-    else
-    {
-        for (j = blkheight; j > 0; j--)
-        {
-            for (i = blkwidth; i > 0; i -= 4)
-            {
-                temp = *((uint32*)in);
-                *((uint32*)out) = temp;
-                in += 4;
-                out += 4;
-            }
-            out += offset_out;
-            in += offset_in;
-        }
-    }
-    return ;
-}
-
-void ePadChroma(uint8 *ref, int picwidth, int picheight, int picpitch, int x_pos, int y_pos)
-{
-    int pad_height;
-    int pad_width;
-    uint8 *start;
-    uint32 word1, word2, word3;
-    int offset, j;
-
-
-    pad_height = 8 + ((y_pos & 7) ? 1 : 0);
-    pad_width = 8 + ((x_pos & 7) ? 1 : 0);
-
-    y_pos >>= 3;
-    x_pos >>= 3;
-    // pad vertical first
-    if (y_pos < 0) // need to pad up
-    {
-        if (x_pos < -8) start = ref - 8;
-        else if (x_pos + pad_width > picwidth + 7) start = ref + picwidth + 7 - pad_width;
-        else start = ref + x_pos;
-
-        /* word-align start */
-        offset = (intptr_t)start & 0x3;
-        if (offset) start -= offset;
-
-        word1 = *((uint32*)start);
-        word2 = *((uint32*)(start + 4));
-        word3 = *((uint32*)(start + 8));
-
-        /* pad up N rows */
-        j = -y_pos;
-        if (j > 8) j = 8;
-        while (j--)
-        {
-            *((uint32*)(start -= picpitch)) = word1;
-            *((uint32*)(start + 4)) = word2;
-            *((uint32*)(start + 8)) = word3;
-        }
-
-    }
-    else if (y_pos + pad_height >= picheight) /* pad down */
-    {
-        if (x_pos < -8) start = ref + picpitch * (picheight - 1) - 8;
-        else if (x_pos + pad_width > picwidth + 7) start = ref + picpitch * (picheight - 1) +
-                    picwidth + 7 - pad_width;
-        else    start = ref + picpitch * (picheight - 1) + x_pos;
-
-        /* word-align start */
-        offset = (intptr_t)start & 0x3;
-        if (offset) start -= offset;
-
-        word1 = *((uint32*)start);
-        word2 = *((uint32*)(start + 4));
-        word3 = *((uint32*)(start + 8));
-
-        /* pad down N rows */
-        j = y_pos + pad_height - picheight;
-        if (j > 8) j = 8;
-        while (j--)
-        {
-            *((uint32*)(start += picpitch)) = word1;
-            *((uint32*)(start + 4)) = word2;
-            *((uint32*)(start + 8)) = word3;
-        }
-    }
-
-    /* now pad horizontal */
-    if (x_pos < 0) // pad left
-    {
-        if (y_pos < -8) start = ref - (picpitch << 3);
-        else if (y_pos + pad_height > picheight + 7) start = ref + (picheight + 7 - pad_height) * picpitch;
-        else start = ref + y_pos * picpitch;
-
-        // now pad left 8 pixels for pad_height rows */
-        j = pad_height;
-        start -= picpitch;
-        while (j--)
-        {
-            word1 = *(start += picpitch);
-            word1 |= (word1 << 8);
-            word1 |= (word1 << 16);
-            *((uint32*)(start - 8)) = word1;
-            *((uint32*)(start - 4)) = word1;
-        }
-    }
-    else if (x_pos + pad_width >= picwidth) /* pad right */
-    {
-        if (y_pos < -8) start = ref - (picpitch << 3) + picwidth - 1;
-        else if (y_pos + pad_height > picheight + 7) start = ref + (picheight + 7 - pad_height) * picpitch + picwidth - 1;
-        else start = ref + y_pos * picpitch + picwidth - 1;
-
-        // now pad right 8 pixels for pad_height rows */
-        j = pad_height;
-        start -= picpitch;
-        while (j--)
-        {
-            word1 = *(start += picpitch);
-            word1 |= (word1 << 8);
-            word1 |= (word1 << 16);
-            *((uint32*)(start + 1)) = word1;
-            *((uint32*)(start + 5)) = word1;
-        }
-    }
-
-    return ;
-}
-
-
-void eChromaMotionComp(uint8 *ref, int picwidth, int picheight,
-                       int x_pos, int y_pos,
-                       uint8 *pred, int picpitch,
-                       int blkwidth, int blkheight)
-{
-    int dx, dy;
-    int offset_dx, offset_dy;
-    int index;
-
-    ePadChroma(ref, picwidth, picheight, picpitch, x_pos, y_pos);
-
-    dx = x_pos & 7;
-    dy = y_pos & 7;
-    offset_dx = (dx + 7) >> 3;
-    offset_dy = (dy + 7) >> 3;
-    x_pos = x_pos >> 3;  /* round it to full-pel resolution */
-    y_pos = y_pos >> 3;
-
-    ref += y_pos * picpitch + x_pos;
-
-    index = offset_dx + (offset_dy << 1) + ((blkwidth << 1) & 0x7);
-
-    (*(eChromaMC_SIMD[index]))(ref, picpitch , dx, dy, pred, picpitch, blkwidth, blkheight);
-    return ;
-}
-
-
-/* SIMD routines, unroll the loops in vertical direction, decreasing loops (things to be done) */
-void eChromaDiagonalMC_SIMD(uint8 *pRef, int srcPitch, int dx, int dy,
-                            uint8 *pOut, int predPitch, int blkwidth, int blkheight)
-{
-    int32 r0, r1, r2, r3, result0, result1;
-    uint8 temp[288];
-    uint8 *ref, *out;
-    int i, j;
-    int dx_8 = 8 - dx;
-    int dy_8 = 8 - dy;
-
-    /* horizontal first */
-    out = temp;
-    for (i = 0; i < blkheight + 1; i++)
-    {
-        ref = pRef;
-        r0 = ref[0];
-        for (j = 0; j < blkwidth; j += 4)
-        {
-            r0 |= (ref[2] << 16);
-            result0 = dx_8 * r0;
-
-            r1 = ref[1] | (ref[3] << 16);
-            result0 += dx * r1;
-            *(int32 *)out = result0;
-
-            result0 = dx_8 * r1;
-
-            r2 = ref[4];
-            r0 = r0 >> 16;
-            r1 = r0 | (r2 << 16);
-            result0 += dx * r1;
-            *(int32 *)(out + 16) = result0;
-
-            ref += 4;
-            out += 4;
-            r0 = r2;
-        }
-        pRef += srcPitch;
-        out += (32 - blkwidth);
-    }
-
-//  pRef -= srcPitch*(blkheight+1);
-    ref = temp;
-
-    for (j = 0; j < blkwidth; j += 4)
-    {
-        r0 = *(int32 *)ref;
-        r1 = *(int32 *)(ref + 16);
-        ref += 32;
-        out = pOut;
-        for (i = 0; i < (blkheight >> 1); i++)
-        {
-            result0 = dy_8 * r0 + 0x00200020;
-            r2 = *(int32 *)ref;
-            result0 += dy * r2;
-            result0 >>= 6;
-            result0 &= 0x00FF00FF;
-            r0 = r2;
-
-            result1 = dy_8 * r1 + 0x00200020;
-            r3 = *(int32 *)(ref + 16);
-            result1 += dy * r3;
-            result1 >>= 6;
-            result1 &= 0x00FF00FF;
-            r1 = r3;
-            *(int32 *)out = result0 | (result1 << 8);
-            out += predPitch;
-            ref += 32;
-
-            result0 = dy_8 * r0 + 0x00200020;
-            r2 = *(int32 *)ref;
-            result0 += dy * r2;
-            result0 >>= 6;
-            result0 &= 0x00FF00FF;
-            r0 = r2;
-
-            result1 = dy_8 * r1 + 0x00200020;
-            r3 = *(int32 *)(ref + 16);
-            result1 += dy * r3;
-            result1 >>= 6;
-            result1 &= 0x00FF00FF;
-            r1 = r3;
-            *(int32 *)out = result0 | (result1 << 8);
-            out += predPitch;
-            ref += 32;
-        }
-        pOut += 4;
-        ref = temp + 4; /* since it can only iterate twice max */
-    }
-    return;
-}
-
-void eChromaHorizontalMC_SIMD(uint8 *pRef, int srcPitch, int dx, int dy,
-                              uint8 *pOut, int predPitch, int blkwidth, int blkheight)
-{
-    (void)(dy);
-
-    int32 r0, r1, r2, result0, result1;
-    uint8 *ref, *out;
-    int i, j;
-    int dx_8 = 8 - dx;
-
-    /* horizontal first */
-    for (i = 0; i < blkheight; i++)
-    {
-        ref = pRef;
-        out = pOut;
-
-        r0 = ref[0];
-        for (j = 0; j < blkwidth; j += 4)
-        {
-            r0 |= (ref[2] << 16);
-            result0 = dx_8 * r0 + 0x00040004;
-
-            r1 = ref[1] | (ref[3] << 16);
-            result0 += dx * r1;
-            result0 >>= 3;
-            result0 &= 0x00FF00FF;
-
-            result1 = dx_8 * r1 + 0x00040004;
-
-            r2 = ref[4];
-            r0 = r0 >> 16;
-            r1 = r0 | (r2 << 16);
-            result1 += dx * r1;
-            result1 >>= 3;
-            result1 &= 0x00FF00FF;
-
-            *(int32 *)out = result0 | (result1 << 8);
-
-            ref += 4;
-            out += 4;
-            r0 = r2;
-        }
-
-        pRef += srcPitch;
-        pOut += predPitch;
-    }
-    return;
-}
-
-void eChromaVerticalMC_SIMD(uint8 *pRef, int srcPitch, int dx, int dy,
-                            uint8 *pOut, int predPitch, int blkwidth, int blkheight)
-{
-    (void)(dx);
-
-    int32 r0, r1, r2, r3, result0, result1;
-    int i, j;
-    uint8 *ref, *out;
-    int dy_8 = 8 - dy;
-    /* vertical first */
-    for (i = 0; i < blkwidth; i += 4)
-    {
-        ref = pRef;
-        out = pOut;
-
-        r0 = ref[0] | (ref[2] << 16);
-        r1 = ref[1] | (ref[3] << 16);
-        ref += srcPitch;
-        for (j = 0; j < blkheight; j++)
-        {
-            result0 = dy_8 * r0 + 0x00040004;
-            r2 = ref[0] | (ref[2] << 16);
-            result0 += dy * r2;
-            result0 >>= 3;
-            result0 &= 0x00FF00FF;
-            r0 = r2;
-
-            result1 = dy_8 * r1 + 0x00040004;
-            r3 = ref[1] | (ref[3] << 16);
-            result1 += dy * r3;
-            result1 >>= 3;
-            result1 &= 0x00FF00FF;
-            r1 = r3;
-            *(int32 *)out = result0 | (result1 << 8);
-            ref += srcPitch;
-            out += predPitch;
-        }
-        pOut += 4;
-        pRef += 4;
-    }
-    return;
-}
-
-void eChromaDiagonalMC2_SIMD(uint8 *pRef, int srcPitch, int dx, int dy,
-                             uint8 *pOut,  int predPitch, int blkwidth, int blkheight)
-{
-    (void)(blkwidth);
-
-    int32 r0, r1, temp0, temp1, result;
-    int32 temp[9];
-    int32 *out;
-    int i, r_temp;
-    int dy_8 = 8 - dy;
-
-    /* horizontal first */
-    out = temp;
-    for (i = 0; i < blkheight + 1; i++)
-    {
-        r_temp = pRef[1];
-        temp0 = (pRef[0] << 3) + dx * (r_temp - pRef[0]);
-        temp1 = (r_temp << 3) + dx * (pRef[2] - r_temp);
-        r0 = temp0 | (temp1 << 16);
-        *out++ = r0;
-        pRef += srcPitch;
-    }
-
-    pRef -= srcPitch * (blkheight + 1);
-
-    out = temp;
-
-    r0 = *out++;
-
-    for (i = 0; i < blkheight; i++)
-    {
-        result = dy_8 * r0 + 0x00200020;
-        r1 = *out++;
-        result += dy * r1;
-        result >>= 6;
-        result &= 0x00FF00FF;
-        *(int16 *)pOut = (result >> 8) | (result & 0xFF);
-        r0 = r1;
-        pOut += predPitch;
-    }
-    return;
-}
-
-void eChromaHorizontalMC2_SIMD(uint8 *pRef, int srcPitch, int dx, int dy,
-                               uint8 *pOut, int predPitch, int blkwidth, int blkheight)
-{
-    (void)(dy);
-    (void)(blkwidth);
-
-    int i, temp, temp0, temp1;
-
-    /* horizontal first */
-    for (i = 0; i < blkheight; i++)
-    {
-        temp = pRef[1];
-        temp0 = ((pRef[0] << 3) + dx * (temp - pRef[0]) + 4) >> 3;
-        temp1 = ((temp << 3) + dx * (pRef[2] - temp) + 4) >> 3;
-
-        *(int16 *)pOut = temp0 | (temp1 << 8);
-        pRef += srcPitch;
-        pOut += predPitch;
-
-    }
-    return;
-}
-void eChromaVerticalMC2_SIMD(uint8 *pRef, int srcPitch, int dx, int dy,
-                             uint8 *pOut, int predPitch, int blkwidth, int blkheight)
-{
-    (void)(dx);
-    (void)(blkwidth);
-
-    int32 r0, r1, result;
-    int i;
-    int dy_8 = 8 - dy;
-    r0 = pRef[0] | (pRef[1] << 16);
-    pRef += srcPitch;
-    for (i = 0; i < blkheight; i++)
-    {
-        result = dy_8 * r0 + 0x00040004;
-        r1 = pRef[0] | (pRef[1] << 16);
-        result += dy * r1;
-        result >>= 3;
-        result &= 0x00FF00FF;
-        *(int16 *)pOut = (result >> 8) | (result & 0xFF);
-        r0 = r1;
-        pRef += srcPitch;
-        pOut += predPitch;
-    }
-    return;
-}
-
-void eChromaFullMC_SIMD(uint8 *pRef, int srcPitch, int dx, int dy,
-                        uint8 *pOut, int predPitch, int blkwidth, int blkheight)
-{
-    (void)(dx);
-    (void)(dy);
-
-    int i, j;
-    int offset_in = srcPitch - blkwidth;
-    int offset_out = predPitch - blkwidth;
-    uint16 temp;
-    uint8 byte;
-
-    if (((intptr_t)pRef)&1)
-    {
-        for (j = blkheight; j > 0; j--)
-        {
-            for (i = blkwidth; i > 0; i -= 2)
-            {
-                temp = *pRef++;
-                byte = *pRef++;
-                temp |= (byte << 8);
-                *((uint16*)pOut) = temp; /* write 2 bytes */
-                pOut += 2;
-            }
-            pOut += offset_out;
-            pRef += offset_in;
-        }
-    }
-    else
-    {
-        for (j = blkheight; j > 0; j--)
-        {
-            for (i = blkwidth; i > 0; i -= 2)
-            {
-                temp = *((uint16*)pRef);
-                *((uint16*)pOut) = temp;
-                pRef += 2;
-                pOut += 2;
-            }
-            pOut += offset_out;
-            pRef += offset_in;
-        }
-    }
-    return ;
-}
diff --git a/media/libstagefright/codecs/avc/enc/src/motion_est.cpp b/media/libstagefright/codecs/avc/enc/src/motion_est.cpp
deleted file mode 100644
index 00c56c8..0000000
--- a/media/libstagefright/codecs/avc/enc/src/motion_est.cpp
+++ /dev/null
@@ -1,1774 +0,0 @@
-/* ------------------------------------------------------------------
- * 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 "avcenc_lib.h"
-
-#define MIN_GOP     1   /* minimum size of GOP, 1/23/01, need to be tested */
-
-#define DEFAULT_REF_IDX     0  /* always from the first frame in the reflist */
-
-#define ALL_CAND_EQUAL  10  /*  any number greater than 5 will work */
-
-
-/* from TMN 3.2 */
-#define PREF_NULL_VEC 129   /* zero vector bias */
-#define PREF_16_VEC 129     /* 1MV bias versus 4MVs*/
-#define PREF_INTRA  3024//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 _SAD_STAT
-uint32 num_MB = 0;
-uint32 num_cand = 0;
-#endif
-
-/************************************************************************/
-#define TH_INTER_2  100  /* temporary for now */
-
-//#define FIXED_INTERPRED_MODE  AVC_P16
-#define FIXED_REF_IDX   0
-#define FIXED_MVX 0
-#define FIXED_MVY 0
-
-// only use when AVC_P8 or AVC_P8ref0
-#define FIXED_SUBMB_MODE    AVC_4x4
-/*************************************************************************/
-
-/* Initialize arrays necessary for motion search */
-AVCEnc_Status InitMotionSearchModule(AVCHandle *avcHandle)
-{
-    AVCEncObject *encvid = (AVCEncObject*) avcHandle->AVCObject;
-    AVCRateControl *rateCtrl = encvid->rateCtrl;
-    int search_range = rateCtrl->mvRange;
-    int number_of_subpel_positions = 4 * (2 * search_range + 3);
-    int max_mv_bits, max_mvd;
-    int temp_bits = 0;
-    uint8 *mvbits;
-    int bits, imax, imin, i;
-    uint8* subpel_pred = (uint8*) encvid->subpel_pred; // all 16 sub-pel positions
-
-
-    while (number_of_subpel_positions > 0)
-    {
-        temp_bits++;
-        number_of_subpel_positions >>= 1;
-    }
-
-    max_mv_bits = 3 + 2 * temp_bits;
-    max_mvd  = (1 << (max_mv_bits >> 1)) - 1;
-
-    encvid->mvbits_array = (uint8*) avcHandle->CBAVC_Malloc(encvid->avcHandle->userData,
-                           sizeof(uint8) * (2 * max_mvd + 1), DEFAULT_ATTR);
-
-    if (encvid->mvbits_array == NULL)
-    {
-        return AVCENC_MEMORY_FAIL;
-    }
-
-    mvbits = encvid->mvbits  = encvid->mvbits_array + max_mvd;
-
-    mvbits[0] = 1;
-    for (bits = 3; bits <= max_mv_bits; bits += 2)
-    {
-        imax = 1    << (bits >> 1);
-        imin = imax >> 1;
-
-        for (i = imin; i < imax; i++)   mvbits[-i] = mvbits[i] = bits;
-    }
-
-    /* initialize half-pel search */
-    encvid->hpel_cand[0] = subpel_pred + REF_CENTER;
-    encvid->hpel_cand[1] = subpel_pred + V2Q_H0Q * SUBPEL_PRED_BLK_SIZE + 1 ;
-    encvid->hpel_cand[2] = subpel_pred + V2Q_H2Q * SUBPEL_PRED_BLK_SIZE + 1;
-    encvid->hpel_cand[3] = subpel_pred + V0Q_H2Q * SUBPEL_PRED_BLK_SIZE + 25;
-    encvid->hpel_cand[4] = subpel_pred + V2Q_H2Q * SUBPEL_PRED_BLK_SIZE + 25;
-    encvid->hpel_cand[5] = subpel_pred + V2Q_H0Q * SUBPEL_PRED_BLK_SIZE + 25;
-    encvid->hpel_cand[6] = subpel_pred + V2Q_H2Q * SUBPEL_PRED_BLK_SIZE + 24;
-    encvid->hpel_cand[7] = subpel_pred + V0Q_H2Q * SUBPEL_PRED_BLK_SIZE + 24;
-    encvid->hpel_cand[8] = subpel_pred + V2Q_H2Q * SUBPEL_PRED_BLK_SIZE;
-
-    /* For quarter-pel interpolation around best half-pel result */
-
-    encvid->bilin_base[0][0] = subpel_pred + V2Q_H2Q * SUBPEL_PRED_BLK_SIZE;
-    encvid->bilin_base[0][1] = subpel_pred + V2Q_H0Q * SUBPEL_PRED_BLK_SIZE + 1;
-    encvid->bilin_base[0][2] = subpel_pred + V0Q_H2Q * SUBPEL_PRED_BLK_SIZE + 24;
-    encvid->bilin_base[0][3] = subpel_pred + REF_CENTER;
-
-
-    encvid->bilin_base[1][0] = subpel_pred + V0Q_H2Q * SUBPEL_PRED_BLK_SIZE;
-    encvid->bilin_base[1][1] = subpel_pred + REF_CENTER - 24;
-    encvid->bilin_base[1][2] = subpel_pred + V2Q_H2Q * SUBPEL_PRED_BLK_SIZE;
-    encvid->bilin_base[1][3] = subpel_pred + V2Q_H0Q * SUBPEL_PRED_BLK_SIZE + 1;
-
-    encvid->bilin_base[2][0] = subpel_pred + REF_CENTER - 24;
-    encvid->bilin_base[2][1] = subpel_pred + V0Q_H2Q * SUBPEL_PRED_BLK_SIZE + 1;
-    encvid->bilin_base[2][2] = subpel_pred + V2Q_H0Q * SUBPEL_PRED_BLK_SIZE + 1;
-    encvid->bilin_base[2][3] = subpel_pred + V2Q_H2Q * SUBPEL_PRED_BLK_SIZE + 1;
-
-    encvid->bilin_base[3][0] = subpel_pred + V2Q_H0Q * SUBPEL_PRED_BLK_SIZE + 1;
-    encvid->bilin_base[3][1] = subpel_pred + V2Q_H2Q * SUBPEL_PRED_BLK_SIZE + 1;
-    encvid->bilin_base[3][2] = subpel_pred + REF_CENTER;
-    encvid->bilin_base[3][3] = subpel_pred + V0Q_H2Q * SUBPEL_PRED_BLK_SIZE + 25;
-
-    encvid->bilin_base[4][0] = subpel_pred + REF_CENTER;
-    encvid->bilin_base[4][1] = subpel_pred + V0Q_H2Q * SUBPEL_PRED_BLK_SIZE + 25;
-    encvid->bilin_base[4][2] = subpel_pred + V2Q_H0Q * SUBPEL_PRED_BLK_SIZE + 25;
-    encvid->bilin_base[4][3] = subpel_pred + V2Q_H2Q * SUBPEL_PRED_BLK_SIZE + 25;
-
-    encvid->bilin_base[5][0] = subpel_pred + V0Q_H2Q * SUBPEL_PRED_BLK_SIZE + 24;
-    encvid->bilin_base[5][1] = subpel_pred + REF_CENTER;
-    encvid->bilin_base[5][2] = subpel_pred + V2Q_H2Q * SUBPEL_PRED_BLK_SIZE + 24;
-    encvid->bilin_base[5][3] = subpel_pred + V2Q_H0Q * SUBPEL_PRED_BLK_SIZE + 25;
-
-    encvid->bilin_base[6][0] = subpel_pred + REF_CENTER - 1;
-    encvid->bilin_base[6][1] = subpel_pred + V0Q_H2Q * SUBPEL_PRED_BLK_SIZE + 24;
-    encvid->bilin_base[6][2] = subpel_pred + V2Q_H0Q * SUBPEL_PRED_BLK_SIZE + 24;
-    encvid->bilin_base[6][3] = subpel_pred + V2Q_H2Q * SUBPEL_PRED_BLK_SIZE + 24;
-
-    encvid->bilin_base[7][0] = subpel_pred + V2Q_H0Q * SUBPEL_PRED_BLK_SIZE;
-    encvid->bilin_base[7][1] = subpel_pred + V2Q_H2Q * SUBPEL_PRED_BLK_SIZE;
-    encvid->bilin_base[7][2] = subpel_pred + REF_CENTER - 1;
-    encvid->bilin_base[7][3] = subpel_pred + V0Q_H2Q * SUBPEL_PRED_BLK_SIZE + 24;
-
-    encvid->bilin_base[8][0] = subpel_pred + REF_CENTER - 25;
-    encvid->bilin_base[8][1] = subpel_pred + V0Q_H2Q * SUBPEL_PRED_BLK_SIZE;
-    encvid->bilin_base[8][2] = subpel_pred + V2Q_H0Q * SUBPEL_PRED_BLK_SIZE;
-    encvid->bilin_base[8][3] = subpel_pred + V2Q_H2Q * SUBPEL_PRED_BLK_SIZE;
-
-
-    return AVCENC_SUCCESS;
-}
-
-/* Clean-up memory */
-void CleanMotionSearchModule(AVCHandle *avcHandle)
-{
-    AVCEncObject *encvid = (AVCEncObject*) avcHandle->AVCObject;
-
-    if (encvid->mvbits_array)
-    {
-        avcHandle->CBAVC_Free(avcHandle->userData, encvid->mvbits_array);
-        encvid->mvbits = NULL;
-    }
-
-    return ;
-}
-
-
-bool IntraDecisionABE(int *min_cost, uint8 *cur, int pitch, bool ave)
-{
-    int j;
-    uint8 *out;
-    int temp, SBE;
-    OsclFloat ABE;
-    bool intra = true;
-
-    SBE = 0;
-    /* top neighbor */
-    out = cur - pitch;
-    for (j = 0; j < 16; j++)
-    {
-        temp = out[j] - cur[j];
-        SBE += ((temp >= 0) ? temp : -temp);
-    }
-
-    /* left neighbor */
-    out = cur - 1;
-    out -= pitch;
-    cur -= pitch;
-    for (j = 0; j < 16; j++)
-    {
-        temp = *(out += pitch) - *(cur += pitch);
-        SBE += ((temp >= 0) ? temp : -temp);
-    }
-
-    /* compare mincost/384 and SBE/64 */
-    ABE = SBE / 32.0; //ABE = SBE/64.0; //
-    if (ABE >= *min_cost / 256.0) //if( ABE*0.8 >= min_cost/384.0) //
-    {
-        intra = false; // no possibility of intra, just use inter
-    }
-    else
-    {
-        if (ave == true)
-        {
-            *min_cost = (*min_cost + (int)(SBE * 8)) >> 1; // possibility of intra, averaging the cost
-        }
-        else
-        {
-            *min_cost = (int)(SBE * 8);
-        }
-    }
-
-    return intra;
-}
-
-/******* main function for macroblock prediction for the entire frame ***/
-/* if turns out to be IDR frame, set video->nal_unit_type to AVC_NALTYPE_IDR */
-void AVCMotionEstimation(AVCEncObject *encvid)
-{
-    AVCCommonObj *video = encvid->common;
-    int slice_type = video->slice_type;
-    AVCFrameIO *currInput = encvid->currInput;
-    AVCPictureData *refPic = video->RefPicList0[0];
-    int i, j, k;
-    int mbwidth = video->PicWidthInMbs;
-    int mbheight = video->PicHeightInMbs;
-    int totalMB = video->PicSizeInMbs;
-    int pitch = currInput->pitch;
-    AVCMacroblock *currMB, *mblock = video->mblock;
-    AVCMV *mot_mb_16x16, *mot16x16 = encvid->mot16x16;
-    // AVCMV *mot_mb_16x8, *mot_mb_8x16, *mot_mb_8x8, etc;
-    AVCRateControl *rateCtrl = encvid->rateCtrl;
-    uint8 *intraSearch = encvid->intraSearch;
-    uint FS_en = encvid->fullsearch_enable;
-
-    int NumIntraSearch, start_i, numLoop, incr_i;
-    int mbnum, offset;
-    uint8 *cur, *best_cand[5];
-    int totalSAD = 0;   /* average SAD for rate control */
-    int type_pred;
-    int abe_cost;
-
-#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;
-    uint32 mv_uint32;
-
-    offset = 0;
-
-    if (slice_type == AVC_I_SLICE)
-    {
-        /* cannot do I16 prediction here because it needs full decoding. */
-        for (i = 0; i < totalMB; i++)
-        {
-            encvid->min_cost[i] = 0x7FFFFFFF;  /* max value for int */
-        }
-
-        memset(intraSearch, 1, sizeof(uint8)*totalMB);
-
-        encvid->firstIntraRefreshMBIndx = 0; /* reset this */
-
-        return ;
-    }
-    else   // P_SLICE
-    {
-        for (i = 0; i < totalMB; i++)
-        {
-            mblock[i].mb_intra = 0;
-        }
-        memset(intraSearch, 1, sizeof(uint8)*totalMB);
-    }
-
-    if (refPic->padded == 0)
-    {
-        AVCPaddingEdge(refPic);
-        refPic->padded = 1;
-    }
-    /* Random INTRA update */
-    if (rateCtrl->intraMBRate)
-    {
-        AVCRasterIntraUpdate(encvid, mblock, totalMB, rateCtrl->intraMBRate);
-    }
-
-    encvid->sad_extra_info = NULL;
-#ifdef HTFM
-    /***** HYPOTHESIS TESTING ********/
-    InitHTFM(video, &htfm_stat, newvar, &collect);
-    /*********************************/
-#endif
-
-    if ((rateCtrl->scdEnable == 1)
-            && ((rateCtrl->frame_rate < 5.0) || (video->sliceHdr->frame_num > 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 */
-    NumIntraSearch = 0; // to be intra searched in the encoding loop.
-    while (numLoop--)
-    {
-        for (j = 0; j < mbheight; j++)
-        {
-            if (incr_i > 1)
-                start_i = (start_i == 0 ? 1 : 0) ; /* toggle 0 and 1 */
-
-            offset = pitch * (j << 4) + (start_i << 4);
-
-            mbnum = j * mbwidth + start_i;
-
-            for (i = start_i; i < mbwidth; i += incr_i)
-            {
-                video->mbNum = mbnum;
-                video->currMB = currMB = mblock + mbnum;
-                mot_mb_16x16 = mot16x16 + mbnum;
-
-                cur = currInput->YCbCr[0] + offset;
-
-                if (currMB->mb_intra == 0) /* for INTER mode */
-                {
-#if defined(HTFM)
-                    HTFMPrepareCurMB_AVC(encvid, &htfm_stat, cur, pitch);
-#else
-                    AVCPrepareCurMB(encvid, cur, pitch);
-#endif
-                    /************************************************************/
-                    /******** full-pel 1MV search **********************/
-
-                    AVCMBMotionSearch(encvid, cur, best_cand, i << 4, j << 4, type_pred,
-                                      FS_en, &hp_guess);
-
-                    abe_cost = encvid->min_cost[mbnum] = mot_mb_16x16->sad;
-
-                    /* set mbMode and MVs */
-                    currMB->mbMode = AVC_P16;
-                    currMB->MBPartPredMode[0][0] = AVC_Pred_L0;
-                    mv_uint32 = ((mot_mb_16x16->y) << 16) | ((mot_mb_16x16->x) & 0xffff);
-                    for (k = 0; k < 32; k += 2)
-                    {
-                        currMB->mvL0[k>>1] = mv_uint32;
-                    }
-
-                    /* make a decision whether it should be tested for intra or not */
-                    if (i != mbwidth - 1 && j != mbheight - 1 && i != 0 && j != 0)
-                    {
-                        if (false == IntraDecisionABE(&abe_cost, cur, pitch, true))
-                        {
-                            intraSearch[mbnum] = 0;
-                        }
-                        else
-                        {
-                            NumIntraSearch++;
-                            rateCtrl->MADofMB[mbnum] = abe_cost;
-                        }
-                    }
-                    else // boundary MBs, always do intra search
-                    {
-                        NumIntraSearch++;
-                    }
-
-                    totalSAD += (int) rateCtrl->MADofMB[mbnum];//mot_mb_16x16->sad;
-                }
-                else    /* INTRA update, use for prediction */
-                {
-                    mot_mb_16x16[0].x = mot_mb_16x16[0].y = 0;
-
-                    /* reset all other MVs to zero */
-                    /* mot_mb_16x8, mot_mb_8x16, mot_mb_8x8, etc. */
-                    abe_cost = encvid->min_cost[mbnum] = 0x7FFFFFFF;  /* max value for int */
-
-                    if (i != mbwidth - 1 && j != mbheight - 1 && i != 0 && j != 0)
-                    {
-                        IntraDecisionABE(&abe_cost, cur, pitch, false);
-
-                        rateCtrl->MADofMB[mbnum] = abe_cost;
-                        totalSAD += abe_cost;
-                    }
-
-                    NumIntraSearch++ ;
-                    /* cannot do I16 prediction here because it needs full decoding. */
-                    // intraSearch[mbnum] = 1;
-
-                }
-
-                mbnum += incr_i;
-                offset += (incr_i << 4);
-
-            } /* for i */
-        } /* for j */
-
-        /* since we cannot do intra/inter decision here, the SCD has to be
-        based on other criteria such as motion vectors coherency or the SAD */
-        if (incr_i > 1 && numLoop) /* scene change on and first loop */
-        {
-            //if(NumIntraSearch > ((totalMB>>3)<<1) + (totalMB>>3)) /* 75% of 50%MBs */
-            if (NumIntraSearch*99 > (48*totalMB)) /* 20% of 50%MBs */
-                /* need to do more investigation about this threshold since the NumIntraSearch
-                only show potential intra MBs, not the actual one */
-            {
-                /* we can choose to just encode I_SLICE without IDR */
-                //video->nal_unit_type = AVC_NALTYPE_IDR;
-                video->nal_unit_type = AVC_NALTYPE_SLICE;
-                video->sliceHdr->slice_type = AVC_I_ALL_SLICE;
-                video->slice_type = AVC_I_SLICE;
-                memset(intraSearch, 1, sizeof(uint8)*totalMB);
-                i = totalMB;
-                while (i--)
-                {
-                    mblock[i].mb_intra = 1;
-                    encvid->min_cost[i] = 0x7FFFFFFF;  /* max value for int */
-                }
-
-                rateCtrl->totalSAD = totalSAD * 2;  /* SAD */
-
-                return ;
-            }
-        }
-        /******** no scene change, continue motion search **********************/
-        start_i = 0;
-        type_pred++; /* second pass */
-    }
-
-    rateCtrl->totalSAD = totalSAD;  /* SAD */
-
-#ifdef HTFM
-    /***** HYPOTHESIS TESTING ********/
-    if (collect)
-    {
-        collect = 0;
-        UpdateHTFM(encvid, newvar, exp_lamda, &htfm_stat);
-    }
-    /*********************************/
-#endif
-
-    return ;
-}
-
-/*=====================================================================
-    Function:   PaddingEdge
-    Date:       09/16/2000
-    Purpose:    Pad edge of a Vop
-=====================================================================*/
-
-void  AVCPaddingEdge(AVCPictureData *refPic)
-{
-    uint8 *src, *dst;
-    int i;
-    int pitch, width, height;
-    uint32 temp1, temp2;
-
-    width = refPic->width;
-    height = refPic->height;
-    pitch = refPic->pitch;
-
-    /* pad top */
-    src = refPic->Sl;
-
-    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);
-
-    *((uint32*)(dst - 16)) = temp1;
-    *((uint32*)(dst - 12)) = temp1;
-    *((uint32*)(dst - 8)) = temp1;
-    *((uint32*)(dst - 4)) = temp1;
-
-    memcpy(dst, src, width);
-
-    *((uint32*)(dst += width)) = temp2;
-    *((uint32*)(dst + 4)) = temp2;
-    *((uint32*)(dst + 8)) = temp2;
-    *((uint32*)(dst + 12)) = temp2;
-
-    dst = dst - width - 16;
-
-    i = 15;
-    while (i--)
-    {
-        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);
-
-        *((uint32*)(dst - 16)) = temp1;
-        *((uint32*)(dst - 12)) = temp1;
-        *((uint32*)(dst - 8)) = temp1;
-        *((uint32*)(dst - 4)) = temp1;
-
-        *((uint32*)(dst += width)) = temp2;
-        *((uint32*)(dst + 4)) = temp2;
-        *((uint32*)(dst + 8)) = temp2;
-        *((uint32*)(dst + 12)) = temp2;
-
-        src += pitch;
-        dst = src;
-    }
-
-    /* pad bottom */
-    dst -= 16;
-    i = 16;
-    while (i--)
-    {
-        memcpy(dst, dst - pitch, pitch);
-        dst += pitch;
-    }
-
-
-    return ;
-}
-
-/*===========================================================================
-    Function:   AVCRasterIntraUpdate
-    Date:       2/26/01
-    Purpose:    To raster-scan assign INTRA-update .
-                N macroblocks are updated (also was programmable).
-===========================================================================*/
-void AVCRasterIntraUpdate(AVCEncObject *encvid, AVCMacroblock *mblock, int totalMB, int numRefresh)
-{
-    int indx, i;
-
-    indx = encvid->firstIntraRefreshMBIndx;
-    for (i = 0; i < numRefresh && indx < totalMB; i++)
-    {
-        (mblock + indx)->mb_intra = 1;
-        encvid->intraSearch[indx++] = 1;
-    }
-
-    /* if read the end of frame, reset and loop around */
-    if (indx >= totalMB - 1)
-    {
-        indx = 0;
-        while (i < numRefresh && indx < totalMB)
-        {
-            (mblock + indx)->mb_intra = 1;
-            encvid->intraSearch[indx++] = 1;
-            i++;
-        }
-    }
-
-    encvid->firstIntraRefreshMBIndx = indx; /* update with a new value */
-
-    return ;
-}
-
-
-#ifdef HTFM
-void InitHTFM(VideoEncData *encvid, HTFM_Stat *htfm_stat, double *newvar, int *collect)
-{
-    AVCCommonObj *video = encvid->common;
-    int i;
-    int lx = video->currPic->width; // padding
-    int lx2 = lx << 1;
-    int lx3 = lx2 + lx;
-    int rx = video->currPic->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->sliceHdr->frame_num) % 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;
-        }
-//      encvid->functionPointer->SAD_MB_PADDING = &SAD_MB_PADDING_HTFM_Collect;
-        encvid->functionPointer->SAD_Macroblock = &SAD_MB_HTFM_Collect;
-        encvid->functionPointer->SAD_MB_HalfPel[0] = NULL;
-        encvid->functionPointer->SAD_MB_HalfPel[1] = &SAD_MB_HP_HTFM_Collectxh;
-        encvid->functionPointer->SAD_MB_HalfPel[2] = &SAD_MB_HP_HTFM_Collectyh;
-        encvid->functionPointer->SAD_MB_HalfPel[3] = &SAD_MB_HP_HTFM_Collectxhyh;
-        encvid->sad_extra_info = (void*)(htfm_stat);
-        offset = htfm_stat->offsetArray;
-        offset2 = htfm_stat->offsetRef;
-    }
-    else
-    {
-//      encvid->functionPointer->SAD_MB_PADDING = &SAD_MB_PADDING_HTFM;
-        encvid->functionPointer->SAD_Macroblock = &SAD_MB_HTFM;
-        encvid->functionPointer->SAD_MB_HalfPel[0] = NULL;
-        encvid->functionPointer->SAD_MB_HalfPel[1] = &SAD_MB_HP_HTFMxh;
-        encvid->functionPointer->SAD_MB_HalfPel[2] = &SAD_MB_HP_HTFMyh;
-        encvid->functionPointer->SAD_MB_HalfPel[3] = &SAD_MB_HP_HTFMxhyh;
-        encvid->sad_extra_info = (void*)(encvid->nrmlz_th);
-        offset = encvid->nrmlz_th + 16;
-        offset2 = encvid->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(AVCEncObject *encvid, 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, encvid->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_AVC(AVCEncObject *encvid, HTFM_Stat *htfm_stat, uint8 *cur, int pitch)
-{
-    AVCCommonObj *video = encvid->common;
-    uint32 *htfmMB = (uint32*)(encvid->currYMB);
-    uint8 *ptr, byte;
-    int *offset;
-    int i;
-    uint32 word;
-
-    if (((int)video->sliceHdr->frame_num) % 30 == 1)
-    {
-        offset = htfm_stat->offsetArray;
-    }
-    else
-    {
-        offset = encvid->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 += (pitch << 2));
-        byte = ptr[4];
-        word |= (byte << 8);
-        byte = ptr[8];
-        word |= (byte << 16);
-        byte = ptr[12];
-        word |= (byte << 24);
-        *htfmMB++ = word;
-
-        word = *(ptr += (pitch << 2));
-        byte = ptr[4];
-        word |= (byte << 8);
-        byte = ptr[8];
-        word |= (byte << 16);
-        byte = ptr[12];
-        word |= (byte << 24);
-        *htfmMB++ = word;
-
-        word = *(ptr += (pitch << 2));
-        byte = ptr[4];
-        word |= (byte << 8);
-        byte = ptr[8];
-        word |= (byte << 16);
-        byte = ptr[12];
-        word |= (byte << 24);
-        *htfmMB++ = word;
-    }
-
-    return ;
-}
-
-
-#endif // HTFM
-
-void    AVCPrepareCurMB(AVCEncObject *encvid, uint8 *cur, int pitch)
-{
-    void* tmp = (void*)(encvid->currYMB);
-    uint32 *currYMB = (uint32*) tmp;
-    int i;
-
-    cur -= pitch;
-
-    for (i = 0; i < 16; i++)
-    {
-        *currYMB++ = *((uint32*)(cur += pitch));
-        *currYMB++ = *((uint32*)(cur + 4));
-        *currYMB++ = *((uint32*)(cur + 8));
-        *currYMB++ = *((uint32*)(cur + 12));
-    }
-
-    return ;
-}
-
-#ifdef FIXED_INTERPRED_MODE
-
-/* due to the complexity of the predicted motion vector, we may not decide to skip
-a macroblock here just yet. */
-/* We will find the best motion vector and the best intra prediction mode for each block. */
-/* output are
-    currMB->NumMbPart,  currMB->MbPartWidth, currMB->MbPartHeight,
-    currMB->NumSubMbPart[], currMB->SubMbPartWidth[], currMB->SubMbPartHeight,
-    currMB->MBPartPredMode[][] (L0 or L1 or BiPred)
-    currMB->RefIdx[], currMB->ref_idx_L0[],
-    currMB->mvL0[], currMB->mvL1[]
-    */
-
-AVCEnc_Status AVCMBMotionSearch(AVCEncObject *encvid, AVCMacroblock *currMB, int mbNum,
-                                int num_pass)
-{
-    AVCCommonObj *video = encvid->common;
-    int mbPartIdx, subMbPartIdx;
-    int16 *mv;
-    int i;
-    int SubMbPartHeight, SubMbPartWidth, NumSubMbPart;
-
-    /* assign value to currMB->MBPartPredMode[][x],subMbMode[],NumSubMbPart[],SubMbPartWidth[],SubMbPartHeight[] */
-
-    currMB->mbMode = FIXED_INTERPRED_MODE;
-    currMB->mb_intra = 0;
-
-    if (currMB->mbMode == AVC_P16)
-    {
-        currMB->NumMbPart = 1;
-        currMB->MbPartWidth = 16;
-        currMB->MbPartHeight = 16;
-        currMB->SubMbPartHeight[0] = 16;
-        currMB->SubMbPartWidth[0] = 16;
-        currMB->NumSubMbPart[0] =  1;
-    }
-    else if (currMB->mbMode == AVC_P16x8)
-    {
-        currMB->NumMbPart = 2;
-        currMB->MbPartWidth = 16;
-        currMB->MbPartHeight = 8;
-        for (i = 0; i < 2; i++)
-        {
-            currMB->SubMbPartWidth[i] = 16;
-            currMB->SubMbPartHeight[i] = 8;
-            currMB->NumSubMbPart[i] = 1;
-        }
-    }
-    else if (currMB->mbMode == AVC_P8x16)
-    {
-        currMB->NumMbPart = 2;
-        currMB->MbPartWidth = 8;
-        currMB->MbPartHeight = 16;
-        for (i = 0; i < 2; i++)
-        {
-            currMB->SubMbPartWidth[i] = 8;
-            currMB->SubMbPartHeight[i] = 16;
-            currMB->NumSubMbPart[i] = 1;
-        }
-    }
-    else if (currMB->mbMode == AVC_P8 || currMB->mbMode == AVC_P8ref0)
-    {
-        currMB->NumMbPart = 4;
-        currMB->MbPartWidth = 8;
-        currMB->MbPartHeight = 8;
-        if (FIXED_SUBMB_MODE == AVC_8x8)
-        {
-            SubMbPartHeight = 8;
-            SubMbPartWidth = 8;
-            NumSubMbPart = 1;
-        }
-        else if (FIXED_SUBMB_MODE == AVC_8x4)
-        {
-            SubMbPartHeight = 4;
-            SubMbPartWidth = 8;
-            NumSubMbPart = 2;
-        }
-        else if (FIXED_SUBMB_MODE == AVC_4x8)
-        {
-            SubMbPartHeight = 8;
-            SubMbPartWidth = 4;
-            NumSubMbPart = 2;
-        }
-        else if (FIXED_SUBMB_MODE == AVC_4x4)
-        {
-            SubMbPartHeight = 4;
-            SubMbPartWidth = 4;
-            NumSubMbPart = 4;
-        }
-
-        for (i = 0; i < 4; i++)
-        {
-            currMB->subMbMode[i] = FIXED_SUBMB_MODE;
-            currMB->SubMbPartHeight[i] = SubMbPartHeight;
-            currMB->SubMbPartWidth[i] = SubMbPartWidth;
-            currMB->NumSubMbPart[i] = NumSubMbPart;
-        }
-    }
-    else /* it's probably intra mode */
-    {
-        return AVCENC_SUCCESS;
-    }
-
-    for (mbPartIdx = 0; mbPartIdx < 4; mbPartIdx++)
-    {
-        currMB->MBPartPredMode[mbPartIdx][0]  = AVC_Pred_L0;
-        currMB->ref_idx_L0[mbPartIdx] = FIXED_REF_IDX;
-        currMB->RefIdx[mbPartIdx] = video->RefPicList0[FIXED_REF_IDX]->RefIdx;
-
-        for (subMbPartIdx = 0; subMbPartIdx < 4; subMbPartIdx++)
-        {
-            mv = (int16*)(currMB->mvL0 + (mbPartIdx << 2) + subMbPartIdx);
-
-            *mv++ = FIXED_MVX;
-            *mv = FIXED_MVY;
-        }
-    }
-
-    encvid->min_cost = 0;
-
-    return AVCENC_SUCCESS;
-}
-
-#else /* perform the search */
-
-/* This option #1 search is very similar to PV's MPEG4 motion search algorithm.
-  The search is done in hierarchical manner from 16x16 MB down to smaller and smaller
-  partition. At each level, a decision can be made to stop the search if the expected
-  prediction gain is not worth the computation. The decision can also be made at the finest
-  level for more fullsearch-like behavior with the price of heavier computation. */
-void AVCMBMotionSearch(AVCEncObject *encvid, uint8 *cur, uint8 *best_cand[],
-                       int i0, int j0, int type_pred, int FS_en, int *hp_guess)
-{
-    AVCCommonObj *video = encvid->common;
-    AVCPictureData *currPic = video->currPic;
-    AVCSeqParamSet *currSPS = video->currSeqParams;
-    AVCRateControl *rateCtrl = encvid->rateCtrl;
-    AVCMacroblock *currMB = video->currMB;
-    uint8 *ref, *cand, *ncand;
-    void *extra_info = encvid->sad_extra_info;
-    int mbnum = video->mbNum;
-    int width = currPic->width; /* 6/12/01, must be multiple of 16 */
-    int height = currPic->height;
-    AVCMV *mot16x16 = encvid->mot16x16;
-    int (*SAD_Macroblock)(uint8*, uint8*, int, void*) = encvid->functionPointer->SAD_Macroblock;
-
-    int range = rateCtrl->mvRange;
-
-    int lx = currPic->pitch; /*  padding */
-    int i, j, imin, jmin, ilow, ihigh, jlow, jhigh;
-    int d, dmin, dn[9];
-    int k;
-    int mvx[5], mvy[5];
-    int num_can, center_again;
-    int last_loc, new_loc = 0;
-    int step, max_step = range >> 1;
-    int next;
-
-    int cmvx, cmvy; /* estimated predicted MV */
-    int lev_idx;
-    int lambda_motion = encvid->lambda_motion;
-    uint8 *mvbits = encvid->mvbits;
-    int mvshift = 2;
-    int mvcost;
-
-    int min_sad = 65535;
-
-    ref = video->RefPicList0[DEFAULT_REF_IDX]->Sl; /* origin of actual frame */
-
-    /* have to initialize these params, necessary for interprediction part */
-    currMB->NumMbPart = 1;
-    currMB->SubMbPartHeight[0] = 16;
-    currMB->SubMbPartWidth[0] = 16;
-    currMB->NumSubMbPart[0] = 1;
-    currMB->ref_idx_L0[0] = currMB->ref_idx_L0[1] =
-                                currMB->ref_idx_L0[2] = currMB->ref_idx_L0[3] = DEFAULT_REF_IDX;
-    currMB->ref_idx_L1[0] = currMB->ref_idx_L1[1] =
-                                currMB->ref_idx_L1[2] = currMB->ref_idx_L1[3] = DEFAULT_REF_IDX;
-    currMB->RefIdx[0] = currMB->RefIdx[1] =
-                            currMB->RefIdx[2] = currMB->RefIdx[3] = video->RefPicList0[DEFAULT_REF_IDX]->RefIdx;
-
-    cur = encvid->currYMB; /* use smaller memory space for current MB */
-
-    /*  find limit of the search (adjusting search range)*/
-    lev_idx = mapLev2Idx[currSPS->level_idc];
-
-    /* we can make this part dynamic based on previous statistics */
-    ilow = i0 - range;
-    if (i0 - ilow > 2047) /* clip to conform with the standard */
-    {
-        ilow = i0 - 2047;
-    }
-    if (ilow < -13)  // change it from -15 to -13 because of 6-tap filter needs extra 2 lines.
-    {
-        ilow = -13;
-    }
-
-    ihigh = i0 + range - 1;
-    if (ihigh - i0 > 2047) /* clip to conform with the standard */
-    {
-        ihigh = i0 + 2047;
-    }
-    if (ihigh > width - 3)
-    {
-        ihigh = width - 3;  // change from width-1 to width-3 for the same reason as above
-    }
-
-    jlow = j0 - range;
-    if (j0 - jlow > MaxVmvR[lev_idx] - 1) /* clip to conform with the standard */
-    {
-        jlow = j0 - MaxVmvR[lev_idx] + 1;
-    }
-    if (jlow < -13)     // same reason as above
-    {
-        jlow = -13;
-    }
-
-    jhigh = j0 + range - 1;
-    if (jhigh - j0 > MaxVmvR[lev_idx] - 1) /* clip to conform with the standard */
-    {
-        jhigh = j0 + MaxVmvR[lev_idx] - 1;
-    }
-    if (jhigh > height - 3) // same reason as above
-    {
-        jhigh = height - 3;
-    }
-
-    /* find initial motion vector & predicted MV*/
-    AVCCandidateSelection(mvx, mvy, &num_can, i0 >> 4, j0 >> 4, encvid, type_pred, &cmvx, &cmvy);
-
-    imin = i0;
-    jmin = j0; /* needed for fullsearch */
-    ncand = ref + i0 + j0 * lx;
-
-    /* for first row of MB, fullsearch can be used */
-    if (FS_en)
-    {
-        *hp_guess = 0; /* no guess for fast half-pel */
-
-        dmin =  AVCFullSearch(encvid, ref, cur, &imin, &jmin, ilow, ihigh, jlow, jhigh, cmvx, cmvy);
-
-        ncand = ref + imin + jmin * lx;
-    }
-    else
-    {   /*       fullsearch the top row to only upto (0,3) MB */
-        /*       upto 30% complexity saving with the same complexity */
-        if (video->PrevRefFrameNum == 0 && j0 == 0 && i0 <= 64 && type_pred != 1)
-        {
-            *hp_guess = 0; /* no guess for fast half-pel */
-            dmin =  AVCFullSearch(encvid, ref, cur, &imin, &jmin, ilow, ihigh, jlow, jhigh, cmvx, cmvy);
-            ncand = ref + imin + jmin * lx;
-        }
-        else
-        {
-            /************** initialize candidate **************************/
-
-            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);
-                    mvcost = MV_COST(lambda_motion, mvshift, i - i0, j - j0, cmvx, cmvy);
-                    d +=  mvcost;
-
-                    if (d < dmin)
-                    {
-                        dmin = d;
-                        imin = i;
-                        jmin = j;
-                        ncand = cand;
-                        min_sad = d - mvcost; // for rate control
-                    }
-                }
-            }
-            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);
-                        mvcost = MV_COST(lambda_motion, mvshift, i - i0, j - j0, cmvx, cmvy);
-                        d +=  mvcost;
-
-                        if (d < dmin)
-                        {
-                            dmin = d;
-                            imin = i;
-                            jmin = j;
-                            ncand = cand;
-                            min_sad = d - mvcost; // for rate control
-                        }
-                    }
-                }
-            }
-
-            /******************* 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)
-            {
-
-                AVCMoveNeighborSAD(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);
-                            mvcost = MV_COST(lambda_motion, mvshift, i - i0, j - j0, cmvx, cmvy);
-                            d += mvcost;
-
-                            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;
-                                min_sad = d - mvcost; // for rate control
-                            }
-                        }
-                    }
-                    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)
-                AVCMoveNeighborSAD(dn, last_loc);
-
-            *hp_guess = AVCFindMin(dn);
-
-            encvid->rateCtrl->MADofMB[mbnum] = min_sad / 256.0;
-        }
-    }
-
-    mot16x16[mbnum].sad = dmin;
-    mot16x16[mbnum].x = (imin - i0) << 2;
-    mot16x16[mbnum].y = (jmin - j0) << 2;
-    best_cand[0] = ncand;
-
-    if (rateCtrl->subPelEnable) // always enable half-pel search
-    {
-        /* find half-pel resolution motion vector */
-        min_sad = AVCFindHalfPelMB(encvid, cur, mot16x16 + mbnum, best_cand[0], i0, j0, *hp_guess, cmvx, cmvy);
-
-        encvid->rateCtrl->MADofMB[mbnum] = min_sad / 256.0;
-
-
-        if (encvid->best_qpel_pos == -1)
-        {
-            ncand = encvid->hpel_cand[encvid->best_hpel_pos];
-        }
-        else
-        {
-            ncand = encvid->qpel_cand[encvid->best_qpel_pos];
-        }
-    }
-    else
-    {
-        encvid->rateCtrl->MADofMB[mbnum] = min_sad / 256.0;
-    }
-
-    /** do motion comp here for now */
-    ref = currPic->Sl + i0 + j0 * lx;
-    /* copy from the best result to current Picture */
-    for (j = 0; j < 16; j++)
-    {
-        for (i = 0; i < 16; i++)
-        {
-            *ref++ = *ncand++;
-        }
-        ref += (lx - 16);
-        ncand += 8;
-    }
-
-    return ;
-}
-
-#endif
-
-/*===============================================================================
-    Function:   AVCFullSearch
-    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 AVCFullSearch(AVCEncObject *encvid, uint8 *prev, uint8 *cur,
-                  int *imin, int *jmin, int ilow, int ihigh, int jlow, int jhigh,
-                  int cmvx, int cmvy)
-{
-    int range = encvid->rateCtrl->mvRange;
-    AVCPictureData *currPic = encvid->common->currPic;
-    uint8 *cand;
-    int i, j, k, l;
-    int d, dmin;
-    int i0 = *imin; /* current position */
-    int j0 = *jmin;
-    int (*SAD_Macroblock)(uint8*, uint8*, int, void*) = encvid->functionPointer->SAD_Macroblock;
-    void *extra_info = encvid->sad_extra_info;
-    int lx = currPic->pitch; /* with padding */
-
-    int offset = i0 + j0 * lx;
-
-    int lambda_motion = encvid->lambda_motion;
-    uint8 *mvbits = encvid->mvbits;
-    int mvshift = 2;
-    int mvcost;
-    int min_sad;
-
-    cand = prev + offset;
-
-    dmin  = (*SAD_Macroblock)(cand, cur, (65535 << 16) | lx, (void*)extra_info);
-    mvcost = MV_COST(lambda_motion, mvshift, 0, 0, cmvx, cmvy);
-    min_sad = dmin;
-    dmin += mvcost;
-
-    /* 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);
-                mvcost = MV_COST(lambda_motion, mvshift, i - i0, j - j0, cmvx, cmvy);
-                d +=  mvcost;
-
-                if (d < dmin)
-                {
-                    dmin = d;
-                    *imin = i;
-                    *jmin = j;
-                    min_sad = d - mvcost;
-                }
-            }
-
-            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;
-            }
-        }
-    }
-
-    encvid->rateCtrl->MADofMB[encvid->common->mbNum] = (min_sad / 256.0); // for rate control
-
-    return dmin;
-}
-
-/*===============================================================================
-    Function:   AVCCandidateSelection
-    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.
-                , 09/11/07, added return for modified predicted MV, this will be
-                    needed for both fast search and fullsearch.
-===============================================================================*/
-
-void AVCCandidateSelection(int *mvx, int *mvy, int *num_can, int imb, int jmb,
-                           AVCEncObject *encvid, int type_pred, int *cmvx, int *cmvy)
-{
-    AVCCommonObj *video = encvid->common;
-    AVCMV *mot16x16 = encvid->mot16x16;
-    AVCMV *pmot;
-    int mbnum = video->mbNum;
-    int mbwidth = video->PicWidthInMbs;
-    int mbheight = video->PicHeightInMbs;
-    int i, j, same, num1;
-
-    /* this part is for predicted MV */
-    int pmvA_x = 0, pmvA_y = 0, pmvB_x = 0, pmvB_y = 0, pmvC_x = 0, pmvC_y = 0;
-    int availA = 0, availB = 0, availC = 0;
-
-    *num_can = 0;
-
-    if (video->PrevRefFrameNum != 0) // previous frame is an IDR frame
-    {
-        /* Spatio-Temporal Candidate (five candidates) */
-        if (type_pred == 0) /* first pass */
-        {
-            pmot = &mot16x16[mbnum]; /* same coordinate previous frame */
-            mvx[(*num_can)] = (pmot->x) >> 2;
-            mvy[(*num_can)++] = (pmot->y) >> 2;
-            if (imb >= (mbwidth >> 1) && imb > 0)  /*left neighbor previous frame */
-            {
-                pmot = &mot16x16[mbnum-1];
-                mvx[(*num_can)] = (pmot->x) >> 2;
-                mvy[(*num_can)++] = (pmot->y) >> 2;
-            }
-            else if (imb + 1 < mbwidth)   /*right neighbor previous frame */
-            {
-                pmot = &mot16x16[mbnum+1];
-                mvx[(*num_can)] = (pmot->x) >> 2;
-                mvy[(*num_can)++] = (pmot->y) >> 2;
-            }
-
-            if (jmb < mbheight - 1)  /*bottom neighbor previous frame */
-            {
-                pmot = &mot16x16[mbnum+mbwidth];
-                mvx[(*num_can)] = (pmot->x) >> 2;
-                mvy[(*num_can)++] = (pmot->y) >> 2;
-            }
-            else if (jmb > 0)   /*upper neighbor previous frame */
-            {
-                pmot = &mot16x16[mbnum-mbwidth];
-                mvx[(*num_can)] = (pmot->x) >> 2;
-                mvy[(*num_can)++] = (pmot->y) >> 2;
-            }
-
-            if (imb > 0 && jmb > 0)  /* upper-left neighbor current frame*/
-            {
-                pmot = &mot16x16[mbnum-mbwidth-1];
-                mvx[(*num_can)] = (pmot->x) >> 2;
-                mvy[(*num_can)++] = (pmot->y) >> 2;
-            }
-            if (jmb > 0 && imb < mbheight - 1)  /* upper right neighbor current frame*/
-            {
-                pmot = &mot16x16[mbnum-mbwidth+1];
-                mvx[(*num_can)] = (pmot->x) >> 2;
-                mvy[(*num_can)++] = (pmot->y) >> 2;
-            }
-        }
-        else    /* second pass */
-            /* original ST1 algorithm */
-        {
-            pmot = &mot16x16[mbnum]; /* same coordinate previous frame */
-            mvx[(*num_can)] = (pmot->x) >> 2;
-            mvy[(*num_can)++] = (pmot->y) >> 2;
-
-            if (imb > 0)  /*left neighbor current frame */
-            {
-                pmot = &mot16x16[mbnum-1];
-                mvx[(*num_can)] = (pmot->x) >> 2;
-                mvy[(*num_can)++] = (pmot->y) >> 2;
-            }
-            if (jmb > 0)  /*upper neighbor current frame */
-            {
-                pmot = &mot16x16[mbnum-mbwidth];
-                mvx[(*num_can)] = (pmot->x) >> 2;
-                mvy[(*num_can)++] = (pmot->y) >> 2;
-            }
-            if (imb < mbwidth - 1)  /*right neighbor previous frame */
-            {
-                pmot = &mot16x16[mbnum+1];
-                mvx[(*num_can)] = (pmot->x) >> 2;
-                mvy[(*num_can)++] = (pmot->y) >> 2;
-            }
-            if (jmb < mbheight - 1)  /*bottom neighbor previous frame */
-            {
-                pmot = &mot16x16[mbnum+mbwidth];
-                mvx[(*num_can)] = (pmot->x) >> 2;
-                mvy[(*num_can)++] = (pmot->y) >> 2;
-            }
-        }
-
-        /* get predicted MV */
-        if (imb > 0)    /* get MV from left (A) neighbor either on current or previous frame */
-        {
-            availA = 1;
-            pmot = &mot16x16[mbnum-1];
-            pmvA_x = pmot->x;
-            pmvA_y = pmot->y;
-        }
-
-        if (jmb > 0) /* get MV from top (B) neighbor either on current or previous frame */
-        {
-            availB = 1;
-            pmot = &mot16x16[mbnum-mbwidth];
-            pmvB_x = pmot->x;
-            pmvB_y = pmot->y;
-
-            availC = 1;
-
-            if (imb < mbwidth - 1) /* get MV from top-right (C) neighbor of current frame */
-            {
-                pmot = &mot16x16[mbnum-mbwidth+1];
-            }
-            else /* get MV from top-left (D) neighbor of current frame */
-            {
-                pmot = &mot16x16[mbnum-mbwidth-1];
-            }
-            pmvC_x = pmot->x;
-            pmvC_y = pmot->y;
-        }
-
-    }
-    else  /* only Spatial Candidate (four candidates)*/
-    {
-        if (type_pred == 0) /*first pass*/
-        {
-            if (imb > 1)  /* neighbor two blocks away to the left */
-            {
-                pmot = &mot16x16[mbnum-2];
-                mvx[(*num_can)] = (pmot->x) >> 2;
-                mvy[(*num_can)++] = (pmot->y) >> 2;
-            }
-            if (imb > 0 && jmb > 0)  /* upper-left neighbor */
-            {
-                pmot = &mot16x16[mbnum-mbwidth-1];
-                mvx[(*num_can)] = (pmot->x) >> 2;
-                mvy[(*num_can)++] = (pmot->y) >> 2;
-            }
-            if (jmb > 0 && imb < mbheight - 1)  /* upper right neighbor */
-            {
-                pmot = &mot16x16[mbnum-mbwidth+1];
-                mvx[(*num_can)] = (pmot->x) >> 2;
-                mvy[(*num_can)++] = (pmot->y) >> 2;
-            }
-
-            /* get predicted MV */
-            if (imb > 1)    /* get MV from 2nd left (A) neighbor either of current frame */
-            {
-                availA = 1;
-                pmot = &mot16x16[mbnum-2];
-                pmvA_x = pmot->x;
-                pmvA_y = pmot->y;
-            }
-
-            if (jmb > 0 && imb > 0) /* get MV from top-left (B) neighbor of current frame */
-            {
-                availB = 1;
-                pmot = &mot16x16[mbnum-mbwidth-1];
-                pmvB_x = pmot->x;
-                pmvB_y = pmot->y;
-            }
-
-            if (jmb > 0 && imb < mbwidth - 1)
-            {
-                availC = 1;
-                pmot = &mot16x16[mbnum-mbwidth+1];
-                pmvC_x = pmot->x;
-                pmvC_y = pmot->y;
-            }
-        }
-//#ifdef SCENE_CHANGE_DETECTION
-        /* second pass (ST2 algorithm)*/
-        else
-        {
-            if (type_pred == 1) /*  4/7/01 */
-            {
-                if (imb > 0)  /*left neighbor current frame */
-                {
-                    pmot = &mot16x16[mbnum-1];
-                    mvx[(*num_can)] = (pmot->x) >> 2;
-                    mvy[(*num_can)++] = (pmot->y) >> 2;
-                }
-                if (jmb > 0)  /*upper neighbor current frame */
-                {
-                    pmot = &mot16x16[mbnum-mbwidth];
-                    mvx[(*num_can)] = (pmot->x) >> 2;
-                    mvy[(*num_can)++] = (pmot->y) >> 2;
-                }
-                if (imb < mbwidth - 1)  /*right neighbor current frame */
-                {
-                    pmot = &mot16x16[mbnum+1];
-                    mvx[(*num_can)] = (pmot->x) >> 2;
-                    mvy[(*num_can)++] = (pmot->y) >> 2;
-                }
-                if (jmb < mbheight - 1)  /*bottom neighbor current frame */
-                {
-                    pmot = &mot16x16[mbnum+mbwidth];
-                    mvx[(*num_can)] = (pmot->x) >> 2;
-                    mvy[(*num_can)++] = (pmot->y) >> 2;
-                }
-            }
-            //#else
-            else /* original ST1 algorithm */
-            {
-                if (imb > 0)  /*left neighbor current frame */
-                {
-                    pmot = &mot16x16[mbnum-1];
-                    mvx[(*num_can)] = (pmot->x) >> 2;
-                    mvy[(*num_can)++] = (pmot->y) >> 2;
-
-                    if (jmb > 0)  /*upper-left neighbor current frame */
-                    {
-                        pmot = &mot16x16[mbnum-mbwidth-1];
-                        mvx[(*num_can)] = (pmot->x) >> 2;
-                        mvy[(*num_can)++] = (pmot->y) >> 2;
-                    }
-
-                }
-                if (jmb > 0)  /*upper neighbor current frame */
-                {
-                    pmot = &mot16x16[mbnum-mbwidth];
-                    mvx[(*num_can)] = (pmot->x) >> 2;
-                    mvy[(*num_can)++] = (pmot->y) >> 2;
-
-                    if (imb < mbheight - 1)  /*upper-right neighbor current frame */
-                    {
-                        pmot = &mot16x16[mbnum-mbwidth+1];
-                        mvx[(*num_can)] = (pmot->x) >> 2;
-                        mvy[(*num_can)++] = (pmot->y) >> 2;
-                    }
-                }
-            }
-
-            /* get predicted MV */
-            if (imb > 0)    /* get MV from left (A) neighbor either on current or previous frame */
-            {
-                availA = 1;
-                pmot = &mot16x16[mbnum-1];
-                pmvA_x = pmot->x;
-                pmvA_y = pmot->y;
-            }
-
-            if (jmb > 0) /* get MV from top (B) neighbor either on current or previous frame */
-            {
-                availB = 1;
-                pmot = &mot16x16[mbnum-mbwidth];
-                pmvB_x = pmot->x;
-                pmvB_y = pmot->y;
-
-                availC = 1;
-
-                if (imb < mbwidth - 1) /* get MV from top-right (C) neighbor of current frame */
-                {
-                    pmot = &mot16x16[mbnum-mbwidth+1];
-                }
-                else /* get MV from top-left (D) neighbor of current frame */
-                {
-                    pmot = &mot16x16[mbnum-mbwidth-1];
-                }
-                pmvC_x = pmot->x;
-                pmvC_y = pmot->y;
-            }
-        }
-//#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 (AVC_ABS(mvx[i] - mvx[j]) + AVC_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)++;
-        }
-    }
-
-    if (num1 == 5 && *num_can == 1)
-        *num_can = ALL_CAND_EQUAL; /* all are equal */
-
-    /* calculate predicted MV */
-
-    if (availA && !(availB || availC))
-    {
-        *cmvx = pmvA_x;
-        *cmvy = pmvA_y;
-    }
-    else
-    {
-        *cmvx = AVC_MEDIAN(pmvA_x, pmvB_x, pmvC_x);
-        *cmvy = AVC_MEDIAN(pmvA_y, pmvB_y, pmvC_y);
-    }
-
-    return ;
-}
-
-
-/*************************************************************
-    Function:   AVCMoveNeighborSAD
-    Date:       3/27/01
-    Purpose:    Move neighboring SAD around when center has shifted
-*************************************************************/
-
-void AVCMoveNeighborSAD(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 AVCFindMin(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/avc/enc/src/rate_control.cpp b/media/libstagefright/codecs/avc/enc/src/rate_control.cpp
deleted file mode 100644
index 09dcc28..0000000
--- a/media/libstagefright/codecs/avc/enc/src/rate_control.cpp
+++ /dev/null
@@ -1,979 +0,0 @@
-/* ------------------------------------------------------------------
- * 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 "avcenc_lib.h"
-#include <math.h>
-
-/* rate control variables */
-#define RC_MAX_QUANT 51
-#define RC_MIN_QUANT 0   //cap to 10 to prevent rate fluctuation    
-
-#define MAD_MIN 1 /* handle the case of devision by zero in RC */
-
-
-/* local functions */
-double QP2Qstep(int QP);
-int Qstep2QP(double Qstep);
-
-double ComputeFrameMAD(AVCCommonObj *video, AVCRateControl *rateCtrl);
-
-void targetBitCalculation(AVCEncObject *encvid, AVCCommonObj *video, AVCRateControl *rateCtrl, MultiPass *pMP);
-
-void calculateQuantizer_Multipass(AVCEncObject *encvid, AVCCommonObj *video,
-                                  AVCRateControl *rateCtrl, MultiPass *pMP);
-
-void updateRC_PostProc(AVCRateControl *rateCtrl, MultiPass *pMP);
-
-void AVCSaveRDSamples(MultiPass *pMP, int counter_samples);
-
-void updateRateControl(AVCRateControl *rateControl, int nal_type);
-
-int GetAvgFrameQP(AVCRateControl *rateCtrl)
-{
-    return rateCtrl->Qc;
-}
-
-AVCEnc_Status RCDetermineFrameNum(AVCEncObject *encvid, AVCRateControl *rateCtrl, uint32 modTime, uint *frameNum)
-{
-    AVCCommonObj *video = encvid->common;
-    AVCSliceHeader *sliceHdr = video->sliceHdr;
-    uint32 modTimeRef = encvid->modTimeRef;
-    int32  currFrameNum ;
-    int  frameInc;
-
-
-    /* check with the buffer fullness to make sure that we have enough bits to encode this frame */
-    /* we can use a threshold to guarantee minimum picture quality */
-    /**********************************/
-
-    /* for now, the default is to encode every frame, To Be Changed */
-    if (rateCtrl->first_frame)
-    {
-        encvid->modTimeRef = modTime;
-        encvid->wrapModTime = 0;
-        encvid->prevFrameNum = 0;
-        encvid->prevProcFrameNum = 0;
-
-        *frameNum = 0;
-
-        /* set frame type to IDR-frame */
-        video->nal_unit_type = AVC_NALTYPE_IDR;
-        sliceHdr->slice_type = AVC_I_ALL_SLICE;
-        video->slice_type = AVC_I_SLICE;
-
-        return AVCENC_SUCCESS;
-    }
-    else
-    {
-        if (modTime < modTimeRef) /* modTime wrapped around */
-        {
-            encvid->wrapModTime += ((uint32)0xFFFFFFFF - modTimeRef) + 1;
-            encvid->modTimeRef = modTimeRef = 0;
-        }
-        modTime += encvid->wrapModTime; /* wrapModTime is non zero after wrap-around */
-
-        currFrameNum = (int32)(((modTime - modTimeRef) * rateCtrl->frame_rate + 200) / 1000); /* add small roundings */
-
-        if (currFrameNum <= (int32)encvid->prevProcFrameNum)
-        {
-            return AVCENC_FAIL;  /* this is a late frame do not encode it */
-        }
-
-        frameInc = currFrameNum - encvid->prevProcFrameNum;
-
-        if (frameInc < rateCtrl->skip_next_frame + 1)
-        {
-            return AVCENC_FAIL;  /* frame skip required to maintain the target bit rate. */
-        }
-
-        RCUpdateBuffer(video, rateCtrl, frameInc - rateCtrl->skip_next_frame);  /* in case more frames dropped */
-
-        *frameNum = currFrameNum;
-
-        /* This part would be similar to DetermineVopType of m4venc */
-        if ((*frameNum >= (uint)rateCtrl->idrPeriod && rateCtrl->idrPeriod > 0) || (*frameNum > video->MaxFrameNum)) /* first frame or IDR*/
-        {
-            /* set frame type to IDR-frame */
-            if (rateCtrl->idrPeriod)
-            {
-                encvid->modTimeRef += (uint32)(rateCtrl->idrPeriod * 1000 / rateCtrl->frame_rate);
-                *frameNum -= rateCtrl->idrPeriod;
-            }
-            else
-            {
-                encvid->modTimeRef += (uint32)(video->MaxFrameNum * 1000 / rateCtrl->frame_rate);
-                *frameNum -= video->MaxFrameNum;
-            }
-
-            video->nal_unit_type = AVC_NALTYPE_IDR;
-            sliceHdr->slice_type = AVC_I_ALL_SLICE;
-            video->slice_type = AVC_I_SLICE;
-            encvid->prevProcFrameNum = *frameNum;
-        }
-        else
-        {
-            video->nal_unit_type = AVC_NALTYPE_SLICE;
-            sliceHdr->slice_type = AVC_P_ALL_SLICE;
-            video->slice_type = AVC_P_SLICE;
-            encvid->prevProcFrameNum = currFrameNum;
-        }
-
-    }
-
-    return AVCENC_SUCCESS;
-}
-
-void RCUpdateBuffer(AVCCommonObj *video, AVCRateControl *rateCtrl, int frameInc)
-{
-    int tmp;
-    MultiPass *pMP = rateCtrl->pMP;
-
-    OSCL_UNUSED_ARG(video);
-
-    if (rateCtrl->rcEnable == TRUE)
-    {
-        if (frameInc > 1)
-        {
-            tmp = rateCtrl->bitsPerFrame * (frameInc - 1);
-            rateCtrl->VBV_fullness -= tmp;
-            pMP->counter_BTsrc += 10 * (frameInc - 1);
-
-            /* Check buffer underflow */
-            if (rateCtrl->VBV_fullness < rateCtrl->low_bound)
-            {
-                rateCtrl->VBV_fullness = rateCtrl->low_bound; // -rateCtrl->Bs/2;
-                rateCtrl->TMN_W = rateCtrl->VBV_fullness - rateCtrl->low_bound;
-                pMP->counter_BTsrc = pMP->counter_BTdst + (int)((OsclFloat)(rateCtrl->Bs / 2 - rateCtrl->low_bound) / 2.0 / (pMP->target_bits_per_frame / 10));
-            }
-        }
-    }
-}
-
-
-AVCEnc_Status InitRateControlModule(AVCHandle *avcHandle)
-{
-    AVCEncObject *encvid = (AVCEncObject*) avcHandle->AVCObject;
-    AVCCommonObj *video = encvid->common;
-    AVCRateControl *rateCtrl = encvid->rateCtrl;
-    double L1, L2, L3, bpp;
-    int qp;
-    int i;
-
-    rateCtrl->basicUnit = video->PicSizeInMbs;
-
-    rateCtrl->MADofMB = (double*) avcHandle->CBAVC_Malloc(encvid->avcHandle->userData,
-                        video->PicSizeInMbs * sizeof(double), DEFAULT_ATTR);
-
-    if (!rateCtrl->MADofMB)
-    {
-        goto CLEANUP_RC;
-    }
-
-    if (rateCtrl->rcEnable == TRUE)
-    {
-        rateCtrl->pMP = (MultiPass*) avcHandle->CBAVC_Malloc(encvid->avcHandle->userData, sizeof(MultiPass), DEFAULT_ATTR);
-        if (!rateCtrl->pMP)
-        {
-            goto CLEANUP_RC;
-        }
-        rateCtrl->pMP->encoded_frames = -1; /* forget about the very first I frame */
-
-        /* RDInfo **pRDSamples */
-        rateCtrl->pMP->pRDSamples = (RDInfo **)avcHandle->CBAVC_Malloc(encvid->avcHandle->userData, (30 * sizeof(RDInfo *)), DEFAULT_ATTR);
-        if (!rateCtrl->pMP->pRDSamples)
-        {
-            goto CLEANUP_RC;
-        }
-
-        for (i = 0; i < 30; i++)
-        {
-            rateCtrl->pMP->pRDSamples[i] = (RDInfo *)avcHandle->CBAVC_Malloc(encvid->avcHandle->userData, (32 * sizeof(RDInfo)), DEFAULT_ATTR);
-            if (!rateCtrl->pMP->pRDSamples[i])
-            {
-                goto CLEANUP_RC;
-            }
-        }
-        rateCtrl->pMP->frameRange = (int)(rateCtrl->frame_rate * 1.0); /* 1.0s time frame*/
-        rateCtrl->pMP->frameRange = AVC_MAX(rateCtrl->pMP->frameRange, 5);
-        rateCtrl->pMP->frameRange = AVC_MIN(rateCtrl->pMP->frameRange, 30);
-
-        rateCtrl->pMP->framePos = -1;
-
-
-        rateCtrl->bitsPerFrame = (int32)(rateCtrl->bitRate / rateCtrl->frame_rate);
-
-        /* BX rate control */
-        rateCtrl->skip_next_frame = 0; /* must be initialized */
-
-        rateCtrl->Bs = rateCtrl->cpbSize;
-        rateCtrl->TMN_W = 0;
-        rateCtrl->VBV_fullness = (int)(rateCtrl->Bs * 0.5); /* rateCtrl->Bs */
-        rateCtrl->encoded_frames = 0;
-
-        rateCtrl->TMN_TH = rateCtrl->bitsPerFrame;
-
-        rateCtrl->max_BitVariance_num = (int)((OsclFloat)(rateCtrl->Bs - rateCtrl->VBV_fullness) / (rateCtrl->bitsPerFrame / 10.0)) - 5;
-        if (rateCtrl->max_BitVariance_num < 0) rateCtrl->max_BitVariance_num += 5;
-
-        // Set the initial buffer fullness
-        /* According to the spec, the initial buffer fullness needs to be set to 1/3 */
-        rateCtrl->VBV_fullness = (int)(rateCtrl->Bs / 3.0 - rateCtrl->Bs / 2.0); /* the buffer range is [-Bs/2, Bs/2] */
-        rateCtrl->pMP->counter_BTsrc = (int)((rateCtrl->Bs / 2.0 - rateCtrl->Bs / 3.0) / (rateCtrl->bitsPerFrame / 10.0));
-        rateCtrl->TMN_W = (int)(rateCtrl->VBV_fullness + rateCtrl->pMP->counter_BTsrc * (rateCtrl->bitsPerFrame / 10.0));
-
-        rateCtrl->low_bound = -rateCtrl->Bs / 2;
-        rateCtrl->VBV_fullness_offset = 0;
-
-        /* Setting the bitrate and framerate */
-        rateCtrl->pMP->bitrate = rateCtrl->bitRate;
-        rateCtrl->pMP->framerate = rateCtrl->frame_rate;
-        rateCtrl->pMP->target_bits_per_frame = rateCtrl->pMP->bitrate / rateCtrl->pMP->framerate;
-
-        /*compute the initial QP*/
-        bpp = 1.0 * rateCtrl->bitRate / (rateCtrl->frame_rate * (video->PicSizeInMbs << 8));
-        if (video->PicWidthInSamplesL == 176)
-        {
-            L1 = 0.1;
-            L2 = 0.3;
-            L3 = 0.6;
-        }
-        else if (video->PicWidthInSamplesL == 352)
-        {
-            L1 = 0.2;
-            L2 = 0.6;
-            L3 = 1.2;
-        }
-        else
-        {
-            L1 = 0.6;
-            L2 = 1.4;
-            L3 = 2.4;
-        }
-
-        if (rateCtrl->initQP == 0)
-        {
-            if (bpp <= L1)
-                qp = 35;
-            else if (bpp <= L2)
-                qp = 25;
-            else if (bpp <= L3)
-                qp = 20;
-            else
-                qp = 15;
-            rateCtrl->initQP = qp;
-        }
-
-        rateCtrl->Qc = rateCtrl->initQP;
-    }
-
-    return AVCENC_SUCCESS;
-
-CLEANUP_RC:
-
-    CleanupRateControlModule(avcHandle);
-    return AVCENC_MEMORY_FAIL;
-
-}
-
-
-void CleanupRateControlModule(AVCHandle *avcHandle)
-{
-    AVCEncObject *encvid = (AVCEncObject*) avcHandle->AVCObject;
-    AVCRateControl *rateCtrl = encvid->rateCtrl;
-    int i;
-
-    if (rateCtrl->MADofMB)
-    {
-        avcHandle->CBAVC_Free(avcHandle->userData, rateCtrl->MADofMB);
-    }
-
-    if (rateCtrl->pMP)
-    {
-        if (rateCtrl->pMP->pRDSamples)
-        {
-            for (i = 0; i < 30; i++)
-            {
-                if (rateCtrl->pMP->pRDSamples[i])
-                {
-                    avcHandle->CBAVC_Free(avcHandle->userData, rateCtrl->pMP->pRDSamples[i]);
-                }
-            }
-            avcHandle->CBAVC_Free(avcHandle->userData, rateCtrl->pMP->pRDSamples);
-        }
-        avcHandle->CBAVC_Free(avcHandle->userData, rateCtrl->pMP);
-    }
-
-    return ;
-}
-
-void RCInitGOP(AVCEncObject *encvid)
-{
-    /* in BX RC, there's no GOP-level RC */
-
-    OSCL_UNUSED_ARG(encvid);
-
-    return ;
-}
-
-
-void RCInitFrameQP(AVCEncObject *encvid)
-{
-    AVCCommonObj *video = encvid->common;
-    AVCRateControl *rateCtrl = encvid->rateCtrl;
-    AVCPicParamSet *picParam = video->currPicParams;
-    MultiPass *pMP = rateCtrl->pMP;
-
-    if (rateCtrl->rcEnable == TRUE)
-    {
-        /* frame layer rate control */
-        if (rateCtrl->encoded_frames == 0)
-        {
-            video->QPy = rateCtrl->Qc = rateCtrl->initQP;
-        }
-        else
-        {
-            calculateQuantizer_Multipass(encvid, video, rateCtrl, pMP);
-            video->QPy = rateCtrl->Qc;
-        }
-
-        rateCtrl->NumberofHeaderBits = 0;
-        rateCtrl->NumberofTextureBits = 0;
-        rateCtrl->numFrameBits = 0; // reset
-
-        /* update pMP->framePos */
-        if (++pMP->framePos == pMP->frameRange) pMP->framePos = 0;
-
-        if (rateCtrl->T == 0)
-        {
-            pMP->counter_BTdst = (int)(rateCtrl->frame_rate * 7.5 + 0.5); /* 0.75s time frame */
-            pMP->counter_BTdst = AVC_MIN(pMP->counter_BTdst, (int)(rateCtrl->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 = AVC_MAX(pMP->counter_BTdst, (int)((rateCtrl->Bs / 2 - rateCtrl->VBV_fullness) * 0.30 / (rateCtrl->TMN_TH / 10.0) + 0.5)); /* At least 30% of VBV buffer size/2 */
-            pMP->counter_BTdst = AVC_MIN(pMP->counter_BTdst, 20); /* Limit the target to be smaller than 3C */
-
-            pMP->target_bits = rateCtrl->T = rateCtrl->TMN_TH = (int)(rateCtrl->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 = rateCtrl->T;
-        pMP->QP  = video->QPy;
-
-        pMP->mad = (OsclFloat)rateCtrl->totalSAD / video->PicSizeInMbs; //ComputeFrameMAD(video, rateCtrl);
-        if (pMP->mad < MAD_MIN) pMP->mad = MAD_MIN; /* MAD_MIN is defined as 1 in mp4def.h */
-
-        pMP->bitrate = rateCtrl->bitRate; /* calculated in RCVopQPSetting */
-        pMP->framerate = rateCtrl->frame_rate;
-
-        /* first pass encoding */
-        pMP->nRe_Quantized = 0;
-
-    } // rcEnable
-    else
-    {
-        video->QPy = rateCtrl->initQP;
-    }
-
-//  printf(" %d ",video->QPy);
-
-    if (video->CurrPicNum == 0 && encvid->outOfBandParamSet == FALSE)
-    {
-        picParam->pic_init_qs_minus26 = 0;
-        picParam->pic_init_qp_minus26 = video->QPy - 26;
-    }
-
-    // need this for motion estimation
-    encvid->lambda_mode = QP2QUANT[AVC_MAX(0, video->QPy-SHIFT_QP)];
-    encvid->lambda_motion = LAMBDA_FACTOR(encvid->lambda_mode);
-    return ;
-}
-
-/* Mad based variable bit allocation + QP calculation with a new quadratic method */
-void calculateQuantizer_Multipass(AVCEncObject *encvid, AVCCommonObj *video,
-                                  AVCRateControl *rateCtrl, MultiPass *pMP)
-{
-    int prev_actual_bits = 0, curr_target, /*pos=0,*/i, j;
-    OsclFloat Qstep, prev_QP = 0.625;
-
-    OsclFloat curr_mad, prev_mad, curr_RD, prev_RD, average_mad, aver_QP;
-
-    /* Mad based variable bit allocation */
-    targetBitCalculation(encvid, video, rateCtrl, pMP);
-
-    if (rateCtrl->T <= 0 || rateCtrl->totalSAD == 0)
-    {
-        if (rateCtrl->T < 0)    rateCtrl->Qc = RC_MAX_QUANT;
-        return;
-    }
-
-    /* ---------------------------------------------------------------------------------------------------*/
-    /* current frame QP estimation */
-    curr_target = rateCtrl->T;
-    curr_mad = (OsclFloat)rateCtrl->totalSAD / video->PicSizeInMbs;
-    if (curr_mad < MAD_MIN) curr_mad = MAD_MIN; /* MAD_MIN is defined as 1 in mp4def.h */
-    curr_RD  = (OsclFloat)curr_target / curr_mad;
-
-    if (rateCtrl->skip_next_frame == -1) // previous was skipped
-    {
-        i = pMP->framePos;
-        prev_mad = pMP->pRDSamples[i][0].mad;
-        prev_QP = pMP->pRDSamples[i][0].QP;
-        prev_actual_bits = pMP->pRDSamples[i][0].actual_bits;
-    }
-    else
-    {
-        /* Another version of search the optimal point */
-        prev_mad = 0.0;
-        i = 0;
-        while (i < pMP->frameRange && prev_mad < 0.001) /* find first one with nonzero prev_mad */
-        {
-            prev_mad = pMP->pRDSamples[i][0].mad;
-            i++;
-        }
-
-        if (i < pMP->frameRange)
-        {
-            prev_actual_bits = pMP->pRDSamples[i-1][0].actual_bits;
-
-            for (j = 0; i < pMP->frameRange; i++)
-            {
-                if (pMP->pRDSamples[i][0].mad != 0 &&
-                        AVC_ABS(prev_mad - curr_mad) > AVC_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 = QP2Qstep(pMP->pRDSamples[j][0].QP);
-
-            for (i = 1; i < pMP->samplesPerFrame[j]; i++)
-            {
-                if (AVC_ABS(prev_actual_bits - curr_target) > AVC_ABS(pMP->pRDSamples[j][i].actual_bits - curr_target))
-                {
-                    prev_actual_bits = pMP->pRDSamples[j][i].actual_bits;
-                    prev_QP = QP2Qstep(pMP->pRDSamples[j][i].QP);
-                }
-            }
-        }
-    }
-
-    // quadratic approximation
-    if (prev_mad > 0.001) // only when prev_mad is greater than 0, otherwise keep using the same QP
-    {
-        prev_RD = (OsclFloat)prev_actual_bits / prev_mad;
-        //rateCtrl->Qc = (Int)(prev_QP * sqrt(prev_actual_bits/curr_target) + 0.4);
-        if (prev_QP == 0.625) // added this to allow getting out of QP = 0 easily
-        {
-            Qstep = (int)(prev_RD / curr_RD + 0.5);
-        }
-        else
-        {
-            //      rateCtrl->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)
-                Qstep = (int)(prev_QP * (sqrt(prev_RD / curr_RD) + prev_RD / curr_RD) / 2.0 + 0.9); /* Quadratic and linear approximation */
-            else
-                Qstep = (int)(prev_QP * (sqrt(prev_RD / curr_RD) + pow(prev_RD / curr_RD, 1.0 / 3.0)) / 2.0 + 0.9);
-        }
-        // 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) && (rateCtrl->Qc < 12))   rateCtrl->Qc = 12;
-        //  else    if((curr_mad < 128) && (rateCtrl->Qc < 3)) rateCtrl->Qc = 3;
-
-        rateCtrl->Qc = Qstep2QP(Qstep);
-
-        if (rateCtrl->Qc < RC_MIN_QUANT) rateCtrl->Qc = RC_MIN_QUANT;
-        if (rateCtrl->Qc > RC_MAX_QUANT)    rateCtrl->Qc = RC_MAX_QUANT;
-    }
-
-    /* active bit resource protection */
-    aver_QP = (pMP->encoded_frames == 0 ? 0 : pMP->sum_QP / (OsclFloat)pMP->encoded_frames);
-    average_mad = (pMP->encoded_frames == 0 ? 0 : pMP->sum_mad / (OsclFloat)pMP->encoded_frames); /* this function is called from the scond encoded frame*/
-    if (pMP->diff_counter == 0 &&
-            ((OsclFloat)rateCtrl->Qc <= aver_QP*1.1 || curr_mad <= average_mad*1.1) &&
-            pMP->counter_BTsrc <= (pMP->counter_BTdst + (int)(pMP->framerate*1.0 + 0.5)))
-    {
-        rateCtrl->TMN_TH -= (int)(pMP->target_bits_per_frame / 10.0);
-        rateCtrl->T = rateCtrl->TMN_TH - rateCtrl->TMN_W;
-        pMP->counter_BTsrc++;
-        pMP->diff_counter--;
-    }
-
-}
-
-void targetBitCalculation(AVCEncObject *encvid, AVCCommonObj *video, AVCRateControl *rateCtrl, MultiPass *pMP)
-{
-    OSCL_UNUSED_ARG(encvid);
-    OsclFloat 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 */
-
-    /* some stuff about frame dropping remained here to be done because pMP cannot be inserted into updateRateControl()*/
-    updateRC_PostProc(rateCtrl, pMP);
-
-    /* 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 = (OsclFloat)rateCtrl->totalSAD / video->PicSizeInMbs;
-    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/(OsclFloat)(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)
-        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)(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)(sqrt(curr_mad / (pMP->aver_mad + 0.0001)) * 10 + 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)(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)(sqrt(curr_mad / (pMP->aver_mad_prev + 0.0001)) * 10 + 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)((rateCtrl->Bs / 2 - rateCtrl->VBV_fullness) * 0.6 / (pMP->target_bits_per_frame / 10)); /* rateCtrl->Bs */
-    diff_counter_BTsrc =  AVC_MIN(diff_counter_BTsrc, bound);
-    diff_counter_BTdst =  AVC_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;  -- For Low delay */
-
-    diff_counter_BTsrc =  AVC_MIN(diff_counter_BTsrc, bound);
-    diff_counter_BTdst =  AVC_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 (AVC_ABS(prev_counter_diff) >= rateCtrl->max_BitVariance_num || AVC_ABS(curr_counter_diff) >= rateCtrl->max_BitVariance_num)
-    {   //diff_counter_BTsrc = diff_counter_BTdst = 0;
-
-        if (curr_counter_diff > rateCtrl->max_BitVariance_num && diff_counter_BTdst)
-        {
-            diff_counter_BTdst = (rateCtrl->max_BitVariance_num - prev_counter_diff) + diff_counter_BTsrc;
-            if (diff_counter_BTdst < 0) diff_counter_BTdst = 0;
-        }
-
-        else if (curr_counter_diff < -rateCtrl->max_BitVariance_num && diff_counter_BTsrc)
-        {
-            diff_counter_BTsrc = diff_counter_BTdst - (-rateCtrl->max_BitVariance_num - prev_counter_diff);
-            if (diff_counter_BTsrc < 0) diff_counter_BTsrc = 0;
-        }
-    }
-
-
-    /*3.diff_counter_BTsrc, diff_counter_BTdst ==> TMN_TH */
-    rateCtrl->TMN_TH = (int)(pMP->target_bits_per_frame);
-    pMP->diff_counter = 0;
-
-    if (diff_counter_BTsrc)
-    {
-        rateCtrl->TMN_TH -= (int)(pMP->target_bits_per_frame * diff_counter_BTsrc * 0.1);
-        pMP->diff_counter = -diff_counter_BTsrc;
-    }
-    else if (diff_counter_BTdst)
-    {
-        rateCtrl->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 */
-    rateCtrl->T = rateCtrl->TMN_TH - rateCtrl->TMN_W;
-
-    return ;
-}
-
-void updateRC_PostProc(AVCRateControl *rateCtrl, MultiPass *pMP)
-{
-    if (rateCtrl->skip_next_frame > 0) /* skip next frame */
-    {
-        pMP->counter_BTsrc += 10 * rateCtrl->skip_next_frame;
-
-    }
-    else if (rateCtrl->skip_next_frame == -1) /* 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) / (pMP->encoded_frames - 1 + 0.0001);
-        pMP->sum_QP  -= pMP->QP;
-        pMP->encoded_frames --;
-    }
-    /* some stuff in update VBV_fullness remains here */
-    //if(rateCtrl->VBV_fullness < -rateCtrl->Bs/2) /* rateCtrl->Bs */
-    if (rateCtrl->VBV_fullness < rateCtrl->low_bound)
-    {
-        rateCtrl->VBV_fullness = rateCtrl->low_bound; // -rateCtrl->Bs/2;
-        rateCtrl->TMN_W = rateCtrl->VBV_fullness - rateCtrl->low_bound;
-        pMP->counter_BTsrc = pMP->counter_BTdst + (int)((OsclFloat)(rateCtrl->Bs / 2 - rateCtrl->low_bound) / 2.0 / (pMP->target_bits_per_frame / 10));
-    }
-}
-
-
-void RCInitChromaQP(AVCEncObject *encvid)
-{
-    AVCCommonObj *video = encvid->common;
-    AVCMacroblock *currMB = video->currMB;
-    int q_bits;
-
-    /* we have to do the same thing for AVC_CLIP3(0,51,video->QSy) */
-
-    video->QPy_div_6 = (currMB->QPy * 43) >> 8;
-    video->QPy_mod_6 = currMB->QPy - 6 * video->QPy_div_6;
-    currMB->QPc = video->QPc = mapQPi2QPc[AVC_CLIP3(0, 51, currMB->QPy + video->currPicParams->chroma_qp_index_offset)];
-    video->QPc_div_6 = (video->QPc * 43) >> 8;
-    video->QPc_mod_6 = video->QPc - 6 * video->QPc_div_6;
-
-    /* pre-calculate this to save computation */
-    q_bits = 4 + video->QPy_div_6;
-    if (video->slice_type == AVC_I_SLICE)
-    {
-        encvid->qp_const = 682 << q_bits;       // intra
-    }
-    else
-    {
-        encvid->qp_const = 342 << q_bits;       // inter
-    }
-
-    q_bits = 4 + video->QPc_div_6;
-    if (video->slice_type == AVC_I_SLICE)
-    {
-        encvid->qp_const_c = 682 << q_bits;    // intra
-    }
-    else
-    {
-        encvid->qp_const_c = 342 << q_bits;    // inter
-    }
-
-    encvid->lambda_mode = QP2QUANT[AVC_MAX(0, currMB->QPy-SHIFT_QP)];
-    encvid->lambda_motion = LAMBDA_FACTOR(encvid->lambda_mode);
-
-    return ;
-}
-
-
-void RCInitMBQP(AVCEncObject *encvid)
-{
-    AVCCommonObj *video =  encvid->common;
-    AVCMacroblock *currMB = video->currMB;
-
-    currMB->QPy = video->QPy; /* set to previous value or picture level */
-
-    RCInitChromaQP(encvid);
-
-}
-
-void RCPostMB(AVCCommonObj *video, AVCRateControl *rateCtrl, int num_header_bits, int num_texture_bits)
-{
-    OSCL_UNUSED_ARG(video);
-    rateCtrl->numMBHeaderBits = num_header_bits;
-    rateCtrl->numMBTextureBits = num_texture_bits;
-    rateCtrl->NumberofHeaderBits += rateCtrl->numMBHeaderBits;
-    rateCtrl->NumberofTextureBits += rateCtrl->numMBTextureBits;
-}
-
-void RCRestoreQP(AVCMacroblock *currMB, AVCCommonObj *video, AVCEncObject *encvid)
-{
-    currMB->QPy = video->QPy; /* use previous QP */
-    RCInitChromaQP(encvid);
-
-    return ;
-}
-
-
-void RCCalculateMAD(AVCEncObject *encvid, AVCMacroblock *currMB, uint8 *orgL, int orgPitch)
-{
-    AVCCommonObj *video = encvid->common;
-    AVCRateControl *rateCtrl = encvid->rateCtrl;
-    uint32 dmin_lx;
-
-    if (rateCtrl->rcEnable == TRUE)
-    {
-        if (currMB->mb_intra)
-        {
-            if (currMB->mbMode == AVC_I16)
-            {
-                dmin_lx = (0xFFFF << 16) | orgPitch;
-                rateCtrl->MADofMB[video->mbNum] = AVCSAD_Macroblock_C(orgL,
-                                                  encvid->pred_i16[currMB->i16Mode], dmin_lx, NULL);
-            }
-            else /* i4 */
-            {
-                rateCtrl->MADofMB[video->mbNum] = encvid->i4_sad / 256.;
-            }
-        }
-        /* for INTER, we have already saved it with the MV search */
-    }
-
-    return ;
-}
-
-
-
-AVCEnc_Status RCUpdateFrame(AVCEncObject *encvid)
-{
-    AVCCommonObj *video = encvid->common;
-    AVCRateControl *rateCtrl = encvid->rateCtrl;
-    AVCEnc_Status status = AVCENC_SUCCESS;
-    MultiPass *pMP = rateCtrl->pMP;
-    int diff_BTCounter;
-    int nal_type = video->nal_unit_type;
-
-    /* update the complexity weight of I, P, B frame */
-
-    if (rateCtrl->rcEnable == TRUE)
-    {
-        pMP->actual_bits = rateCtrl->numFrameBits;
-        pMP->mad = (OsclFloat)rateCtrl->totalSAD / video->PicSizeInMbs; //ComputeFrameMAD(video, rateCtrl);
-
-        AVCSaveRDSamples(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)((OsclFloat)(rateCtrl->TMN_TH - rateCtrl->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 */
-
-        rateCtrl->TMN_TH -= (int)((OsclFloat)pMP->bitrate / (pMP->framerate + 0.0001) * (diff_BTCounter * 0.1));
-        rateCtrl->T = pMP->target_bits = rateCtrl->TMN_TH - rateCtrl->TMN_W;
-        pMP->diff_counter -= diff_BTCounter;
-
-        rateCtrl->Rc = rateCtrl->numFrameBits;  /* Total Bits for current frame */
-        rateCtrl->Hc = rateCtrl->NumberofHeaderBits;    /* Total Bits in Header and Motion Vector */
-
-        /* BX_RC */
-        updateRateControl(rateCtrl, nal_type);
-        if (rateCtrl->skip_next_frame == -1) // skip current frame
-        {
-            status = AVCENC_SKIPPED_PICTURE;
-        }
-    }
-
-    rateCtrl->first_frame = 0;  // reset here after we encode the first frame.
-
-    return status;
-}
-
-void AVCSaveRDSamples(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 = (OsclFloat)pMP->actual_bits / (pMP->mad + 0.0001);
-
-    return ;
-}
-
-void updateRateControl(AVCRateControl *rateCtrl, int nal_type)
-{
-    int  frame_bits;
-    MultiPass *pMP = rateCtrl->pMP;
-
-    /* BX rate contro\l */
-    frame_bits = (int)(rateCtrl->bitRate / rateCtrl->frame_rate);
-    rateCtrl->TMN_W += (rateCtrl->Rc - rateCtrl->TMN_TH);
-    rateCtrl->VBV_fullness += (rateCtrl->Rc - frame_bits); //rateCtrl->Rp);
-    //if(rateCtrl->VBV_fullness < 0) rateCtrl->VBV_fullness = -1;
-
-    rateCtrl->encoded_frames++;
-
-    /* frame dropping */
-    rateCtrl->skip_next_frame = 0;
-
-    if ((rateCtrl->VBV_fullness > rateCtrl->Bs / 2) && nal_type != AVC_NALTYPE_IDR) /* skip the current frame */ /* rateCtrl->Bs */
-    {
-        rateCtrl->TMN_W -= (rateCtrl->Rc - rateCtrl->TMN_TH);
-        rateCtrl->VBV_fullness -= rateCtrl->Rc;
-        rateCtrl->skip_next_frame = -1;
-    }
-    else if ((OsclFloat)(rateCtrl->VBV_fullness - rateCtrl->VBV_fullness_offset) > (rateCtrl->Bs / 2 - rateCtrl->VBV_fullness_offset)*0.95) /* skip next frame */
-    {
-        rateCtrl->VBV_fullness -= frame_bits; //rateCtrl->Rp;
-        rateCtrl->skip_next_frame = 1;
-        pMP->counter_BTsrc -= (int)((OsclFloat)(rateCtrl->Bs / 2 - rateCtrl->low_bound) / 2.0 / (pMP->target_bits_per_frame / 10));
-        /* BX_1, skip more than 1 frames  */
-        //while(rateCtrl->VBV_fullness > rateCtrl->Bs*0.475)
-        while ((rateCtrl->VBV_fullness - rateCtrl->VBV_fullness_offset) > (rateCtrl->Bs / 2 - rateCtrl->VBV_fullness_offset)*0.95)
-        {
-            rateCtrl->VBV_fullness -= frame_bits; //rateCtrl->Rp;
-            rateCtrl->skip_next_frame++;
-            pMP->counter_BTsrc -= (int)((OsclFloat)(rateCtrl->Bs / 2 - rateCtrl->low_bound) / 2.0 / (pMP->target_bits_per_frame / 10));
-        }
-
-        /* END BX_1 */
-    }
-}
-
-
-double ComputeFrameMAD(AVCCommonObj *video, AVCRateControl *rateCtrl)
-{
-    double TotalMAD;
-    int i;
-    TotalMAD = 0.0;
-    for (i = 0; i < (int)video->PicSizeInMbs; i++)
-        TotalMAD += rateCtrl->MADofMB[i];
-    TotalMAD /= video->PicSizeInMbs;
-    return TotalMAD;
-}
-
-
-
-
-
-/* convert from QP to Qstep */
-double QP2Qstep(int QP)
-{
-    int i;
-    double Qstep;
-    static const double QP2QSTEP[6] = { 0.625, 0.6875, 0.8125, 0.875, 1.0, 1.125 };
-
-    Qstep = QP2QSTEP[QP % 6];
-    for (i = 0; i < (QP / 6); i++)
-        Qstep *= 2;
-
-    return Qstep;
-}
-
-/* convert from step size to QP */
-int Qstep2QP(double Qstep)
-{
-    int q_per = 0, q_rem = 0;
-
-    //  assert( Qstep >= QP2Qstep(0) && Qstep <= QP2Qstep(51) );
-    if (Qstep < QP2Qstep(0))
-        return 0;
-    else if (Qstep > QP2Qstep(51))
-        return 51;
-
-    while (Qstep > QP2Qstep(5))
-    {
-        Qstep /= 2;
-        q_per += 1;
-    }
-
-    if (Qstep <= (0.625 + 0.6875) / 2)
-    {
-        Qstep = 0.625;
-        q_rem = 0;
-    }
-    else if (Qstep <= (0.6875 + 0.8125) / 2)
-    {
-        Qstep = 0.6875;
-        q_rem = 1;
-    }
-    else if (Qstep <= (0.8125 + 0.875) / 2)
-    {
-        Qstep = 0.8125;
-        q_rem = 2;
-    }
-    else if (Qstep <= (0.875 + 1.0) / 2)
-    {
-        Qstep = 0.875;
-        q_rem = 3;
-    }
-    else if (Qstep <= (1.0 + 1.125) / 2)
-    {
-        Qstep = 1.0;
-        q_rem = 4;
-    }
-    else
-    {
-        Qstep = 1.125;
-        q_rem = 5;
-    }
-
-    return (q_per * 6 + q_rem);
-}
-
-
-
diff --git a/media/libstagefright/codecs/avc/enc/src/residual.cpp b/media/libstagefright/codecs/avc/enc/src/residual.cpp
deleted file mode 100644
index 42eb910..0000000
--- a/media/libstagefright/codecs/avc/enc/src/residual.cpp
+++ /dev/null
@@ -1,389 +0,0 @@
-/* ------------------------------------------------------------------
- * 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 "avcenc_lib.h"
-
-AVCEnc_Status EncodeIntraPCM(AVCEncObject *encvid)
-{
-    AVCEnc_Status status = AVCENC_SUCCESS;
-    AVCCommonObj *video = encvid->common;
-    AVCFrameIO  *currInput = encvid->currInput;
-    AVCEncBitstream *stream = encvid->bitstream;
-    int x_position = (video->mb_x << 4);
-    int y_position = (video->mb_y << 4);
-    int orgPitch = currInput->pitch;
-    int offset1 = y_position * orgPitch + x_position;
-    int i, j;
-    int offset;
-    uint8 *pDst, *pSrc;
-    uint code;
-
-    ue_v(stream, 25);
-
-    i = stream->bit_left & 0x7;
-    if (i) /* not byte-aligned */
-    {
-        BitstreamWriteBits(stream, 0, i);
-    }
-
-    pSrc = currInput->YCbCr[0] + offset1;
-    pDst = video->currPic->Sl + offset1;
-    offset = video->PicWidthInSamplesL - 16;
-
-    /* at this point bitstream is byte-aligned */
-    j = 16;
-    while (j > 0)
-    {
-#if (WORD_SIZE==32)
-        for (i = 0; i < 4; i++)
-        {
-            code = *((uint*)pSrc);
-            pSrc += 4;
-            *((uint*)pDst) = code;
-            pDst += 4;
-            status = BitstreamWriteBits(stream, 32, code);
-        }
-#else
-        for (i = 0; i < 8; i++)
-        {
-            code = *((uint*)pSrc);
-            pSrc += 2;
-            *((uint*)pDst) = code;
-            pDst += 2;
-            status = BitstreamWriteBits(stream, 16, code);
-        }
-#endif
-        pDst += offset;
-        pSrc += offset;
-        j--;
-    }
-    if (status != AVCENC_SUCCESS)  /* check only once per line */
-        return status;
-
-    pDst = video->currPic->Scb + ((offset1 + x_position) >> 2);
-    pSrc = currInput->YCbCr[1] + ((offset1 + x_position) >> 2);
-    offset >>= 1;
-
-    j = 8;
-    while (j > 0)
-    {
-#if (WORD_SIZE==32)
-        for (i = 0; i < 2; i++)
-        {
-            code = *((uint*)pSrc);
-            pSrc += 4;
-            *((uint*)pDst) = code;
-            pDst += 4;
-            status = BitstreamWriteBits(stream, 32, code);
-        }
-#else
-        for (i = 0; i < 4; i++)
-        {
-            code = *((uint*)pSrc);
-            pSrc += 2;
-            *((uint*)pDst) = code;
-            pDst += 2;
-            status = BitstreamWriteBits(stream, 16, code);
-        }
-#endif
-        pDst += offset;
-        pSrc += offset;
-        j--;
-    }
-
-    if (status != AVCENC_SUCCESS)  /* check only once per line */
-        return status;
-
-    pDst = video->currPic->Scr + ((offset1 + x_position) >> 2);
-    pSrc = currInput->YCbCr[2] + ((offset1 + x_position) >> 2);
-
-    j = 8;
-    while (j > 0)
-    {
-#if (WORD_SIZE==32)
-        for (i = 0; i < 2; i++)
-        {
-            code = *((uint*)pSrc);
-            pSrc += 4;
-            *((uint*)pDst) = code;
-            pDst += 4;
-            status = BitstreamWriteBits(stream, 32, code);
-        }
-#else
-        for (i = 0; i < 4; i++)
-        {
-            code = *((uint*)pSrc);
-            pSrc += 2;
-            *((uint*)pDst) = code;
-            pDst += 2;
-            status = BitstreamWriteBits(stream, 16, code);
-        }
-#endif
-        pDst += offset;
-        pSrc += offset;
-        j--;
-    }
-
-    return status;
-}
-
-
-AVCEnc_Status enc_residual_block(AVCEncObject *encvid, AVCResidualType type, int cindx, AVCMacroblock *currMB)
-{
-    AVCEnc_Status status = AVCENC_SUCCESS;
-    AVCCommonObj *video = encvid->common;
-    int i, maxNumCoeff, nC;
-    int cdc = 0, cac = 0;
-    int TrailingOnes;
-    AVCEncBitstream *stream = encvid->bitstream;
-    uint trailing_ones_sign_flag;
-    int zerosLeft;
-    int *level, *run;
-    int TotalCoeff;
-    const static int incVlc[] = {0, 3, 6, 12, 24, 48, 32768};  // maximum vlc = 6
-    int escape, numPrefix, sufmask, suffix, shift, sign, value, absvalue, vlcnum, level_two_or_higher;
-    int bindx = blkIdx2blkXY[cindx>>2][cindx&3] ; // raster scan index
-
-    switch (type)
-    {
-        case AVC_Luma:
-            maxNumCoeff = 16;
-            level = encvid->level[cindx];
-            run = encvid->run[cindx];
-            TotalCoeff = currMB->nz_coeff[bindx];
-            break;
-        case AVC_Intra16DC:
-            maxNumCoeff = 16;
-            level = encvid->leveldc;
-            run = encvid->rundc;
-            TotalCoeff = cindx; /* special case */
-            bindx = 0;
-            cindx = 0;
-            break;
-        case AVC_Intra16AC:
-            maxNumCoeff = 15;
-            level = encvid->level[cindx];
-            run = encvid->run[cindx];
-            TotalCoeff = currMB->nz_coeff[bindx];
-            break;
-        case AVC_ChromaDC:  /* how to differentiate Cb from Cr */
-            maxNumCoeff = 4;
-            cdc = 1;
-            if (cindx >= 8)
-            {
-                level = encvid->levelcdc + 4;
-                run = encvid->runcdc + 4;
-                TotalCoeff = cindx - 8;  /* special case */
-            }
-            else
-            {
-                level = encvid->levelcdc;
-                run = encvid->runcdc;
-                TotalCoeff = cindx;  /* special case */
-            }
-            break;
-        case AVC_ChromaAC:
-            maxNumCoeff = 15;
-            cac = 1;
-            level = encvid->level[cindx];
-            run = encvid->run[cindx];
-            cindx -= 16;
-            bindx = 16 + blkIdx2blkXY[cindx>>2][cindx&3];
-            cindx += 16;
-            TotalCoeff = currMB->nz_coeff[bindx];
-            break;
-        default:
-            return AVCENC_FAIL;
-    }
-
-
-    /* find TrailingOnes */
-    TrailingOnes = 0;
-    zerosLeft = 0;
-    i = TotalCoeff - 1;
-    nC = 1;
-    while (i >= 0)
-    {
-        zerosLeft += run[i];
-        if (nC && (level[i] == 1 || level[i] == -1))
-        {
-            TrailingOnes++;
-        }
-        else
-        {
-            nC = 0;
-        }
-        i--;
-    }
-    if (TrailingOnes > 3)
-    {
-        TrailingOnes = 3; /* clip it */
-    }
-
-    if (!cdc)
-    {
-        if (!cac)  /* not chroma */
-        {
-            nC = predict_nnz(video, bindx & 3, bindx >> 2);
-        }
-        else /* chroma ac but not chroma dc */
-        {
-            nC = predict_nnz_chroma(video, bindx & 3, bindx >> 2);
-        }
-
-        status = ce_TotalCoeffTrailingOnes(stream, TrailingOnes, TotalCoeff, nC);
-    }
-    else
-    {
-        nC = -1; /* Chroma DC level */
-        status = ce_TotalCoeffTrailingOnesChromaDC(stream, TrailingOnes, TotalCoeff);
-    }
-
-    /* This part is done quite differently in ReadCoef4x4_CAVLC() */
-    if (TotalCoeff > 0)
-    {
-
-        i = TotalCoeff - 1;
-
-        if (TrailingOnes) /* keep reading the sign of those trailing ones */
-        {
-            nC = TrailingOnes;
-            trailing_ones_sign_flag = 0;
-            while (nC)
-            {
-                trailing_ones_sign_flag <<= 1;
-                trailing_ones_sign_flag |= ((uint32)level[i--] >> 31); /* 0 or positive, 1 for negative */
-                nC--;
-            }
-
-            /* instead of writing one bit at a time, read the whole thing at once */
-            status = BitstreamWriteBits(stream, TrailingOnes, trailing_ones_sign_flag);
-        }
-
-        level_two_or_higher = 1;
-        if (TotalCoeff > 3 && TrailingOnes == 3)
-        {
-            level_two_or_higher = 0;
-        }
-
-        if (TotalCoeff > 10 && TrailingOnes < 3)
-        {
-            vlcnum = 1;
-        }
-        else
-        {
-            vlcnum = 0;
-        }
-
-        /* then do this TotalCoeff-TrailingOnes times */
-        for (i = TotalCoeff - TrailingOnes - 1; i >= 0; i--)
-        {
-            value = level[i];
-            absvalue = (value >= 0) ? value : -value;
-
-            if (level_two_or_higher)
-            {
-                if (value > 0) value--;
-                else    value++;
-                level_two_or_higher = 0;
-            }
-
-            if (value >= 0)
-            {
-                sign = 0;
-            }
-            else
-            {
-                sign = 1;
-                value = -value;
-            }
-
-            if (vlcnum == 0) // VLC1
-            {
-                if (value < 8)
-                {
-                    status = BitstreamWriteBits(stream, value * 2 + sign - 1, 1);
-                }
-                else if (value < 8 + 8)
-                {
-                    status = BitstreamWriteBits(stream, 14 + 1 + 4, (1 << 4) | ((value - 8) << 1) | sign);
-                }
-                else
-                {
-                    status = BitstreamWriteBits(stream, 14 + 2 + 12, (1 << 12) | ((value - 16) << 1) | sign) ;
-                }
-            }
-            else  // VLCN
-            {
-                shift = vlcnum - 1;
-                escape = (15 << shift) + 1;
-                numPrefix = (value - 1) >> shift;
-                sufmask = ~((0xffffffff) << shift);
-                suffix = (value - 1) & sufmask;
-                if (value < escape)
-                {
-                    status = BitstreamWriteBits(stream, numPrefix + vlcnum + 1, (1 << (shift + 1)) | (suffix << 1) | sign);
-                }
-                else
-                {
-                    status = BitstreamWriteBits(stream, 28, (1 << 12) | ((value - escape) << 1) | sign);
-                }
-
-            }
-
-            if (absvalue > incVlc[vlcnum])
-                vlcnum++;
-
-            if (i == TotalCoeff - TrailingOnes - 1 && absvalue > 3)
-                vlcnum = 2;
-        }
-
-        if (status != AVCENC_SUCCESS)  /* occasionally check the bitstream */
-        {
-            return status;
-        }
-        if (TotalCoeff < maxNumCoeff)
-        {
-            if (!cdc)
-            {
-                ce_TotalZeros(stream, zerosLeft, TotalCoeff);
-            }
-            else
-            {
-                ce_TotalZerosChromaDC(stream, zerosLeft, TotalCoeff);
-            }
-        }
-        else
-        {
-            zerosLeft = 0;
-        }
-
-        i = TotalCoeff - 1;
-        while (i > 0) /* don't do the last one */
-        {
-            if (zerosLeft > 0)
-            {
-                ce_RunBefore(stream, run[i], zerosLeft);
-            }
-
-            zerosLeft = zerosLeft - run[i];
-            i--;
-        }
-    }
-
-    return status;
-}
diff --git a/media/libstagefright/codecs/avc/enc/src/sad.cpp b/media/libstagefright/codecs/avc/enc/src/sad.cpp
deleted file mode 100644
index ae7acd2..0000000
--- a/media/libstagefright/codecs/avc/enc/src/sad.cpp
+++ /dev/null
@@ -1,290 +0,0 @@
-/* ------------------------------------------------------------------
- * 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 "avcenc_lib.h"
-#include "sad_inline.h"
-
-#define Cached_lx 176
-
-#ifdef _SAD_STAT
-uint32 num_sad_MB = 0;
-uint32 num_sad_Blk = 0;
-uint32 num_sad_MB_call = 0;
-uint32 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 AVCSAD_Macroblock_C(uint8 *ref,uint8 *blk,int dmin,int lx,void *extra_info)
-int AVCSAD_MB_HTFM_Collect(uint8 *ref,uint8 *blk,int dmin,int lx,void *extra_info)
-int AVCSAD_MB_HTFM(uint8 *ref,uint8 *blk,int dmin,int lx,void *extra_info)
-*/
-
-
-/*==================================================================
-    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 AVCSAD_Macroblock_C(uint8 *ref, uint8 *blk, int dmin_lx, void *extra_info)
-{
-    (void)(extra_info);
-
-    int32 x10;
-    int dmin = (uint32)dmin_lx >> 16;
-    int lx = dmin_lx & 0xFFFF;
-
-    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:   AVCAVCSAD_MB_HTFM_Collect and AVCSAD_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 AVCAVCSAD_MB_HTFM_Collect(uint8 *ref, uint8 *blk, int dmin_lx, void *extra_info)
-{
-    int i;
-    int sad = 0;
-    uint8 *p1;
-    int lx4 = (dmin_lx << 2) & 0x3FFFC;
-    uint32 cur_word;
-    int saddata[16], tmp, tmp2;    /* used when collecting flag (global) is on */
-    int difmad;
-    int madstar;
-    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;
-
-    madstar = (uint32)dmin_lx >> 20;
-
-    NUM_SAD_MB_CALL();
-
-    blk -= 4;
-    for (i = 0; i < 16; i++)
-    {
-        p1 = ref + offsetRef[i];
-        cur_word = *((uint32*)(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 = *((uint32*)(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 = *((uint32*)(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 = *((uint32*)(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 ((uint32)sad > ((uint32)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 AVCSAD_MB_HTFM(uint8 *ref, uint8 *blk, int dmin_lx, void *extra_info)
-{
-    int sad = 0;
-    uint8 *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;
-    uint32 cur_word;
-
-    madstar = (uint32)dmin_lx >> 20;
-
-    NUM_SAD_MB_CALL();
-
-    blk -= 4;
-    for (i = 0; i < 16; i++)
-    {
-        p1 = ref + offsetRef[i];
-        cur_word = *((uint32*)(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 = *((uint32*)(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 = *((uint32*)(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 = *((uint32*)(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 (((uint32)sad <= ((uint32)dmin_lx >> 16)) && (sad <= (sadstar - *nrmlz_th++)))
-            ;
-        else
-            return 65536;
-    }
-
-    return sad;
-}
-#endif /* HTFM */
-
-
-
diff --git a/media/libstagefright/codecs/avc/enc/src/sad_halfpel.cpp b/media/libstagefright/codecs/avc/enc/src/sad_halfpel.cpp
deleted file mode 100644
index faf2198..0000000
--- a/media/libstagefright/codecs/avc/enc/src/sad_halfpel.cpp
+++ /dev/null
@@ -1,629 +0,0 @@
-/* ------------------------------------------------------------------
- * 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 AVCHalfPel1_SAD_MB(uint8 *ref,uint8 *blk,int dmin,int width,int ih,int jh)
-int AVCHalfPel2_SAD_MB(uint8 *ref,uint8 *blk,int dmin,int width)
-int AVCHalfPel1_SAD_Blk(uint8 *ref,uint8 *blk,int dmin,int width,int ih,int jh)
-int AVCHalfPel2_SAD_Blk(uint8 *ref,uint8 *blk,int dmin,int width)
-
-int AVCSAD_MB_HalfPel_C(uint8 *ref,uint8 *blk,int dmin,int width,int rx,int xh,int yh,void *extra_info)
-int AVCSAD_MB_HP_HTFM_Collect(uint8 *ref,uint8 *blk,int dmin,int width,int rx,int xh,int yh,void *extra_info)
-int AVCSAD_MB_HP_HTFM(uint8 *ref,uint8 *blk,int dmin,int width,int rx,int xh,int yh,void *extra_info)
-int AVCSAD_Blk_HalfPel_C(uint8 *ref,uint8 *blk,int dmin,int width,int rx,int xh,int yh,void *extra_info)
-*/
-
-#include "avcenc_lib.h"
-#include "sad_halfpel_inline.h"
-
-#ifdef _SAD_STAT
-uint32 num_sad_HP_MB = 0;
-uint32 num_sad_HP_Blk = 0;
-uint32 num_sad_HP_MB_call = 0;
-uint32 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
-
-
-
-/*===============================================================
-    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:   AVCSAD_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 AVCSAD_MB_HalfPel_Cxhyh(uint8 *ref, uint8 *blk, int dmin_rx, void *extra_info)
-{
-    (void)(extra_info);
-
-    int i, j;
-    int sad = 0;
-    uint8 *kk, *p1, *p2, *p3, *p4;
-//  int sumref=0;
-    int temp;
-    int rx = dmin_rx & 0xFFFF;
-
-    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 += AVC_ABS(temp);
-        }
-
-        NUM_SAD_HP_MB();
-
-        if (sad > (int)((uint32)dmin_rx >> 16))
-            return sad;
-
-        p1 += rx;
-        p3 += rx;
-        p2 += rx;
-        p4 += rx;
-    }
-    return sad;
-}
-
-int AVCSAD_MB_HalfPel_Cyh(uint8 *ref, uint8 *blk, int dmin_rx, void *extra_info)
-{
-    (void)(extra_info);
-
-    int i, j;
-    int sad = 0;
-    uint8 *kk, *p1, *p2;
-//  int sumref=0;
-    int temp;
-    int rx = dmin_rx & 0xFFFF;
-
-    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 += AVC_ABS(temp);
-        }
-
-        NUM_SAD_HP_MB();
-
-        if (sad > (int)((uint32)dmin_rx >> 16))
-            return sad;
-        p1 += rx;
-        p2 += rx;
-    }
-    return sad;
-}
-
-int AVCSAD_MB_HalfPel_Cxh(uint8 *ref, uint8 *blk, int dmin_rx, void *extra_info)
-{
-    (void)(extra_info);
-
-    int i, j;
-    int sad = 0;
-    uint8 *kk, *p1;
-    int temp;
-    int rx = dmin_rx & 0xFFFF;
-
-    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 += AVC_ABS(temp);
-        }
-
-        NUM_SAD_HP_MB();
-
-        if (sad > (int)((uint32)dmin_rx >> 16))
-            return sad;
-        p1 += rx;
-    }
-    return sad;
-}
-
-#ifdef HTFM  /* HTFM with uniform subsampling implementation,  2/28/01 */
-
-//Checheck here
-int AVCAVCSAD_MB_HP_HTFM_Collectxhyh(uint8 *ref, uint8 *blk, int dmin_rx, void *extra_info)
-{
-    int i, j;
-    int sad = 0;
-    uint8 *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;
-    int madstar;
-    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;
-    uint32 cur_word;
-
-    madstar = (uint32)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 = *((uint32*)(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 > ((uint32)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 AVCAVCSAD_MB_HP_HTFM_Collectyh(uint8 *ref, uint8 *blk, int dmin_rx, void *extra_info)
-{
-    int i, j;
-    int sad = 0;
-    uint8 *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;
-    int madstar;
-    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;
-    uint32 cur_word;
-
-    madstar = (uint32)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 = *((uint32*)(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 > ((uint32)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 AVCAVCSAD_MB_HP_HTFM_Collectxh(uint8 *ref, uint8 *blk, int dmin_rx, void *extra_info)
-{
-    int i, j;
-    int sad = 0;
-    uint8 *p1;
-    int rx = dmin_rx & 0xFFFF;
-    int refwx4 = rx << 2;
-    int saddata[16];      /* used when collecting flag (global) is on */
-    int difmad, tmp, tmp2;
-    int madstar;
-    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;
-    uint32 cur_word;
-
-    madstar = (uint32)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 = *((uint32*)(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 > ((uint32)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 AVCSAD_MB_HP_HTFMxhyh(uint8 *ref, uint8 *blk, int dmin_rx, void *extra_info)
-{
-    int i, j;
-    int sad = 0, tmp, tmp2;
-    uint8 *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;
-    uint32 cur_word;
-
-    madstar = (uint32)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 = *((uint32*)(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 > ((uint32)dmin_rx >> 16))
-        {
-            return 65536;
-        }
-    }
-
-    return sad;
-}
-
-int AVCSAD_MB_HP_HTFMyh(uint8 *ref, uint8 *blk, int dmin_rx, void *extra_info)
-{
-    int i, j;
-    int sad = 0, tmp, tmp2;
-    uint8 *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;
-    uint32 cur_word;
-
-    madstar = (uint32)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 = *((uint32*)(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 > ((uint32)dmin_rx >> 16))
-        {
-            return 65536;
-        }
-    }
-
-    return sad;
-}
-
-int AVCSAD_MB_HP_HTFMxh(uint8 *ref, uint8 *blk, int dmin_rx, void *extra_info)
-{
-    int i, j;
-    int sad = 0, tmp, tmp2;
-    uint8 *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;
-    uint32 cur_word;
-
-    madstar = (uint32)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 = *((uint32*)(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 > ((uint32)dmin_rx >> 16))
-        {
-            return 65536;
-        }
-    }
-
-    return sad;
-}
-
-#endif /* HTFM */
-
-
-
-
-
diff --git a/media/libstagefright/codecs/avc/enc/src/sad_halfpel_inline.h b/media/libstagefright/codecs/avc/enc/src/sad_halfpel_inline.h
deleted file mode 100644
index 22f545a..0000000
--- a/media/libstagefright/codecs/avc/enc/src/sad_halfpel_inline.h
+++ /dev/null
@@ -1,110 +0,0 @@
-/* ------------------------------------------------------------------
- * 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 _SAD_HALFPEL_INLINE_H_
-#define _SAD_HALFPEL_INLINE_H_
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-/* Intentionally not using the gcc asm version, since it is
- * slightly slower than the plain C version on modern GCC versions. */
-#if !defined(__CC_ARM) /* Generic C version */
-
-    __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(__GNUC__) && defined(__arm__) /* ARM GNU COMPILER  */
-
-    __inline int32 INTERP1_SUB_SAD(int32 sad, int32 tmp, int32 tmp2)
-    {
-        __asm__ volatile(
-            "rsbs       %1, %1, %2, asr #1\n\t"
-            "rsbmi      %1, %1, #0\n\t"
-            "add        %0, %0, %1"
-            : "+r"(sad), "+r"(tmp)
-            : "r"(tmp2)
-        );
-
-        return sad;
-    }
-
-    __inline int32 INTERP2_SUB_SAD(int32 sad, int32 tmp, int32 tmp2)
-    {
-        __asm__ volatile(
-            "rsbs       %1, %2, %1, asr #2\n\t"
-            "rsbmi      %1, %1, #0\n\t"
-            "add        %0, %0, %1"
-            : "+r"(sad), "+r"(tmp)
-            : "r"(tmp2)
-        );
-
-        return sad;
-    }
-
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif //_SAD_HALFPEL_INLINE_H_
-
diff --git a/media/libstagefright/codecs/avc/enc/src/sad_inline.h b/media/libstagefright/codecs/avc/enc/src/sad_inline.h
deleted file mode 100644
index 47abc65..0000000
--- a/media/libstagefright/codecs/avc/enc/src/sad_inline.h
+++ /dev/null
@@ -1,526 +0,0 @@
-/* ------------------------------------------------------------------
- * 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 _SAD_INLINE_H_
-#define _SAD_INLINE_H_
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-/* Intentionally not using the gcc asm version, since it is
- * slightly slower than the plain C version on modern GCC versions. */
-#if !defined(__CC_ARM) /* Generic C version */
-
-    __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(uint8 *ref, uint8 *blk, int dmin, int lx)
-    {
-        int32 x4, x5, x6, x8, x9, x10, x11, x12, x14;
-
-        x9 = 0x80808080; /* const. */
-
-        x8 = (intptr_t)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 ((int)((uint32)x10 >> 16) <= 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(uint8 *ref, uint8 *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(__GNUC__) && defined(__arm__) /* ARM GNU COMPILER  */
-
-    __inline int32 SUB_SAD(int32 sad, int32 tmp, int32 tmp2)
-    {
-        __asm__ volatile(
-            "rsbs       %1, %1, %2\n\t"
-            "rsbmi      %1, %1, #0\n\t"
-            "add        %0, %0, %1"
-            : "+r"(sad), "+r"(tmp)
-            : "r"(tmp2)
-        );
-        return sad;
-    }
-
-    __inline int32 sad_4pixel(int32 src1, int32 src2, int32 mask)
-    {
-        int32 x7;
-
-        __asm__ volatile(
-            "EOR        %1, %2, %0\n\t"
-            "SUBS       %0, %2, %0\n\t"
-            "EOR        %1, %1, %0\n\t"
-            "AND        %1, %3, %1, lsr #1\n\t"
-            "ORRCC      %1, %1, #0x80000000\n\t"
-            "RSB        %1, %1, %1, lsl #8\n\t"
-            "ADD        %0, %0, %1, asr #7\n\t"
-            "EOR        %0, %0, %1, asr #7"
-            : "+r"(src1), "=&r"(x7)
-            : "r"(src2), "r"(mask)
-        );
-
-        return src1;
-    }
-
-    __inline int32 sad_4pixelN(int32 src1, int32 src2, int32 mask)
-    {
-        int32 x7;
-
-        __asm__ volatile(
-            "EOR        %1, %2, %0\n\t"
-            "ADDS       %0, %2, %0\n\t"
-            "EOR        %1, %1, %0\n\t"
-            "ANDS       %1, %3, %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"(src1), "=&r"(x7)
-            : "r"(src2), "r"(mask)
-        );
-
-        return src1;
-    }
-
-#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(uint8 *ref, uint8 *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;
-
-        x8 = 16;
-///
-        __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 */
-
-        /****** process 8 pixels ******/
-        x11 = *((int32*)(ref + 4));
-        __asm__ volatile("LDR   %0, [%1], %2": "=&r"(x10), "+r"(ref): "r"(lx));
-        //x10 = *((int32*)ref); ref+=lx;
-        x14 = *((int32*)(blk + 4));
-        __asm__ volatile("LDR   %0, [%1], #16": "=&r"(x12), "+r"(blk));
-
-        /* 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) <= 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
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // _SAD_INLINE_H_
-
diff --git a/media/libstagefright/codecs/avc/enc/src/sad_mb_offset.h b/media/libstagefright/codecs/avc/enc/src/sad_mb_offset.h
deleted file mode 100644
index 20ca7eb..0000000
--- a/media/libstagefright/codecs/avc/enc/src/sad_mb_offset.h
+++ /dev/null
@@ -1,355 +0,0 @@
-/* ------------------------------------------------------------------
- * 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.
- * -------------------------------------------------------------------
- */
-
-/* Intentionally not using the gcc asm version, since it is
- * slightly slower than the plain C version on modern GCC versions. */
-#if !defined(__CC_ARM) /* Generic C version */
-
-#if (NUMBER==3)
-__inline int32 sad_mb_offset3(uint8 *ref, uint8 *blk, int lx, int dmin)
-#elif (NUMBER==2)
-__inline int32 sad_mb_offset2(uint8 *ref, uint8 *blk, int lx, int dmin)
-#elif (NUMBER==1)
-__inline int32 sad_mb_offset1(uint8 *ref, uint8 *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 ((int)((uint32)x10 >> 16) <= 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(uint8 *ref, uint8 *blk, int lx, int dmin, int32 x8)
-#elif (NUMBER==2)
-__inline int32 sad_mb_offset2(uint8 *ref, uint8 *blk, int lx, int dmin, int32 x8)
-#elif (NUMBER==1)
-__inline int32 sad_mb_offset1(uint8 *ref, uint8 *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;
-#if (NUMBER==3)
-LOOP_SAD3:
-#elif (NUMBER==2)
-LOOP_SAD2:
-#elif (NUMBER==1)
-LOOP_SAD1:
-#endif
-        BIC      ref, ref, #3;
-    }
-    /****** 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(__GNUC__) && defined(__arm__) /* ARM GNU COMPILER  */
-
-#if (NUMBER==3)
-__inline int32 sad_mb_offset3(uint8 *ref, uint8 *blk, int lx, int dmin)
-#elif (NUMBER==2)
-__inline int32 sad_mb_offset2(uint8 *ref, uint8 *blk, int lx, int dmin)
-#elif (NUMBER==1)
-__inline int32 sad_mb_offset1(uint8 *ref, uint8 *blk, int lx, int dmin)
-#endif
-{
-    int32 x4, x5, x6, x8, x9, x10, x11, x12, x14;
-
-    x9 = 0x80808080; /* const. */
-    x4 = x5 = 0;
-    x8 = 16; //<<===========*******
-
-    __asm__ volatile("MVN       %0, #0xFF0000": "=r"(x6));
-
-#if (NUMBER==3)
-LOOP_SAD3:
-#elif (NUMBER==2)
-LOOP_SAD2:
-#elif (NUMBER==1)
-LOOP_SAD1:
-#endif
-    __asm__ volatile("BIC  %0, %0, #3": "+r"(ref));
-    /****** process 8 pixels ******/
-    x11 = *((int32*)(ref + 12));
-    x12 = *((int32*)(ref + 16));
-    x10 = *((int32*)(ref + 8));
-    x14 = *((int32*)(blk + 12));
-
-#if (SHIFT==8)
-    __asm__ volatile(
-        "MVN   %0, %0, lsr #8\n\t"
-        "BIC   %0, %0, %1, lsl #24\n\t"
-        "MVN   %1, %1, lsr #8\n\t"
-        "BIC   %1, %1, %2, lsl #24"
-        : "+r"(x10), "+r"(x11)
-        : "r"(x12)
-    );
-#elif (SHIFT==16)
-    __asm__ volatile(
-        "MVN   %0, %0, lsr #16\n\t"
-        "BIC   %0, %0, %1, lsl #16\n\t"
-        "MVN   %1, %1, lsr #16\n\t"
-        "BIC   %1, %1, %2, lsl #16"
-        : "+r"(x10), "+r"(x11)
-        : "r"(x12)
-    );
-#elif (SHIFT==24)
-    __asm__ volatile(
-        "MVN   %0, %0, lsr #24\n\t"
-        "BIC   %0, %0, %1, lsl #8\n\t"
-        "MVN   %1, %1, lsr #24\n\t"
-        "BIC   %1, %1, %2, lsl #8"
-        : "+r"(x10), "+r"(x11)
-        : "r"(x12)
-    );
-#endif
-
-    x12 = *((int32*)(blk + 8));
-
-    /* process x11 & x14 */
-    x11 = sad_4pixelN(x11, x14, x9);
-
-    /* process x12 & x10 */
-    x10 = sad_4pixelN(x10, x12, x9);
-
-    sum_accumulate;
-
-    /****** process 8 pixels ******/
-    x11 = *((int32*)(ref + 4));
-    x12 = *((int32*)(ref + 8));
-    x10 = *((int32*)ref); ref += lx;
-    x14 = *((int32*)(blk + 4));
-
-#if (SHIFT==8)
-    __asm__ volatile(
-        "MVN   %0, %0, lsr #8\n\t"
-        "BIC   %0, %0, %1, lsl #24\n\t"
-        "MVN   %1, %1, lsr #8\n\t"
-        "BIC   %1, %1, %2, lsl #24"
-        : "+r"(x10), "+r"(x11)
-        : "r"(x12)
-    );
-#elif (SHIFT==16)
-    __asm__ volatile(
-        "MVN   %0, %0, lsr #16\n\t"
-        "BIC   %0, %0, %1, lsl #16\n\t"
-        "MVN   %1, %1, lsr #16\n\t"
-        "BIC   %1, %1, %2, lsl #16"
-        : "+r"(x10), "+r"(x11)
-        : "r"(x12)
-    );
-#elif (SHIFT==24)
-    __asm__ volatile(
-        "MVN   %0, %0, lsr #24\n\t"
-        "BIC   %0, %0, %1, lsl #8\n\t"
-        "MVN   %1, %1, lsr #24\n\t"
-        "BIC   %1, %1, %2, lsl #8"
-        : "+r"(x10), "+r"(x11)
-        : "r"(x12)
-    );
-#endif
-    __asm__ volatile("LDR   %0, [%1], #16": "=&r"(x12), "+r"(blk));
-
-    /* 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 */
-
-    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/avc/enc/src/slice.cpp b/media/libstagefright/codecs/avc/enc/src/slice.cpp
deleted file mode 100644
index f6d066e..0000000
--- a/media/libstagefright/codecs/avc/enc/src/slice.cpp
+++ /dev/null
@@ -1,1025 +0,0 @@
-/* ------------------------------------------------------------------
- * 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 "avcenc_lib.h"
-
-
-AVCEnc_Status AVCEncodeSlice(AVCEncObject *encvid)
-{
-    AVCEnc_Status status = AVCENC_SUCCESS;
-    AVCCommonObj *video = encvid->common;
-    AVCPicParamSet *pps = video->currPicParams;
-    AVCSliceHeader *sliceHdr = video->sliceHdr;
-    AVCMacroblock *currMB ;
-    AVCEncBitstream *stream = encvid->bitstream;
-    uint slice_group_id;
-    int CurrMbAddr, slice_type;
-
-    slice_type = video->slice_type;
-
-    /* set the first mb in slice */
-    video->mbNum = CurrMbAddr = sliceHdr->first_mb_in_slice;// * (1+video->MbaffFrameFlag);
-    slice_group_id = video->MbToSliceGroupMap[CurrMbAddr];
-
-    video->mb_skip_run = 0;
-
-    /* while loop , see subclause 7.3.4 */
-    while (1)
-    {
-        video->mbNum = CurrMbAddr;
-        currMB = video->currMB = &(video->mblock[CurrMbAddr]);
-        currMB->slice_id = video->slice_id;  // for deblocking
-
-        video->mb_x = CurrMbAddr % video->PicWidthInMbs;
-        video->mb_y = CurrMbAddr / video->PicWidthInMbs;
-
-        /* initialize QP for this MB here*/
-        /* calculate currMB->QPy */
-        RCInitMBQP(encvid);
-
-        /* check the availability of neighboring macroblocks */
-        InitNeighborAvailability(video, CurrMbAddr);
-
-        /* Assuming that InitNeighborAvailability has been called prior to this function */
-        video->intraAvailA = video->intraAvailB = video->intraAvailC = video->intraAvailD = 0;
-        /* this is necessary for all subsequent intra search */
-
-        if (!video->currPicParams->constrained_intra_pred_flag)
-        {
-            video->intraAvailA = video->mbAvailA;
-            video->intraAvailB = video->mbAvailB;
-            video->intraAvailC = video->mbAvailC;
-            video->intraAvailD = video->mbAvailD;
-        }
-        else
-        {
-            if (video->mbAvailA)
-            {
-                video->intraAvailA = video->mblock[video->mbAddrA].mb_intra;
-            }
-            if (video->mbAvailB)
-            {
-                video->intraAvailB = video->mblock[video->mbAddrB].mb_intra ;
-            }
-            if (video->mbAvailC)
-            {
-                video->intraAvailC = video->mblock[video->mbAddrC].mb_intra;
-            }
-            if (video->mbAvailD)
-            {
-                video->intraAvailD = video->mblock[video->mbAddrD].mb_intra;
-            }
-        }
-
-        /* encode_one_macroblock() */
-        status = EncodeMB(encvid);
-        if (status != AVCENC_SUCCESS)
-        {
-            break;
-        }
-
-        /* go to next MB */
-        CurrMbAddr++;
-
-        while ((uint)video->MbToSliceGroupMap[CurrMbAddr] != slice_group_id &&
-                (uint)CurrMbAddr < video->PicSizeInMbs)
-        {
-            CurrMbAddr++;
-        }
-
-        if ((uint)CurrMbAddr >= video->PicSizeInMbs)
-        {
-            /* end of slice, return, but before that check to see if there are other slices
-            to be encoded. */
-            encvid->currSliceGroup++;
-            if (encvid->currSliceGroup > (int)pps->num_slice_groups_minus1) /* no more slice group */
-            {
-                status = AVCENC_PICTURE_READY;
-                break;
-            }
-            else
-            {
-                /* find first_mb_num for the next slice */
-                CurrMbAddr = 0;
-                while (video->MbToSliceGroupMap[CurrMbAddr] != encvid->currSliceGroup &&
-                        (uint)CurrMbAddr < video->PicSizeInMbs)
-                {
-                    CurrMbAddr++;
-                }
-                if ((uint)CurrMbAddr >= video->PicSizeInMbs)
-                {
-                    status = AVCENC_SLICE_EMPTY; /* error, one slice group has no MBs in it */
-                }
-
-                video->mbNum = CurrMbAddr;
-                status = AVCENC_SUCCESS;
-                break;
-            }
-        }
-    }
-
-    if (video->mb_skip_run > 0)
-    {
-        /* write skip_run */
-        if (slice_type != AVC_I_SLICE && slice_type != AVC_SI_SLICE)
-        {
-            ue_v(stream, video->mb_skip_run);
-            video->mb_skip_run = 0;
-        }
-        else    /* shouldn't happen */
-        {
-            status = AVCENC_FAIL;
-        }
-    }
-
-    return status;
-}
-
-
-AVCEnc_Status EncodeMB(AVCEncObject *encvid)
-{
-    AVCEnc_Status status = AVCENC_SUCCESS;
-    AVCCommonObj *video = encvid->common;
-    AVCPictureData *currPic = video->currPic;
-    AVCFrameIO  *currInput = encvid->currInput;
-    AVCMacroblock *currMB = video->currMB;
-    AVCMacroblock *MB_A, *MB_B;
-    AVCEncBitstream *stream = encvid->bitstream;
-    AVCRateControl *rateCtrl = encvid->rateCtrl;
-    uint8 *cur, *curL, *curCb, *curCr;
-    uint8 *orgL, *orgCb, *orgCr, *org4;
-    int CurrMbAddr = video->mbNum;
-    int picPitch = currPic->pitch;
-    int orgPitch = currInput->pitch;
-    int x_position = (video->mb_x << 4);
-    int y_position = (video->mb_y << 4);
-    int offset;
-    int b8, b4, blkidx;
-    AVCResidualType  resType;
-    int slice_type;
-    int numcoeff; /* output from residual_block_cavlc */
-    int cost16, cost8;
-
-    int num_bits, start_mb_bits, start_text_bits;
-
-    slice_type = video->slice_type;
-
-    /* now, point to the reconstructed frame */
-    offset = y_position * picPitch + x_position;
-    curL = currPic->Sl + offset;
-    orgL = currInput->YCbCr[0] + offset;
-    offset = (offset + x_position) >> 2;
-    curCb = currPic->Scb + offset;
-    curCr = currPic->Scr + offset;
-    orgCb = currInput->YCbCr[1] + offset;
-    orgCr = currInput->YCbCr[2] + offset;
-
-    if (orgPitch != picPitch)
-    {
-        offset = y_position * (orgPitch - picPitch);
-        orgL += offset;
-        offset >>= 2;
-        orgCb += offset;
-        orgCr += offset;
-    }
-
-    /******* determine MB prediction mode *******/
-    if (encvid->intraSearch[CurrMbAddr])
-    {
-        MBIntraSearch(encvid, CurrMbAddr, curL, picPitch);
-    }
-    /******* This part should be determined somehow ***************/
-    if (currMB->mbMode == AVC_I_PCM)
-    {
-        /* write down mb_type and PCM data */
-        /* and copy from currInput to currPic */
-        status = EncodeIntraPCM(encvid);
-
-
-        return status;
-    }
-
-    /****** for intra prediction, pred is already done *******/
-    /****** for I4, the recon is ready and Xfrm coefs are ready to be encoded *****/
-
-    //RCCalculateMAD(encvid,currMB,orgL,orgPitch); // no need to re-calculate MAD for Intra
-    // not used since totalSAD is used instead
-
-    /* compute the prediction */
-    /* output is video->pred_block */
-    if (!currMB->mb_intra)
-    {
-        AVCMBMotionComp(encvid, video); /* perform prediction and residue calculation */
-        /* we can do the loop here and call dct_luma */
-        video->pred_pitch = picPitch;
-        currMB->CBP = 0;
-        cost16 = 0;
-        cur = curL;
-        org4 = orgL;
-
-        for (b8 = 0; b8 < 4; b8++)
-        {
-            cost8 = 0;
-
-            for (b4 = 0; b4 < 4; b4++)
-            {
-                blkidx = blkIdx2blkXY[b8][b4];
-                video->pred_block = cur;
-                numcoeff = dct_luma(encvid, blkidx, cur, org4, &cost8);
-                currMB->nz_coeff[blkidx] = numcoeff;
-                if (numcoeff)
-                {
-                    video->cbp4x4 |= (1 << blkidx);
-                    currMB->CBP |= (1 << b8);
-                }
-
-                if (b4&1)
-                {
-                    cur += ((picPitch << 2) - 4);
-                    org4 += ((orgPitch << 2) - 4);
-                }
-                else
-                {
-                    cur += 4;
-                    org4 += 4;
-                }
-            }
-
-            /* move the IDCT part out of dct_luma to accommodate the check
-               for coeff_cost. */
-
-            if ((currMB->CBP&(1 << b8)) && (cost8 <= _LUMA_COEFF_COST_))
-            {
-                cost8 = 0; // reset it
-
-                currMB->CBP ^= (1 << b8);
-                blkidx = blkIdx2blkXY[b8][0];
-
-                currMB->nz_coeff[blkidx] = 0;
-                currMB->nz_coeff[blkidx+1] = 0;
-                currMB->nz_coeff[blkidx+4] = 0;
-                currMB->nz_coeff[blkidx+5] = 0;
-            }
-
-            cost16 += cost8;
-
-            if (b8&1)
-            {
-                cur -= 8;
-                org4 -= 8;
-            }
-            else
-            {
-                cur += (8 - (picPitch << 3));
-                org4 += (8 - (orgPitch << 3));
-            }
-        }
-
-        /* after the whole MB, we do another check for coeff_cost */
-        if ((currMB->CBP&0xF) && (cost16 <= _LUMA_MB_COEFF_COST_))
-        {
-            currMB->CBP = 0;  // reset it to zero
-            memset(currMB->nz_coeff, 0, sizeof(uint8)*16);
-        }
-
-        // now we do IDCT
-        MBInterIdct(video, curL, currMB, picPitch);
-
-//      video->pred_block = video->pred + 256;
-    }
-    else    /* Intra prediction */
-    {
-        encvid->numIntraMB++;
-
-        if (currMB->mbMode == AVC_I16) /* do prediction for the whole macroblock */
-        {
-            currMB->CBP = 0;
-            /* get the prediction from encvid->pred_i16 */
-            dct_luma_16x16(encvid, curL, orgL);
-        }
-        video->pred_block = encvid->pred_ic[currMB->intra_chroma_pred_mode];
-    }
-
-    /* chrominance */
-    /* not need to do anything, the result is in encvid->pred_ic
-    chroma dct must be aware that prediction block can come from either intra or inter. */
-
-    dct_chroma(encvid, curCb, orgCb, 0);
-
-    dct_chroma(encvid, curCr, orgCr, 1);
-
-
-    /* 4.1 if there's nothing in there, video->mb_skip_run++ */
-    /* 4.2 if coded, check if there is a run of skipped MB, encodes it,
-            set video->QPyprev = currMB->QPy; */
-
-    /* 5. vlc encode */
-
-    /* check for skipped macroblock, INTER only */
-    if (!currMB->mb_intra)
-    {
-        /* decide whether this MB (for inter MB) should be skipped if there's nothing left. */
-        if (!currMB->CBP && currMB->NumMbPart == 1 && currMB->QPy == video->QPy)
-        {
-            if (currMB->MBPartPredMode[0][0] == AVC_Pred_L0 && currMB->ref_idx_L0[0] == 0)
-            {
-                MB_A = &video->mblock[video->mbAddrA];
-                MB_B = &video->mblock[video->mbAddrB];
-
-                if (!video->mbAvailA || !video->mbAvailB)
-                {
-                    if (currMB->mvL0[0] == 0) /* both mv components are zeros.*/
-                    {
-                        currMB->mbMode = AVC_SKIP;
-                        video->mvd_l0[0][0][0] = 0;
-                        video->mvd_l0[0][0][1] = 0;
-                    }
-                }
-                else
-                {
-                    if ((MB_A->ref_idx_L0[1] == 0 && MB_A->mvL0[3] == 0) ||
-                            (MB_B->ref_idx_L0[2] == 0 && MB_B->mvL0[12] == 0))
-                    {
-                        if (currMB->mvL0[0] == 0) /* both mv components are zeros.*/
-                        {
-                            currMB->mbMode = AVC_SKIP;
-                            video->mvd_l0[0][0][0] = 0;
-                            video->mvd_l0[0][0][1] = 0;
-                        }
-                    }
-                    else if (video->mvd_l0[0][0][0] == 0 && video->mvd_l0[0][0][1] == 0)
-                    {
-                        currMB->mbMode = AVC_SKIP;
-                    }
-                }
-            }
-
-            if (currMB->mbMode == AVC_SKIP)
-            {
-                video->mb_skip_run++;
-
-                /* set parameters */
-                /* not sure whether we need the followings */
-                if (slice_type == AVC_P_SLICE)
-                {
-                    currMB->mbMode = AVC_SKIP;
-                    currMB->MbPartWidth = currMB->MbPartHeight = 16;
-                    currMB->MBPartPredMode[0][0] = AVC_Pred_L0;
-                    currMB->NumMbPart = 1;
-                    currMB->NumSubMbPart[0] = currMB->NumSubMbPart[1] =
-                                                  currMB->NumSubMbPart[2] = currMB->NumSubMbPart[3] = 1;
-                    currMB->SubMbPartWidth[0] = currMB->SubMbPartWidth[1] =
-                                                    currMB->SubMbPartWidth[2] = currMB->SubMbPartWidth[3] = currMB->MbPartWidth;
-                    currMB->SubMbPartHeight[0] = currMB->SubMbPartHeight[1] =
-                                                     currMB->SubMbPartHeight[2] = currMB->SubMbPartHeight[3] = currMB->MbPartHeight;
-
-                }
-                else if (slice_type == AVC_B_SLICE)
-                {
-                    currMB->mbMode = AVC_SKIP;
-                    currMB->MbPartWidth = currMB->MbPartHeight = 8;
-                    currMB->MBPartPredMode[0][0] = AVC_Direct;
-                    currMB->NumMbPart = -1;
-                }
-
-                /* for skipped MB, always look at the first entry in RefPicList */
-                currMB->RefIdx[0] = currMB->RefIdx[1] =
-                                        currMB->RefIdx[2] = currMB->RefIdx[3] = video->RefPicList0[0]->RefIdx;
-
-                /* do not return yet, need to do some copies */
-            }
-        }
-    }
-    /* non-skipped MB */
-
-
-    /************* START ENTROPY CODING *************************/
-
-    start_mb_bits = 32 + (encvid->bitstream->write_pos << 3) - encvid->bitstream->bit_left;
-
-    /* encode mb_type, mb_pred, sub_mb_pred, CBP */
-    if (slice_type != AVC_I_SLICE && slice_type != AVC_SI_SLICE && currMB->mbMode != AVC_SKIP)
-    {
-        //if(!pps->entropy_coding_mode_flag)  ALWAYS true
-        {
-            ue_v(stream, video->mb_skip_run);
-            video->mb_skip_run = 0;
-        }
-    }
-
-    if (currMB->mbMode != AVC_SKIP)
-    {
-        status = EncodeMBHeader(currMB, encvid);
-        if (status != AVCENC_SUCCESS)
-        {
-            return status;
-        }
-    }
-
-    start_text_bits = 32 + (encvid->bitstream->write_pos << 3) - encvid->bitstream->bit_left;
-
-    /**** now decoding part *******/
-    resType = AVC_Luma;
-
-    /* DC transform for luma I16 mode */
-    if (currMB->mbMode == AVC_I16)
-    {
-        /* vlc encode level/run */
-        status = enc_residual_block(encvid, AVC_Intra16DC, encvid->numcoefdc, currMB);
-        if (status != AVCENC_SUCCESS)
-        {
-            return status;
-        }
-        resType = AVC_Intra16AC;
-    }
-
-    /* VLC encoding for luma */
-    for (b8 = 0; b8 < 4; b8++)
-    {
-        if (currMB->CBP&(1 << b8))
-        {
-            for (b4 = 0; b4 < 4; b4++)
-            {
-                /* vlc encode level/run */
-                status = enc_residual_block(encvid, resType, (b8 << 2) + b4, currMB);
-                if (status != AVCENC_SUCCESS)
-                {
-                    return status;
-                }
-            }
-        }
-    }
-
-    /* chroma */
-    if (currMB->CBP & (3 << 4)) /* chroma DC residual present */
-    {
-        for (b8 = 0; b8 < 2; b8++) /* for iCbCr */
-        {
-            /* vlc encode level/run */
-            status = enc_residual_block(encvid, AVC_ChromaDC, encvid->numcoefcdc[b8] + (b8 << 3), currMB);
-            if (status != AVCENC_SUCCESS)
-            {
-                return status;
-            }
-        }
-    }
-
-    if (currMB->CBP & (2 << 4))
-    {
-        /* AC part */
-        for (b8 = 0; b8 < 2; b8++) /* for iCbCr */
-        {
-            for (b4 = 0; b4 < 4; b4++)  /* for each block inside Cb or Cr */
-            {
-                /* vlc encode level/run */
-                status = enc_residual_block(encvid, AVC_ChromaAC, 16 + (b8 << 2) + b4, currMB);
-                if (status != AVCENC_SUCCESS)
-                {
-                    return status;
-                }
-            }
-        }
-    }
-
-
-    num_bits = 32 + (encvid->bitstream->write_pos << 3) - encvid->bitstream->bit_left;
-
-    RCPostMB(video, rateCtrl, start_text_bits - start_mb_bits,
-             num_bits - start_text_bits);
-
-//  num_bits -= start_mb_bits;
-//  fprintf(fdebug,"MB #%d: %d bits\n",CurrMbAddr,num_bits);
-//  fclose(fdebug);
-    return status;
-}
-
-/* copy the content from predBlock back to the reconstructed YUV frame */
-void Copy_MB(uint8 *curL, uint8 *curCb, uint8 *curCr, uint8 *predBlock, int picPitch)
-{
-    int j, offset;
-    uint32 *dst, *dst2, *src;
-
-    dst = (uint32*)curL;
-    src = (uint32*)predBlock;
-
-    offset = (picPitch - 16) >> 2;
-
-    for (j = 0; j < 16; j++)
-    {
-        *dst++ = *src++;
-        *dst++ = *src++;
-        *dst++ = *src++;
-        *dst++ = *src++;
-
-        dst += offset;
-    }
-
-    dst = (uint32*)curCb;
-    dst2 = (uint32*)curCr;
-    offset >>= 1;
-
-    for (j = 0; j < 8; j++)
-    {
-        *dst++ = *src++;
-        *dst++ = *src++;
-        *dst2++ = *src++;
-        *dst2++ = *src++;
-
-        dst += offset;
-        dst2 += offset;
-    }
-    return ;
-}
-
-/* encode mb_type, mb_pred, sub_mb_pred, CBP */
-/* decide whether this MB (for inter MB) should be skipped */
-AVCEnc_Status EncodeMBHeader(AVCMacroblock *currMB, AVCEncObject *encvid)
-{
-    AVCEnc_Status status = AVCENC_SUCCESS;
-    uint mb_type;
-    AVCCommonObj *video = encvid->common;
-    AVCEncBitstream *stream = encvid->bitstream;
-
-    if (currMB->CBP > 47)   /* chroma CBP is 11 */
-    {
-        currMB->CBP -= 16;  /* remove the 5th bit from the right */
-    }
-
-    mb_type = InterpretMBType(currMB, video->slice_type);
-
-    status = ue_v(stream, mb_type);
-
-    if (currMB->mbMode == AVC_P8 || currMB->mbMode == AVC_P8ref0)
-    {
-        status = sub_mb_pred(video, currMB, stream);
-    }
-    else
-    {
-        status = mb_pred(video, currMB, stream) ;
-    }
-
-    if (currMB->mbMode != AVC_I16)
-    {
-        /* decode coded_block_pattern */
-        status = EncodeCBP(currMB, stream);
-    }
-
-    /* calculate currMB->mb_qp_delta = currMB->QPy - video->QPyprev */
-    if (currMB->CBP > 0 || currMB->mbMode == AVC_I16)
-    {
-        status = se_v(stream, currMB->QPy - video->QPy);
-        video->QPy = currMB->QPy; /* = (video->QPyprev + currMB->mb_qp_delta + 52)%52; */
-        // no need video->QPc = currMB->QPc;
-    }
-    else
-    {
-        if (currMB->QPy != video->QPy) // current QP is not the same as previous QP
-        {
-            /* restore these values */
-            RCRestoreQP(currMB, video, encvid);
-        }
-    }
-
-    return status;
-}
-
-
-/* inputs are mbMode, mb_intra, i16Mode, CBP, NumMbPart, MbPartWidth, MbPartHeight */
-uint InterpretMBType(AVCMacroblock *currMB, int slice_type)
-{
-    int CBP_chrom;
-    int mb_type;// part1, part2, part3;
-//  const static int MapParts2Type[2][3][3]={{{4,8,12},{10,6,14},{16,18,20}},
-//  {{5,9,13},{11,7,15},{17,19,21}}};
-
-    if (currMB->mb_intra)
-    {
-        if (currMB->mbMode == AVC_I4)
-        {
-            mb_type = 0;
-        }
-        else if (currMB->mbMode == AVC_I16)
-        {
-            CBP_chrom = (currMB->CBP & 0x30);
-            if (currMB->CBP&0xF)
-            {
-                currMB->CBP |= 0xF;  /* either 0x0 or 0xF */
-                mb_type = 13;
-            }
-            else
-            {
-                mb_type = 1;
-            }
-            mb_type += (CBP_chrom >> 2) + currMB->i16Mode;
-        }
-        else /* if(currMB->mbMode == AVC_I_PCM) */
-        {
-            mb_type = 25;
-        }
-    }
-    else
-    {  /* P-MB *//* note that the order of the enum AVCMBMode cannot be changed
-        since we use it here. */
-        mb_type = currMB->mbMode - AVC_P16;
-    }
-
-    if (slice_type == AVC_P_SLICE)
-    {
-        if (currMB->mb_intra)
-        {
-            mb_type += 5;
-        }
-    }
-    // following codes have not been tested yet, not needed.
-    /*  else if(slice_type == AVC_B_SLICE)
-        {
-            if(currMB->mbMode == AVC_BDirect16)
-            {
-                mb_type = 0;
-            }
-            else if(currMB->mbMode == AVC_P16)
-            {
-                mb_type = currMB->MBPartPredMode[0][0] + 1; // 1 or 2
-            }
-            else if(currMB->mbMode == AVC_P8)
-            {
-                mb_type = 26;
-            }
-            else if(currMB->mbMode == AVC_P8ref0)
-            {
-                mb_type = 27;
-            }
-            else
-            {
-                part1 = currMB->mbMode - AVC_P16x8;
-                part2 = currMB->MBPartPredMode[0][0];
-                part3 = currMB->MBPartPredMode[1][0];
-                mb_type = MapParts2Type[part1][part2][part3];
-            }
-        }
-
-        if(slice_type == AVC_SI_SLICE)
-        {
-            mb_type++;
-        }
-    */
-    return (uint)mb_type;
-}
-
-//const static int mbPart2raster[3][4] = {{0,0,0,0},{1,1,0,0},{1,0,1,0}};
-
-/* see subclause 7.3.5.1 */
-AVCEnc_Status mb_pred(AVCCommonObj *video, AVCMacroblock *currMB, AVCEncBitstream *stream)
-{
-    AVCEnc_Status status = AVCENC_SUCCESS;
-    int mbPartIdx;
-    AVCSliceHeader *sliceHdr = video->sliceHdr;
-    int max_ref_idx;
-    uint code;
-
-    if (currMB->mbMode == AVC_I4 || currMB->mbMode == AVC_I16)
-    {
-        if (currMB->mbMode == AVC_I4)
-        {
-            /* perform prediction to get the actual intra 4x4 pred mode */
-            EncodeIntra4x4Mode(video, currMB, stream);
-            /* output will be in currMB->i4Mode[4][4] */
-        }
-
-        /* assume already set from MBPrediction() */
-        status = ue_v(stream, currMB->intra_chroma_pred_mode);
-    }
-    else if (currMB->MBPartPredMode[0][0] != AVC_Direct)
-    {
-
-        memset(currMB->ref_idx_L0, 0, sizeof(int16)*4);
-
-        /* see subclause 7.4.5.1 for the range of ref_idx_lX */
-        max_ref_idx = sliceHdr->num_ref_idx_l0_active_minus1;
-        /*      if(video->MbaffFrameFlag && currMB->mb_field_decoding_flag)
-                    max_ref_idx = 2*sliceHdr->num_ref_idx_l0_active_minus1 + 1;
-        */
-        /* decode ref index for L0 */
-        if (sliceHdr->num_ref_idx_l0_active_minus1 > 0)
-        {
-            for (mbPartIdx = 0; mbPartIdx < currMB->NumMbPart; mbPartIdx++)
-            {
-                if (/*(sliceHdr->num_ref_idx_l0_active_minus1>0 || currMB->mb_field_decoding_flag) &&*/
-                    currMB->MBPartPredMode[mbPartIdx][0] != AVC_Pred_L1)
-                {
-                    code = currMB->ref_idx_L0[mbPartIdx];
-                    status = te_v(stream, code, max_ref_idx);
-                }
-            }
-        }
-
-        /* see subclause 7.4.5.1 for the range of ref_idx_lX */
-        max_ref_idx = sliceHdr->num_ref_idx_l1_active_minus1;
-        /*      if(video->MbaffFrameFlag && currMB->mb_field_decoding_flag)
-                    max_ref_idx = 2*sliceHdr->num_ref_idx_l1_active_minus1 + 1;
-        */
-        /* decode ref index for L1 */
-        if (sliceHdr->num_ref_idx_l1_active_minus1 > 0)
-        {
-            for (mbPartIdx = 0; mbPartIdx < currMB->NumMbPart; mbPartIdx++)
-            {
-                if (/*(sliceHdr->num_ref_idx_l1_active_minus1>0 || currMB->mb_field_decoding_flag) &&*/
-                    currMB->MBPartPredMode[mbPartIdx][0] != AVC_Pred_L0)
-                {
-                    status = te_v(stream, currMB->ref_idx_L1[mbPartIdx], max_ref_idx);
-                }
-            }
-        }
-
-        /* encode mvd_l0 */
-        for (mbPartIdx = 0; mbPartIdx < currMB->NumMbPart; mbPartIdx++)
-        {
-            if (currMB->MBPartPredMode[mbPartIdx][0] != AVC_Pred_L1)
-            {
-                status = se_v(stream, video->mvd_l0[mbPartIdx][0][0]);
-                status = se_v(stream, video->mvd_l0[mbPartIdx][0][1]);
-            }
-        }
-        /* encode mvd_l1 */
-        for (mbPartIdx = 0; mbPartIdx < currMB->NumMbPart; mbPartIdx++)
-        {
-            if (currMB->MBPartPredMode[mbPartIdx][0] != AVC_Pred_L0)
-            {
-                status = se_v(stream, video->mvd_l1[mbPartIdx][0][0]);
-                status = se_v(stream, video->mvd_l1[mbPartIdx][0][1]);
-            }
-        }
-    }
-
-    return status;
-}
-
-/* see subclause 7.3.5.2 */
-AVCEnc_Status sub_mb_pred(AVCCommonObj *video, AVCMacroblock *currMB, AVCEncBitstream *stream)
-{
-    AVCEnc_Status status = AVCENC_SUCCESS;
-    int mbPartIdx, subMbPartIdx;
-    AVCSliceHeader *sliceHdr = video->sliceHdr;
-    uint max_ref_idx;
-    uint slice_type = video->slice_type;
-    uint sub_mb_type[4];
-
-    /* this should move somewhere else where we don't have to make this check */
-    if (currMB->mbMode == AVC_P8ref0)
-    {
-        memset(currMB->ref_idx_L0, 0, sizeof(int16)*4);
-    }
-
-    /* we have to check the values to make sure they are valid  */
-    /* assign values to currMB->sub_mb_type[] */
-    if (slice_type == AVC_P_SLICE)
-    {
-        InterpretSubMBTypeP(currMB, sub_mb_type);
-    }
-    /* no need to check for B-slice
-        else if(slice_type == AVC_B_SLICE)
-        {
-            InterpretSubMBTypeB(currMB,sub_mb_type);
-        }*/
-
-    for (mbPartIdx = 0; mbPartIdx < 4; mbPartIdx++)
-    {
-        status = ue_v(stream, sub_mb_type[mbPartIdx]);
-    }
-
-    /* see subclause 7.4.5.1 for the range of ref_idx_lX */
-    max_ref_idx = sliceHdr->num_ref_idx_l0_active_minus1;
-    /*  if(video->MbaffFrameFlag && currMB->mb_field_decoding_flag)
-            max_ref_idx = 2*sliceHdr->num_ref_idx_l0_active_minus1 + 1; */
-
-    for (mbPartIdx = 0; mbPartIdx < 4; mbPartIdx++)
-    {
-        if ((sliceHdr->num_ref_idx_l0_active_minus1 > 0 /*|| currMB->mb_field_decoding_flag*/) &&
-                currMB->mbMode != AVC_P8ref0 && /*currMB->subMbMode[mbPartIdx]!=AVC_BDirect8 &&*/
-                currMB->MBPartPredMode[mbPartIdx][0] != AVC_Pred_L1)
-        {
-            status = te_v(stream, currMB->ref_idx_L0[mbPartIdx], max_ref_idx);
-        }
-        /* used in deblocking */
-        currMB->RefIdx[mbPartIdx] = video->RefPicList0[currMB->ref_idx_L0[mbPartIdx]]->RefIdx;
-    }
-    /* see subclause 7.4.5.1 for the range of ref_idx_lX */
-    max_ref_idx = sliceHdr->num_ref_idx_l1_active_minus1;
-    /*  if(video->MbaffFrameFlag && currMB->mb_field_decoding_flag)
-            max_ref_idx = 2*sliceHdr->num_ref_idx_l1_active_minus1 + 1;*/
-
-    if (sliceHdr->num_ref_idx_l1_active_minus1 > 0)
-    {
-        for (mbPartIdx = 0; mbPartIdx < 4; mbPartIdx++)
-        {
-            if (/*(sliceHdr->num_ref_idx_l1_active_minus1>0 || currMB->mb_field_decoding_flag) &&*/
-                /*currMB->subMbMode[mbPartIdx]!=AVC_BDirect8 &&*/
-                currMB->MBPartPredMode[mbPartIdx][0] != AVC_Pred_L0)
-            {
-                status = te_v(stream, currMB->ref_idx_L1[mbPartIdx], max_ref_idx);
-            }
-        }
-    }
-
-    for (mbPartIdx = 0; mbPartIdx < 4; mbPartIdx++)
-    {
-        if (/*currMB->subMbMode[mbPartIdx]!=AVC_BDirect8 &&*/
-            currMB->MBPartPredMode[mbPartIdx][0] != AVC_Pred_L1)
-        {
-            for (subMbPartIdx = 0; subMbPartIdx < currMB->NumSubMbPart[mbPartIdx]; subMbPartIdx++)
-            {
-                status = se_v(stream, video->mvd_l0[mbPartIdx][subMbPartIdx][0]);
-                status = se_v(stream, video->mvd_l0[mbPartIdx][subMbPartIdx][1]);
-            }
-        }
-    }
-
-    for (mbPartIdx = 0; mbPartIdx < 4; mbPartIdx++)
-    {
-        if (/*currMB->subMbMode[mbPartIdx]!=AVC_BDirect8 &&*/
-            currMB->MBPartPredMode[mbPartIdx][0] != AVC_Pred_L0)
-        {
-            for (subMbPartIdx = 0; subMbPartIdx < currMB->NumSubMbPart[mbPartIdx]; subMbPartIdx++)
-            {
-                status = se_v(stream, video->mvd_l1[mbPartIdx][subMbPartIdx][0]);
-                status = se_v(stream, video->mvd_l1[mbPartIdx][subMbPartIdx][1]);
-            }
-        }
-    }
-
-    return status;
-}
-
-/* input is mblock->sub_mb_type[] */
-void InterpretSubMBTypeP(AVCMacroblock *mblock, uint *sub_mb_type)
-{
-    int i;
-    /* see enum AVCMBType declaration */
-    /*const static AVCSubMBMode map2subMbMode[4] = {AVC_8x8,AVC_8x4,AVC_4x8,AVC_4x4};
-    const static int map2subPartWidth[4] = {8,8,4,4};
-    const static int map2subPartHeight[4] = {8,4,8,4};
-    const static int map2numSubPart[4] = {1,2,2,4};*/
-
-    for (i = 0; i < 4 ; i++)
-    {
-        sub_mb_type[i] = mblock->subMbMode[i] - AVC_8x8;
-    }
-
-    return ;
-}
-
-void InterpretSubMBTypeB(AVCMacroblock *mblock, uint *sub_mb_type)
-{
-    int i;
-    /* see enum AVCMBType declaration */
-    /*  const static AVCSubMBMode map2subMbMode[13] = {AVC_BDirect8,AVC_8x8,AVC_8x8,
-            AVC_8x8,AVC_8x4,AVC_4x8,AVC_8x4,AVC_4x8,AVC_8x4,AVC_4x8,AVC_4x4,AVC_4x4,AVC_4x4};
-        const static int map2subPartWidth[13] = {4,8,8,8,8,4,8,4,8,4,4,4,4};
-        const static int map2subPartHeight[13] = {4,8,8,8,4,8,4,8,4,8,4,4,4};
-        const static int map2numSubPart[13] = {4,1,1,1,2,2,2,2,2,2,4,4,4};
-        const static int map2predMode[13] = {3,0,1,2,0,0,1,1,2,2,0,1,2};*/
-
-    for (i = 0; i < 4 ; i++)
-    {
-        if (mblock->subMbMode[i] == AVC_BDirect8)
-        {
-            sub_mb_type[i] = 0;
-        }
-        else if (mblock->subMbMode[i] == AVC_8x8)
-        {
-            sub_mb_type[i] = 1 + mblock->MBPartPredMode[i][0];
-        }
-        else if (mblock->subMbMode[i] == AVC_4x4)
-        {
-            sub_mb_type[i] = 10 + mblock->MBPartPredMode[i][0];
-        }
-        else
-        {
-            sub_mb_type[i] = 4 + (mblock->MBPartPredMode[i][0] << 1) + (mblock->subMbMode[i] - AVC_8x4);
-        }
-    }
-
-    return ;
-}
-
-/* see subclause 8.3.1 */
-AVCEnc_Status EncodeIntra4x4Mode(AVCCommonObj *video, AVCMacroblock *currMB, AVCEncBitstream *stream)
-{
-    int intra4x4PredModeA = 0;
-    int intra4x4PredModeB, predIntra4x4PredMode;
-    int component, SubBlock_indx, block_x, block_y;
-    int dcOnlyPredictionFlag;
-    uint    flag;
-    int     rem = 0;
-    int     mode;
-    int bindx = 0;
-
-    for (component = 0; component < 4; component++) /* partition index */
-    {
-        block_x = ((component & 1) << 1);
-        block_y = ((component >> 1) << 1);
-
-        for (SubBlock_indx = 0; SubBlock_indx < 4; SubBlock_indx++) /* sub-partition index */
-        {
-            dcOnlyPredictionFlag = 0;
-            if (block_x > 0)
-            {
-                intra4x4PredModeA = currMB->i4Mode[(block_y << 2) + block_x - 1 ];
-            }
-            else
-            {
-                if (video->intraAvailA)
-                {
-                    if (video->mblock[video->mbAddrA].mbMode == AVC_I4)
-                    {
-                        intra4x4PredModeA = video->mblock[video->mbAddrA].i4Mode[(block_y << 2) + 3];
-                    }
-                    else
-                    {
-                        intra4x4PredModeA = AVC_I4_DC;
-                    }
-                }
-                else
-                {
-                    dcOnlyPredictionFlag = 1;
-                }
-            }
-
-            if (block_y > 0)
-            {
-                intra4x4PredModeB = currMB->i4Mode[((block_y-1) << 2) + block_x];
-            }
-            else
-            {
-                if (video->intraAvailB)
-                {
-                    if (video->mblock[video->mbAddrB].mbMode == AVC_I4)
-                    {
-                        intra4x4PredModeB = video->mblock[video->mbAddrB].i4Mode[(3 << 2) + block_x];
-                    }
-                    else
-                    {
-                        intra4x4PredModeB = AVC_I4_DC;
-                    }
-                }
-                else
-                {
-                    dcOnlyPredictionFlag = 1;
-                }
-            }
-
-            if (dcOnlyPredictionFlag)
-            {
-                intra4x4PredModeA = intra4x4PredModeB = AVC_I4_DC;
-            }
-
-            predIntra4x4PredMode = AVC_MIN(intra4x4PredModeA, intra4x4PredModeB);
-
-            flag = 0;
-            mode = currMB->i4Mode[(block_y<<2)+block_x];
-
-            if (mode == (AVCIntra4x4PredMode)predIntra4x4PredMode)
-            {
-                flag = 1;
-            }
-            else if (mode < predIntra4x4PredMode)
-            {
-                rem = mode;
-            }
-            else
-            {
-                rem = mode - 1;
-            }
-
-            BitstreamWrite1Bit(stream, flag);
-
-            if (!flag)
-            {
-                BitstreamWriteBits(stream, 3, rem);
-            }
-
-            bindx++;
-            block_y += (SubBlock_indx & 1) ;
-            block_x += (1 - 2 * (SubBlock_indx & 1)) ;
-        }
-    }
-
-    return AVCENC_SUCCESS;
-}
-
-
-
diff --git a/media/libstagefright/codecs/avc/enc/src/vlc_encode.cpp b/media/libstagefright/codecs/avc/enc/src/vlc_encode.cpp
deleted file mode 100644
index 222e709..0000000
--- a/media/libstagefright/codecs/avc/enc/src/vlc_encode.cpp
+++ /dev/null
@@ -1,336 +0,0 @@
-/* ------------------------------------------------------------------
- * 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 "avcenc_lib.h"
-
-/**
-See algorithm in subclause 9.1, Table 9-1, Table 9-2. */
-AVCEnc_Status ue_v(AVCEncBitstream *bitstream, uint codeNum)
-{
-    if (AVCENC_SUCCESS != SetEGBitstring(bitstream, codeNum))
-        return AVCENC_FAIL;
-
-    return AVCENC_SUCCESS;
-}
-
-/**
-See subclause 9.1.1, Table 9-3 */
-AVCEnc_Status  se_v(AVCEncBitstream *bitstream, int value)
-{
-    uint codeNum;
-    AVCEnc_Status status;
-
-    if (value <= 0)
-    {
-        codeNum = -value * 2;
-    }
-    else
-    {
-        codeNum = value * 2 - 1;
-    }
-
-    status = ue_v(bitstream, codeNum);
-
-    return status;
-}
-
-AVCEnc_Status te_v(AVCEncBitstream *bitstream, uint value, uint range)
-{
-    AVCEnc_Status status;
-
-    if (range > 1)
-    {
-        return ue_v(bitstream, value);
-    }
-    else
-    {
-        status = BitstreamWrite1Bit(bitstream, 1 - value);
-        return status;
-    }
-}
-
-/**
-See subclause 9.1, Table 9-1, 9-2. */
-// compute leadingZeros and inforbits
-//codeNum = (1<<leadingZeros)-1+infobits;
-AVCEnc_Status SetEGBitstring(AVCEncBitstream *bitstream, uint codeNum)
-{
-    AVCEnc_Status status;
-    int leadingZeros;
-    int infobits;
-
-    if (!codeNum)
-    {
-        status = BitstreamWrite1Bit(bitstream, 1);
-        return status;
-    }
-
-    /* calculate leadingZeros and infobits */
-    leadingZeros = 1;
-    while ((uint)(1 << leadingZeros) < codeNum + 2)
-    {
-        leadingZeros++;
-    }
-    leadingZeros--;
-    infobits = codeNum - (1 << leadingZeros) + 1;
-
-    status = BitstreamWriteBits(bitstream, leadingZeros, 0);
-    infobits |= (1 << leadingZeros);
-    status = BitstreamWriteBits(bitstream, leadingZeros + 1, infobits);
-    return status;
-}
-
-/* see Table 9-4 assignment of codeNum to values of coded_block_pattern. */
-const static uint8 MapCBP2code[48][2] =
-{
-    {3, 0}, {29, 2}, {30, 3}, {17, 7}, {31, 4}, {18, 8}, {37, 17}, {8, 13}, {32, 5}, {38, 18}, {19, 9}, {9, 14},
-    {20, 10}, {10, 15}, {11, 16}, {2, 11}, {16, 1}, {33, 32}, {34, 33}, {21, 36}, {35, 34}, {22, 37}, {39, 44}, {4, 40},
-    {36, 35}, {40, 45}, {23, 38}, {5, 41}, {24, 39}, {6, 42}, {7, 43}, {1, 19}, {41, 6}, {42, 24}, {43, 25}, {25, 20},
-    {44, 26}, {26, 21}, {46, 46}, {12, 28}, {45, 27}, {47, 47}, {27, 22}, {13, 29}, {28, 23}, {14, 30}, {15, 31}, {0, 12}
-};
-
-AVCEnc_Status EncodeCBP(AVCMacroblock *currMB, AVCEncBitstream *stream)
-{
-    AVCEnc_Status status;
-    uint codeNum;
-
-    if (currMB->mbMode == AVC_I4)
-    {
-        codeNum = MapCBP2code[currMB->CBP][0];
-    }
-    else
-    {
-        codeNum = MapCBP2code[currMB->CBP][1];
-    }
-
-    status = ue_v(stream, codeNum);
-
-    return status;
-}
-
-AVCEnc_Status ce_TotalCoeffTrailingOnes(AVCEncBitstream *stream, int TrailingOnes, int TotalCoeff, int nC)
-{
-    const static uint8 totCoeffTrailOne[3][4][17][2] =
-    {
-        {   // 0702
-            {{1, 1}, {6, 5}, {8, 7}, {9, 7}, {10, 7}, {11, 7}, {13, 15}, {13, 11}, {13, 8}, {14, 15}, {14, 11}, {15, 15}, {15, 11}, {16, 15}, {16, 11}, {16, 7}, {16, 4}},
-            {{0, 0}, {2, 1}, {6, 4}, {8, 6}, {9, 6}, {10, 6}, {11, 6}, {13, 14}, {13, 10}, {14, 14}, {14, 10}, {15, 14}, {15, 10}, {15, 1}, {16, 14}, {16, 10}, {16, 6}},
-            {{0, 0}, {0, 0}, {3, 1}, {7, 5}, {8, 5}, {9, 5}, {10, 5}, {11, 5}, {13, 13}, {13, 9}, {14, 13}, {14, 9}, {15, 13}, {15, 9}, {16, 13}, {16, 9}, {16, 5}},
-            {{0, 0}, {0, 0}, {0, 0}, {5, 3}, {6, 3}, {7, 4}, {8, 4}, {9, 4}, {10, 4}, {11, 4}, {13, 12}, {14, 12}, {14, 8}, {15, 12}, {15, 8}, {16, 12}, {16, 8}},
-        },
-        {
-            {{2, 3}, {6, 11}, {6, 7}, {7, 7}, {8, 7}, {8, 4}, {9, 7}, {11, 15}, {11, 11}, {12, 15}, {12, 11}, {12, 8}, {13, 15}, {13, 11}, {13, 7}, {14, 9}, {14, 7}},
-            {{0, 0}, {2, 2}, {5, 7}, {6, 10}, {6, 6}, {7, 6}, {8, 6}, {9, 6}, {11, 14}, {11, 10}, {12, 14}, {12, 10}, {13, 14}, {13, 10}, {14, 11}, {14, 8}, {14, 6}},
-            {{0, 0}, {0, 0}, {3, 3}, {6, 9}, {6, 5}, {7, 5}, {8, 5}, {9, 5}, {11, 13}, {11, 9}, {12, 13}, {12, 9}, {13, 13}, {13, 9}, {13, 6}, {14, 10}, {14, 5}},
-            {{0, 0}, {0, 0}, {0, 0}, {4, 5}, {4, 4}, {5, 6}, {6, 8}, {6, 4}, {7, 4}, {9, 4}, {11, 12}, {11, 8}, {12, 12}, {13, 12}, {13, 8}, {13, 1}, {14, 4}},
-        },
-        {
-            {{4, 15}, {6, 15}, {6, 11}, {6, 8}, {7, 15}, {7, 11}, {7, 9}, {7, 8}, {8, 15}, {8, 11}, {9, 15}, {9, 11}, {9, 8}, {10, 13}, {10, 9}, {10, 5}, {10, 1}},
-            {{0, 0}, {4, 14}, {5, 15}, {5, 12}, {5, 10}, {5, 8}, {6, 14}, {6, 10}, {7, 14}, {8, 14}, {8, 10}, {9, 14}, {9, 10}, {9, 7}, {10, 12}, {10, 8}, {10, 4}},
-            {{0, 0}, {0, 0}, {4, 13}, {5, 14}, {5, 11}, {5, 9}, {6, 13}, {6, 9}, {7, 13}, {7, 10}, {8, 13}, {8, 9}, {9, 13}, {9, 9}, {10, 11}, {10, 7}, {10, 3}},
-            {{0, 0}, {0, 0}, {0, 0}, {4, 12}, {4, 11}, {4, 10}, {4, 9}, {4, 8}, {5, 13}, {6, 12}, {7, 12}, {8, 12}, {8, 8}, {9, 12}, {10, 10}, {10, 6}, {10, 2}}
-        }
-    };
-
-
-    AVCEnc_Status status = AVCENC_SUCCESS;
-    uint code, len;
-    int vlcnum;
-
-    if (TrailingOnes > 3)
-    {
-        return AVCENC_TRAILINGONES_FAIL;
-    }
-
-    if (nC >= 8)
-    {
-        if (TotalCoeff)
-        {
-            code = ((TotalCoeff - 1) << 2) | (TrailingOnes);
-        }
-        else
-        {
-            code = 3;
-        }
-        status = BitstreamWriteBits(stream, 6, code);
-    }
-    else
-    {
-        if (nC < 2)
-        {
-            vlcnum = 0;
-        }
-        else if (nC < 4)
-        {
-            vlcnum = 1;
-        }
-        else
-        {
-            vlcnum = 2;
-        }
-
-        len = totCoeffTrailOne[vlcnum][TrailingOnes][TotalCoeff][0];
-        code = totCoeffTrailOne[vlcnum][TrailingOnes][TotalCoeff][1];
-        status = BitstreamWriteBits(stream, len, code);
-    }
-
-    return status;
-}
-
-AVCEnc_Status ce_TotalCoeffTrailingOnesChromaDC(AVCEncBitstream *stream, int TrailingOnes, int TotalCoeff)
-{
-    const static uint8 totCoeffTrailOneChrom[4][5][2] =
-    {
-        { {2, 1}, {6, 7}, {6, 4}, {6, 3}, {6, 2}},
-        { {0, 0}, {1, 1}, {6, 6}, {7, 3}, {8, 3}},
-        { {0, 0}, {0, 0}, {3, 1}, {7, 2}, {8, 2}},
-        { {0, 0}, {0, 0}, {0, 0}, {6, 5}, {7, 0}},
-    };
-
-    AVCEnc_Status status = AVCENC_SUCCESS;
-    uint code, len;
-
-    len = totCoeffTrailOneChrom[TrailingOnes][TotalCoeff][0];
-    code = totCoeffTrailOneChrom[TrailingOnes][TotalCoeff][1];
-    status = BitstreamWriteBits(stream, len, code);
-
-    return status;
-}
-
-/* see Table 9-7 and 9-8 */
-AVCEnc_Status ce_TotalZeros(AVCEncBitstream *stream, int total_zeros, int TotalCoeff)
-{
-    const static uint8 lenTotalZeros[15][16] =
-    {
-        { 1, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 9},
-        { 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 6, 6, 6, 6},
-        { 4, 3, 3, 3, 4, 4, 3, 3, 4, 5, 5, 6, 5, 6},
-        { 5, 3, 4, 4, 3, 3, 3, 4, 3, 4, 5, 5, 5},
-        { 4, 4, 4, 3, 3, 3, 3, 3, 4, 5, 4, 5},
-        { 6, 5, 3, 3, 3, 3, 3, 3, 4, 3, 6},
-        { 6, 5, 3, 3, 3, 2, 3, 4, 3, 6},
-        { 6, 4, 5, 3, 2, 2, 3, 3, 6},
-        { 6, 6, 4, 2, 2, 3, 2, 5},
-        { 5, 5, 3, 2, 2, 2, 4},
-        { 4, 4, 3, 3, 1, 3},
-        { 4, 4, 2, 1, 3},
-        { 3, 3, 1, 2},
-        { 2, 2, 1},
-        { 1, 1},
-    };
-
-    const static uint8 codTotalZeros[15][16] =
-    {
-        {1, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 1},
-        {7, 6, 5, 4, 3, 5, 4, 3, 2, 3, 2, 3, 2, 1, 0},
-        {5, 7, 6, 5, 4, 3, 4, 3, 2, 3, 2, 1, 1, 0},
-        {3, 7, 5, 4, 6, 5, 4, 3, 3, 2, 2, 1, 0},
-        {5, 4, 3, 7, 6, 5, 4, 3, 2, 1, 1, 0},
-        {1, 1, 7, 6, 5, 4, 3, 2, 1, 1, 0},
-        {1, 1, 5, 4, 3, 3, 2, 1, 1, 0},
-        {1, 1, 1, 3, 3, 2, 2, 1, 0},
-        {1, 0, 1, 3, 2, 1, 1, 1, },
-        {1, 0, 1, 3, 2, 1, 1, },
-        {0, 1, 1, 2, 1, 3},
-        {0, 1, 1, 1, 1},
-        {0, 1, 1, 1},
-        {0, 1, 1},
-        {0, 1},
-    };
-    int len, code;
-    AVCEnc_Status status;
-
-    len = lenTotalZeros[TotalCoeff-1][total_zeros];
-    code = codTotalZeros[TotalCoeff-1][total_zeros];
-
-    status = BitstreamWriteBits(stream, len, code);
-
-    return status;
-}
-
-/* see Table 9-9 */
-AVCEnc_Status ce_TotalZerosChromaDC(AVCEncBitstream *stream, int total_zeros, int TotalCoeff)
-{
-    const static uint8 lenTotalZerosChromaDC[3][4] =
-    {
-        { 1, 2, 3, 3, },
-        { 1, 2, 2, 0, },
-        { 1, 1, 0, 0, },
-    };
-
-    const static uint8 codTotalZerosChromaDC[3][4] =
-    {
-        { 1, 1, 1, 0, },
-        { 1, 1, 0, 0, },
-        { 1, 0, 0, 0, },
-    };
-
-    int len, code;
-    AVCEnc_Status status;
-
-    len = lenTotalZerosChromaDC[TotalCoeff-1][total_zeros];
-    code = codTotalZerosChromaDC[TotalCoeff-1][total_zeros];
-
-    status = BitstreamWriteBits(stream, len, code);
-
-    return status;
-}
-
-/* see Table 9-10 */
-AVCEnc_Status ce_RunBefore(AVCEncBitstream *stream, int run_before, int zerosLeft)
-{
-    const static uint8 lenRunBefore[7][16] =
-    {
-        {1, 1},
-        {1, 2, 2},
-        {2, 2, 2, 2},
-        {2, 2, 2, 3, 3},
-        {2, 2, 3, 3, 3, 3},
-        {2, 3, 3, 3, 3, 3, 3},
-        {3, 3, 3, 3, 3, 3, 3, 4, 5, 6, 7, 8, 9, 10, 11},
-    };
-
-    const static uint8 codRunBefore[7][16] =
-    {
-        {1, 0},
-        {1, 1, 0},
-        {3, 2, 1, 0},
-        {3, 2, 1, 1, 0},
-        {3, 2, 3, 2, 1, 0},
-        {3, 0, 1, 3, 2, 5, 4},
-        {7, 6, 5, 4, 3, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1},
-    };
-
-    int len, code;
-    AVCEnc_Status status;
-
-    if (zerosLeft <= 6)
-    {
-        len = lenRunBefore[zerosLeft-1][run_before];
-        code = codRunBefore[zerosLeft-1][run_before];
-    }
-    else
-    {
-        len = lenRunBefore[6][run_before];
-        code = codRunBefore[6][run_before];
-    }
-
-    status = BitstreamWriteBits(stream, len, code);
-
-
-    return status;
-}
diff --git a/media/libstagefright/codecs/avc/enc/test/h264_enc_test.cpp b/media/libstagefright/codecs/avc/enc/test/h264_enc_test.cpp
deleted file mode 100644
index 7a782a8..0000000
--- a/media/libstagefright/codecs/avc/enc/test/h264_enc_test.cpp
+++ /dev/null
@@ -1,357 +0,0 @@
-/*
- * Copyright (C) 2014 The Android Open Source Project
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in
- * the documentation and/or other materials provided with the
- * distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
- * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
- * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
- * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <stdio.h>
-#include <stdint.h>
-#include <assert.h>
-#include <stdlib.h>
-
-#include "avcenc_api.h"
-#include "avcenc_int.h"
-
-// Constants.
-enum {
-    kMaxWidth         = 720,
-    kMaxHeight        = 480,
-    kMaxFrameRate     = 30,
-    kMaxBitrate       = 2048, // in kbps.
-    kInputBufferSize  = (kMaxWidth * kMaxHeight * 3) / 2, // For YUV 420 format.
-    kOutputBufferSize = kInputBufferSize,
-    kMaxDpbBuffers    = 17,
-    kIDRFrameRefreshIntervalInSec = 1,
-};
-
-
-static void *MallocCb(void * /*userData*/, int32_t size, int32_t /*attrs*/) {
-    void *ptr = calloc(size, 1);
-    return ptr;
-}
-
-static void FreeCb(void * /*userData*/, void *ptr) {
-    free(ptr);
-}
-
-static int32_t DpbAllocCb(void * /*userData*/,
-        unsigned int sizeInMbs, unsigned int numBuffers) {
-
-    size_t frameSize = (sizeInMbs << 7) * 3;
-    if(numBuffers < kMaxDpbBuffers && frameSize <= kInputBufferSize) {
-        return 1;
-    } else {
-        return 0;
-    }
-}
-
-static int32_t BindFrameCb(void *userData, int32_t index, uint8_t **yuv) {
-     assert(index < kMaxDpbBuffers);
-     uint8_t** dpbBuffer = static_cast<uint8_t**>(userData);
-     *yuv = dpbBuffer[index];
-     return 1;
-}
-
-static void UnbindFrameCb(void * /*userData*/, int32_t /*index*/) {
-}
-
-int main(int argc, char *argv[]) {
-
-    if (argc < 7) {
-        fprintf(stderr, "Usage %s <input yuv> <output file> <width> <height>"
-                        " <frame rate> <bitrate in kbps>\n", argv[0]);
-        fprintf(stderr, "Max width %d\n", kMaxWidth);
-        fprintf(stderr, "Max height %d\n", kMaxHeight);
-        fprintf(stderr, "Max framerate %d\n", kMaxFrameRate);
-        fprintf(stderr, "Max bitrate %d kbps\n", kMaxBitrate);
-        return EXIT_FAILURE;
-    }
-
-    // Read height and width.
-    int32_t width;
-    int32_t height;
-    width = atoi(argv[3]);
-    height = atoi(argv[4]);
-    if (width > kMaxWidth || height > kMaxHeight || width <= 0 || height <= 0) {
-        fprintf(stderr, "Unsupported dimensions %dx%d\n", width, height);
-        return EXIT_FAILURE;
-    }
-
-    if (width % 16 != 0 || height % 16 != 0) {
-        fprintf(stderr, "Video frame size %dx%d must be a multiple of 16\n",
-            width, height);
-        return EXIT_FAILURE;
-    }
-
-    // Read frame rate.
-    int32_t frameRate;
-    frameRate = atoi(argv[5]);
-    if (frameRate > kMaxFrameRate || frameRate <= 0) {
-        fprintf(stderr, "Unsupported frame rate %d\n", frameRate);
-        return EXIT_FAILURE;
-    }
-
-    // Read bit rate.
-    int32_t bitrate;
-    bitrate = atoi(argv[6]);
-    if (bitrate > kMaxBitrate || bitrate <= 0) {
-        fprintf(stderr, "Unsupported bitrate %d\n", bitrate);
-        return EXIT_FAILURE;
-    }
-    bitrate *= 1024; // kbps to bps.
-
-    // Open the input file.
-    FILE *fpInput = fopen(argv[1], "rb");
-    if (!fpInput) {
-        fprintf(stderr, "Could not open %s\n", argv[1]);
-        return EXIT_FAILURE;
-    }
-
-    // Open the output file.
-    FILE *fpOutput = fopen(argv[2], "wb");
-    if (!fpOutput) {
-        fprintf(stderr, "Could not open %s\n", argv[2]);
-        fclose(fpInput);
-        return EXIT_FAILURE;
-    }
-
-    // Allocate input buffer.
-    uint8_t *inputBuf = (uint8_t *)malloc(kInputBufferSize);
-    assert(inputBuf != NULL);
-
-    // Allocate output buffer.
-    uint8_t *outputBuf = (uint8_t *)malloc(kOutputBufferSize);
-    assert(outputBuf != NULL);
-
-    // Allocate dpb buffers.
-    uint8_t * dpbBuffers[kMaxDpbBuffers];
-    for (int i = 0; i < kMaxDpbBuffers; ++i) {
-        dpbBuffers[i] = (uint8_t *)malloc(kInputBufferSize);
-        assert(dpbBuffers[i] != NULL);
-    }
-
-    // Initialize the encoder parameters.
-    tagAVCEncParam encParams;
-    memset(&encParams, 0, sizeof(tagAVCEncParam));
-    encParams.rate_control = AVC_ON;
-    encParams.initQP = 0;
-    encParams.init_CBP_removal_delay = 1600;
-
-    encParams.intramb_refresh = 0;
-    encParams.auto_scd = AVC_ON;
-    encParams.out_of_band_param_set = AVC_ON;
-    encParams.poc_type = 2;
-    encParams.log2_max_poc_lsb_minus_4 = 12;
-    encParams.delta_poc_zero_flag = 0;
-    encParams.offset_poc_non_ref = 0;
-    encParams.offset_top_bottom = 0;
-    encParams.num_ref_in_cycle = 0;
-    encParams.offset_poc_ref = NULL;
-
-    encParams.num_ref_frame = 1;
-    encParams.num_slice_group = 1;
-    encParams.fmo_type = 0;
-
-    encParams.db_filter = AVC_ON;
-    encParams.disable_db_idc = 0;
-
-    encParams.alpha_offset = 0;
-    encParams.beta_offset = 0;
-    encParams.constrained_intra_pred = AVC_OFF;
-
-    encParams.data_par = AVC_OFF;
-    encParams.fullsearch = AVC_OFF;
-    encParams.search_range = 16;
-    encParams.sub_pel = AVC_OFF;
-    encParams.submb_pred = AVC_OFF;
-    encParams.rdopt_mode = AVC_OFF;
-    encParams.bidir_pred = AVC_OFF;
-
-    encParams.use_overrun_buffer = AVC_OFF;
-
-    encParams.width = width;
-    encParams.height = height;
-    encParams.bitrate = bitrate;
-    encParams.frame_rate = 1000 * frameRate;  // In frames/ms.
-    encParams.CPB_size = (uint32_t) (bitrate >> 1);
-
-    int32_t  IDRFrameRefreshIntervalInSec = kIDRFrameRefreshIntervalInSec;
-    if (IDRFrameRefreshIntervalInSec == 0) {
-        encParams.idr_period = 1;  // All I frames.
-    } else {
-        encParams.idr_period = (IDRFrameRefreshIntervalInSec * frameRate);
-    }
-
-    int32_t nMacroBlocks = ((((width + 15) >> 4) << 4) *
-            (((height + 15) >> 4) << 4)) >> 8;
-    uint32_t *sliceGroup = (uint32_t *) malloc(sizeof(uint32_t) * nMacroBlocks);
-    assert(sliceGroup != NULL);
-    for (int i = 0, idx = 0; i < nMacroBlocks; ++i) {
-        sliceGroup[i] = idx++;
-        if (idx >= encParams.num_slice_group) {
-            idx = 0;
-        }
-    }
-    encParams.slice_group = sliceGroup;
-    encParams.profile = AVC_BASELINE;
-    encParams.level = AVC_LEVEL2;
-
-    // Initialize the handle.
-    tagAVCHandle handle;
-    memset(&handle, 0, sizeof(tagAVCHandle));
-    handle.AVCObject = NULL;
-    handle.userData = dpbBuffers;
-    handle.CBAVC_DPBAlloc = DpbAllocCb;
-    handle.CBAVC_FrameBind = BindFrameCb;
-    handle.CBAVC_FrameUnbind = UnbindFrameCb;
-    handle.CBAVC_Malloc = MallocCb;
-    handle.CBAVC_Free = FreeCb;
-
-    // Initialize the encoder.
-    AVCEnc_Status status;
-    status = PVAVCEncInitialize(&handle, &encParams, NULL, NULL);
-    if (status != AVCENC_SUCCESS) {
-        fprintf(stderr, "Failed to initialize the encoder\n");
-
-        // Release resources.
-        fclose(fpInput);
-        fclose(fpOutput);
-        free(sliceGroup);
-        free(inputBuf);
-        free(outputBuf);
-        for (int i = 0; i < kMaxDpbBuffers; ++i) {
-            free(dpbBuffers[i]);
-        }
-        return EXIT_FAILURE;
-    }
-
-    // Encode Sequence Parameter Set.
-    uint32_t dataLength = kOutputBufferSize;
-    int32_t type;
-    status = PVAVCEncodeNAL(&handle, outputBuf, &dataLength, &type);
-    assert(type == AVC_NALTYPE_SPS);
-    fwrite("\x00\x00\x00\x01", 1, 4, fpOutput); // Start Code.
-    fwrite(outputBuf, 1, dataLength, fpOutput); // SPS.
-
-    // Encode Picture Paramater Set.
-    dataLength = kOutputBufferSize;
-    status = PVAVCEncodeNAL(&handle, outputBuf, &dataLength, &type);
-    assert(type == AVC_NALTYPE_PPS);
-    fwrite("\x00\x00\x00\x01", 1, 4, fpOutput); // Start Code.
-    fwrite(outputBuf, 1, dataLength, fpOutput); // PPS.
-
-    // Core loop.
-    int32_t retVal = EXIT_SUCCESS;
-    int32_t frameSize = (width * height * 3) / 2;
-    int32_t numInputFrames = 0;
-    int32_t numNalEncoded = 0;
-    bool readyForNextFrame = true;
-
-    while (1) {
-        if (readyForNextFrame == true) {
-            // Read the input frame.
-            int32_t bytesRead;
-            bytesRead = fread(inputBuf, 1, frameSize, fpInput);
-            if (bytesRead != frameSize) {
-                break; // End of file.
-            }
-
-            // Set the input frame.
-            AVCFrameIO vin;
-            memset(&vin, 0, sizeof(vin));
-            vin.height = ((height + 15) >> 4) << 4;
-            vin.pitch  = ((width  + 15) >> 4) << 4;
-            vin.coding_timestamp = (numInputFrames * 1000) / frameRate;  // in ms
-            vin.YCbCr[0] = inputBuf;
-            vin.YCbCr[1] = vin.YCbCr[0] + vin.height * vin.pitch;
-            vin.YCbCr[2] = vin.YCbCr[1] + ((vin.height * vin.pitch) >> 2);
-            vin.disp_order = numInputFrames;
-
-            status = PVAVCEncSetInput(&handle, &vin);
-            if (status == AVCENC_SUCCESS || status == AVCENC_NEW_IDR) {
-                readyForNextFrame = false;
-                ++numInputFrames;
-            } else if (status < AVCENC_SUCCESS) {
-                fprintf(stderr, "Error %d while setting input frame\n", status);
-                retVal = EXIT_FAILURE;
-                break;
-            } else {
-                fprintf(stderr, "Frame drop\n");
-                readyForNextFrame = true;
-                ++numInputFrames;
-                continue;
-            }
-        }
-
-        // Encode the input frame.
-        dataLength = kOutputBufferSize;
-        status = PVAVCEncodeNAL(&handle, outputBuf, &dataLength, &type);
-        if (status == AVCENC_SUCCESS) {
-            PVAVCEncGetOverrunBuffer(&handle);
-        } else if (status == AVCENC_PICTURE_READY) {
-            PVAVCEncGetOverrunBuffer(&handle);
-            readyForNextFrame = true;
-            AVCFrameIO recon;
-            if (PVAVCEncGetRecon(&handle, &recon) == AVCENC_SUCCESS) {
-                PVAVCEncReleaseRecon(&handle, &recon);
-            }
-        } else {
-            dataLength = 0;
-            readyForNextFrame = true;
-        }
-
-        if (status < AVCENC_SUCCESS) {
-            fprintf(stderr, "Error %d while encoding frame\n", status);
-            retVal = EXIT_FAILURE;
-            break;
-        }
-
-        numNalEncoded++;
-
-        // Write the output.
-        if (dataLength > 0) {
-            fwrite("\x00\x00\x00\x01", 1, 4, fpOutput); // Start Code.
-            fwrite(outputBuf, 1, dataLength, fpOutput); // NAL.
-            printf("NAL %d of size %d written\n", numNalEncoded, dataLength + 4);
-        }
-    }
-
-    // Close input and output file.
-    fclose(fpInput);
-    fclose(fpOutput);
-
-    // Free allocated memory.
-    free(sliceGroup);
-    free(inputBuf);
-    free(outputBuf);
-    for (int i = 0; i < kMaxDpbBuffers; ++i) {
-        free(dpbBuffers[i]);
-    }
-
-    // Close encoder instance.
-    PVAVCCleanUpEncoder(&handle);
-
-    return retVal;
-}
diff --git a/media/libstagefright/codecs/avc/patent_disclaimer.txt b/media/libstagefright/codecs/avc/patent_disclaimer.txt
deleted file mode 100644
index b4bf11d..0000000
--- a/media/libstagefright/codecs/avc/patent_disclaimer.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-
-THIS IS NOT A GRANT OF PATENT RIGHTS.
-
-Google makes no representation or warranty that the codecs for which
-source code is made available hereunder are unencumbered by
-third-party patents.  Those intending to use this source code in
-hardware or software products are advised that implementations of
-these codecs, including in open source software or shareware, may
-require patent licenses from the relevant patent holders.
diff --git a/media/libstagefright/colorconversion/SoftwareRenderer.cpp b/media/libstagefright/colorconversion/SoftwareRenderer.cpp
index 54487b3..536d40d 100644
--- a/media/libstagefright/colorconversion/SoftwareRenderer.cpp
+++ b/media/libstagefright/colorconversion/SoftwareRenderer.cpp
@@ -23,6 +23,7 @@
 #include <media/stagefright/foundation/ADebug.h>
 #include <media/stagefright/foundation/AMessage.h>
 #include <system/window.h>
+#include <ui/Fence.h>
 #include <ui/GraphicBufferMapper.h>
 #include <ui/GraphicBuffer.h>
 #include <ui/Rect.h>
diff --git a/media/libstagefright/foundation/AMessage.cpp b/media/libstagefright/foundation/AMessage.cpp
index 1b0db33..f55de64 100644
--- a/media/libstagefright/foundation/AMessage.cpp
+++ b/media/libstagefright/foundation/AMessage.cpp
@@ -240,6 +240,24 @@
     return false;
 }
 
+bool AMessage::findAsInt64(const char *name, int64_t *value) const {
+    size_t i = findItemIndex(name, strlen(name));
+    if (i < mNumItems) {
+        const Item *item = &mItems[i];
+        switch (item->mType) {
+            case kTypeInt64:
+                *value = item->u.int64Value;
+                return true;
+            case kTypeInt32:
+                *value = item->u.int32Value;
+                return true;
+            default:
+                return false;
+        }
+    }
+    return false;
+}
+
 bool AMessage::contains(const char *name) const {
     size_t i = findItemIndex(name, strlen(name));
     return i < mNumItems;
diff --git a/media/libstagefright/foundation/Android.bp b/media/libstagefright/foundation/Android.bp
index 3548f96..9b2e7fa 100644
--- a/media/libstagefright/foundation/Android.bp
+++ b/media/libstagefright/foundation/Android.bp
@@ -50,5 +50,9 @@
             "unsigned-integer-overflow",
             "signed-integer-overflow",
         ],
+        cfi: true,
+        diag: {
+          cfi: true,
+        },
     },
 }
diff --git a/media/libstagefright/include/ACodec.h b/media/libstagefright/include/ACodec.h
index 998716f..c57005d 100644
--- a/media/libstagefright/include/ACodec.h
+++ b/media/libstagefright/include/ACodec.h
@@ -304,6 +304,12 @@
 
     std::shared_ptr<ACodecBufferChannel> mBufferChannel;
 
+    enum {
+        kExtensionsUnchecked,
+        kExtensionsNone,
+        kExtensionsExist,
+    } mVendorExtensionsStatus;
+
     status_t setCyclicIntraMacroblockRefresh(const sp<AMessage> &msg, int32_t mode);
     status_t allocateBuffersOnPort(OMX_U32 portIndex);
     status_t freeBuffersOnPort(OMX_U32 portIndex);
@@ -549,6 +555,13 @@
     status_t requestIDRFrame();
     status_t setParameters(const sp<AMessage> &params);
 
+    // set vendor extension parameters specified in params that are supported by the codec
+    status_t setVendorParameters(const sp<AMessage> &params);
+
+    // get vendor extension parameters supported by the codec for a specific port and add it to
+    // |format|
+    status_t getVendorParameters(OMX_U32 portIndex, sp<AMessage> &format);
+
     // Send EOS on input stream.
     void onSignalEndOfInputStream();
 
diff --git a/media/libstagefright/include/MediaCodec.h b/media/libstagefright/include/MediaCodec.h
index 30454dc..4140266 100644
--- a/media/libstagefright/include/MediaCodec.h
+++ b/media/libstagefright/include/MediaCodec.h
@@ -186,7 +186,7 @@
 
     status_t getName(AString *componentName) const;
 
-    status_t getMetrics(Parcel *reply);
+    status_t getMetrics(MediaAnalyticsItem * &reply);
 
     status_t setParameters(const sp<AMessage> &params);
 
diff --git a/media/libstagefright/include/foundation/AMessage.h b/media/libstagefright/include/foundation/AMessage.h
index 782f8e6..8580eb5 100644
--- a/media/libstagefright/include/foundation/AMessage.h
+++ b/media/libstagefright/include/foundation/AMessage.h
@@ -123,6 +123,9 @@
     bool findBuffer(const char *name, sp<ABuffer> *buffer) const;
     bool findMessage(const char *name, sp<AMessage> *obj) const;
 
+    // finds signed integer types cast to int64_t
+    bool findAsInt64(const char *name, int64_t *value) const;
+
     // finds any numeric type cast to a float
     bool findAsFloat(const char *name, float *value) const;
 
diff --git a/media/libstagefright/omx/GraphicBufferSource.cpp b/media/libstagefright/omx/GraphicBufferSource.cpp
index 793ecb8..dae1ee9 100644
--- a/media/libstagefright/omx/GraphicBufferSource.cpp
+++ b/media/libstagefright/omx/GraphicBufferSource.cpp
@@ -379,7 +379,7 @@
     // the action are overridden by the last action. For the other cases, traverse
     // the Queue to find the newest action that with timestamp smaller or equal to
     // the buffer's timestamp. For example, an action queue like
-    // [pause, 1s], [resume 2us], [pause 3us], [resume 4us], [pause 5us].... Upon
+    // [pause 1us], [resume 2us], [pause 3us], [resume 4us], [pause 5us].... Upon
     // receiving a buffer with timestamp 3.5us, only the action [pause, 3us] needs
     // to be handled and [pause, 1us], [resume 2us] will be discarded.
     bool dropped = false;
@@ -398,15 +398,14 @@
         }
 
         if (!done) {
+            // Find the newest action that with timestamp smaller than itemTimeUs. Then
+            // remove all the actions before and include the newest action.
             List<ActionItem>::iterator it = mActionQueue.begin();
-            while(it != mActionQueue.end()) {
+            while (it != mActionQueue.end() && it->mActionTimeUs <= itemTimeUs) {
                 nextAction = *it;
-                mActionQueue.erase(it);
-                if (nextAction.mActionTimeUs > itemTimeUs) {
-                    break;
-                }
                 ++it;
             }
+            mActionQueue.erase(mActionQueue.begin(), it);
 
             CHECK(itemTimeUs >= nextAction.mActionTimeUs);
             switch (nextAction.mAction) {
diff --git a/media/libstagefright/omx/OMXUtils.cpp b/media/libstagefright/omx/OMXUtils.cpp
index 38aad39..ee6d1d5 100644
--- a/media/libstagefright/omx/OMXUtils.cpp
+++ b/media/libstagefright/omx/OMXUtils.cpp
@@ -32,9 +32,13 @@
     switch (err) {
         case OMX_ErrorNone:
             return OK;
+        case OMX_ErrorNoMore:
+            return NOT_ENOUGH_DATA;
         case OMX_ErrorUnsupportedSetting:
         case OMX_ErrorUnsupportedIndex:
             return ERROR_UNSUPPORTED; // this is a media specific error
+        case OMX_ErrorBadParameter:
+            return BAD_VALUE;
         case OMX_ErrorInsufficientResources:
             return NO_MEMORY;
         case OMX_ErrorInvalidComponentName:
diff --git a/media/libstagefright/webm/WebmFrameThread.cpp b/media/libstagefright/webm/WebmFrameThread.cpp
index 7eb4745..77de3c8 100644
--- a/media/libstagefright/webm/WebmFrameThread.cpp
+++ b/media/libstagefright/webm/WebmFrameThread.cpp
@@ -37,17 +37,23 @@
 }
 
 status_t WebmFrameThread::start() {
+    status_t err = OK;
     pthread_attr_t attr;
     pthread_attr_init(&attr);
     pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
-    pthread_create(&mThread, &attr, WebmFrameThread::wrap, this);
+    if ((err = pthread_create(&mThread, &attr, WebmFrameThread::wrap, this))) {
+        mThread = 0;
+    }
     pthread_attr_destroy(&attr);
-    return OK;
+    return err;
 }
 
 status_t WebmFrameThread::stop() {
-    void *status;
-    pthread_join(mThread, &status);
+    void *status = nullptr;
+    if (mThread) {
+        pthread_join(mThread, &status);
+        mThread = 0;
+    }
     return (status_t)(intptr_t)status;
 }
 
diff --git a/media/ndk/Android.mk b/media/ndk/Android.mk
index 67b0ab1..0984ca4 100644
--- a/media/ndk/Android.mk
+++ b/media/ndk/Android.mk
@@ -38,6 +38,8 @@
     frameworks/base/core/jni \
     frameworks/base/media/jni \
     frameworks/av/include/ndk \
+    frameworks/native/include \
+    frameworks/native/include/media/openmax \
     system/media/camera/include \
     $(call include-path-for, libhardware)/hardware \
 
@@ -56,10 +58,12 @@
     liblog \
     libutils \
     libcutils \
+    libandroid \
     libandroid_runtime \
     libbinder \
     libgui \
     libui \
+    libandroid \
 
 include $(BUILD_SHARED_LIBRARY)
 
diff --git a/media/ndk/NdkImage.cpp b/media/ndk/NdkImage.cpp
index 6c9a644..95fdf36 100644
--- a/media/ndk/NdkImage.cpp
+++ b/media/ndk/NdkImage.cpp
@@ -31,10 +31,10 @@
 
 #define ALIGN(x, mask) ( ((x) + (mask) - 1) & ~((mask) - 1) )
 
-AImage::AImage(AImageReader* reader, int32_t format, uint64_t usage,
+AImage::AImage(AImageReader* reader, int32_t format, uint64_t usage0, uint64_t usage1,
         BufferItem* buffer, int64_t timestamp,
         int32_t width, int32_t height, int32_t numPlanes) :
-        mReader(reader), mFormat(format), mUsage(usage),
+        mReader(reader), mFormat(format), mUsage0(usage0), mUsage1(usage1),
         mBuffer(buffer), mLockedBuffer(nullptr), mTimestamp(timestamp),
         mWidth(width), mHeight(height), mNumPlanes(numPlanes) {
 }
@@ -54,7 +54,7 @@
 }
 
 void
-AImage::close() {
+AImage::close(int releaseFenceFd) {
     Mutex::Autolock _l(mLock);
     if (mIsClosed) {
         return;
@@ -64,7 +64,7 @@
         LOG_ALWAYS_FATAL("Error: AImage not closed before AImageReader close!");
         return;
     }
-    reader->releaseImageLocked(this);
+    reader->releaseImageLocked(this, releaseFenceFd);
     // Should have been set to nullptr in releaseImageLocked
     // Set to nullptr here for extra safety only
     mBuffer = nullptr;
@@ -178,9 +178,9 @@
         return AMEDIA_ERROR_INVALID_OBJECT;
     }
 
-    if ((mUsage & AHARDWAREBUFFER_USAGE0_CPU_READ_OFTEN) == 0) {
+    if ((mUsage0 & AHARDWAREBUFFER_USAGE0_CPU_READ_OFTEN) == 0) {
         ALOGE("%s: AImage %p does not have any software read usage bits set, usage=%" PRIu64 "",
-              __FUNCTION__, this, mUsage);
+              __FUNCTION__, this, mUsage0);
         return AMEDIA_IMGREADER_CANNOT_LOCK_IMAGE;
     }
 
@@ -194,7 +194,7 @@
     uint64_t producerUsage;
     uint64_t consumerUsage;
     android_hardware_HardwareBuffer_convertToGrallocUsageBits(
-            &producerUsage, &consumerUsage, mUsage, 0);
+            &producerUsage, &consumerUsage, mUsage0, mUsage1);
 
     status_t ret =
             lockImageFromBuffer(mBuffer, consumerUsage, mBuffer->mFence->dup(), lockedBuffer.get());
@@ -600,12 +600,31 @@
     return AMEDIA_OK;
 }
 
+media_status_t
+AImage::getHardwareBuffer(/*out*/AHardwareBuffer** buffer) const {
+    if (mBuffer == nullptr || mBuffer->mGraphicBuffer == nullptr) {
+        ALOGE("%s: AImage %p has no buffer.", __FUNCTION__, this);
+        return AMEDIA_ERROR_INVALID_OBJECT;
+    }
+
+    // TODO(jwcai) Someone from Android graphics team stating this should just be a static_cast.
+    *buffer = reinterpret_cast<AHardwareBuffer*>(mBuffer->mGraphicBuffer.get());
+    return AMEDIA_OK;
+}
+
 EXPORT
 void AImage_delete(AImage* image) {
     ALOGV("%s", __FUNCTION__);
+    AImage_deleteAsync(image, -1);
+    return;
+}
+
+EXPORT
+void AImage_deleteAsync(AImage* image, int releaseFenceFd) {
+    ALOGV("%s", __FUNCTION__);
     if (image != nullptr) {
         image->lockReader();
-        image->close();
+        image->close(releaseFenceFd);
         image->unlockReader();
         if (!image->isClosed()) {
             LOG_ALWAYS_FATAL("Image close failed!");
@@ -750,3 +769,15 @@
     }
     return image->getPlaneData(planeIdx, data, dataLength);
 }
+
+EXPORT
+media_status_t AImage_getHardwareBuffer(
+    const AImage* image, /*out*/AHardwareBuffer** buffer) {
+    ALOGV("%s", __FUNCTION__);
+
+    if (image == nullptr || buffer == nullptr) {
+        ALOGE("%s: bad argument. image %p buffer %p", __FUNCTION__, image, buffer);
+        return AMEDIA_ERROR_INVALID_PARAMETER;
+    }
+    return image->getHardwareBuffer(buffer);
+}
diff --git a/media/ndk/NdkImagePriv.h b/media/ndk/NdkImagePriv.h
index e01dcc7..1fcb495 100644
--- a/media/ndk/NdkImagePriv.h
+++ b/media/ndk/NdkImagePriv.h
@@ -32,12 +32,13 @@
 
 // TODO: this only supports ImageReader
 struct AImage {
-    AImage(AImageReader* reader, int32_t format, uint64_t usage,
+    AImage(AImageReader* reader, int32_t format, uint64_t usage0, uint64_t usage1,
            BufferItem* buffer, int64_t timestamp,
            int32_t width, int32_t height, int32_t numPlanes);
 
     // free all resources while keeping object alive. Caller must obtain reader lock
-    void close();
+    void close() { close(-1); }
+    void close(int releaseFenceFd);
 
     // Remove from object memory. Must be called after close
     void free();
@@ -61,6 +62,7 @@
     media_status_t getPlanePixelStride(int planeIdx, /*out*/int32_t* pixelStride) const;
     media_status_t getPlaneRowStride(int planeIdx, /*out*/int32_t* rowStride) const;
     media_status_t getPlaneData(int planeIdx,/*out*/uint8_t** data, /*out*/int* dataLength) const;
+    media_status_t getHardwareBuffer(/*out*/AHardwareBuffer** buffer) const;
 
   private:
     // AImage should be deleted through free() API.
@@ -73,7 +75,8 @@
     // When reader is close, AImage will only accept close API call
     wp<AImageReader>           mReader;
     const int32_t              mFormat;
-    const uint64_t             mUsage;  // AHARDWAREBUFFER_USAGE0* flags.
+    const uint64_t             mUsage0;  // AHARDWAREBUFFER_USAGE0* flags.
+    const uint64_t             mUsage1;  // AHARDWAREBUFFER_USAGE1* flags.
     BufferItem*                mBuffer;
     std::unique_ptr<CpuConsumer::LockedBuffer> mLockedBuffer;
     const int64_t              mTimestamp;
diff --git a/media/ndk/NdkImageReader.cpp b/media/ndk/NdkImageReader.cpp
index e580dae..c0aee90 100644
--- a/media/ndk/NdkImageReader.cpp
+++ b/media/ndk/NdkImageReader.cpp
@@ -38,9 +38,9 @@
     }
 }
 
-const int32_t AImageReader::kDefaultUsage = AHARDWAREBUFFER_USAGE0_CPU_READ_OFTEN;
 const char* AImageReader::kCallbackFpKey = "Callback";
 const char* AImageReader::kContextKey    = "Context";
+const char* AImageReader::kGraphicBufferKey = "GraphicBuffer";
 
 bool
 AImageReader::isSupportedFormat(int32_t format) {
@@ -117,6 +117,45 @@
     return AMEDIA_OK;
 }
 
+void
+AImageReader::BufferRemovedListener::onBufferFreed(const wp<GraphicBuffer>& graphicBuffer) {
+    Mutex::Autolock _l(mLock);
+    sp<AImageReader> reader = mReader.promote();
+    if (reader == nullptr) {
+        ALOGW("A frame is available after AImageReader closed!");
+        return; // reader has been closed
+    }
+    if (mListener.onBufferRemoved == nullptr) {
+        return; // No callback registered
+    }
+
+    sp<GraphicBuffer> gBuffer = graphicBuffer.promote();
+    if (gBuffer == nullptr) {
+        ALOGW("A buffer being freed has gone away!");
+        return; // buffer is already destroyed
+    }
+
+    sp<AMessage> msg = new AMessage(AImageReader::kWhatBufferRemoved, reader->mHandler);
+    msg->setPointer(
+        AImageReader::kCallbackFpKey, (void*) mListener.onBufferRemoved);
+    msg->setPointer(AImageReader::kContextKey, mListener.context);
+    msg->setObject(AImageReader::kGraphicBufferKey, gBuffer);
+    msg->post();
+}
+
+media_status_t
+AImageReader::BufferRemovedListener::setBufferRemovedListener(
+    AImageReader_BufferRemovedListener* listener) {
+    Mutex::Autolock _l(mLock);
+    if (listener == nullptr) {
+        mListener.context = nullptr;
+        mListener.onBufferRemoved = nullptr;
+    } else {
+        mListener = *listener;
+    }
+    return AMEDIA_OK;
+}
+
 media_status_t
 AImageReader::setImageListenerLocked(AImageReader_ImageListener* listener) {
     return mFrameListener->setImageListener(listener);
@@ -128,9 +167,50 @@
     return setImageListenerLocked(listener);
 }
 
+media_status_t
+AImageReader::setBufferRemovedListenerLocked(AImageReader_BufferRemovedListener* listener) {
+    return mBufferRemovedListener->setBufferRemovedListener(listener);
+}
+
+media_status_t
+AImageReader::setBufferRemovedListener(AImageReader_BufferRemovedListener* listener) {
+    Mutex::Autolock _l(mLock);
+    return setBufferRemovedListenerLocked(listener);
+}
+
 void AImageReader::CallbackHandler::onMessageReceived(
         const sp<AMessage> &msg) {
     switch (msg->what()) {
+        case kWhatBufferRemoved:
+        {
+            AImageReader_BufferRemovedCallback onBufferRemoved;
+            void* context;
+            bool found = msg->findPointer(kCallbackFpKey, (void**) &onBufferRemoved);
+            if (!found || onBufferRemoved == nullptr) {
+                ALOGE("%s: Cannot find onBufferRemoved callback fp!", __FUNCTION__);
+                return;
+            }
+            found = msg->findPointer(kContextKey, &context);
+            if (!found) {
+                ALOGE("%s: Cannot find callback context!", __FUNCTION__);
+                return;
+            }
+            sp<RefBase> bufferToFree;
+            found = msg->findObject(kGraphicBufferKey, &bufferToFree);
+            if (!found || bufferToFree == nullptr) {
+                ALOGE("%s: Cannot find the buffer to free!", __FUNCTION__);
+                return;
+            }
+
+            // TODO(jwcai) Someone from Android graphics team stating this should just be a
+            // static_cast.
+            AHardwareBuffer* outBuffer = reinterpret_cast<AHardwareBuffer*>(bufferToFree.get());
+
+            // At this point, bufferToFree holds the last reference to the GraphicBuffer owned by
+            // this AImageReader, and the reference will be gone once this function returns.
+            (*onBufferRemoved)(context, mReader, outBuffer);
+            break;
+        }
         case kWhatImageAvailable:
         {
             AImageReader_ImageCallback onImageAvailable;
@@ -157,15 +237,18 @@
 AImageReader::AImageReader(int32_t width,
                            int32_t height,
                            int32_t format,
-                           uint64_t usage,
+                           uint64_t usage0,
+                           uint64_t usage1,
                            int32_t maxImages)
     : mWidth(width),
       mHeight(height),
       mFormat(format),
-      mUsage(usage),
+      mUsage0(usage0),
+      mUsage1(usage1),
       mMaxImages(maxImages),
       mNumPlanes(getNumPlanesForFormat(format)),
-      mFrameListener(new FrameListener(this)) {}
+      mFrameListener(new FrameListener(this)),
+      mBufferRemovedListener(new BufferRemovedListener(this)) {}
 
 media_status_t
 AImageReader::init() {
@@ -176,18 +259,19 @@
     uint64_t producerUsage;
     uint64_t consumerUsage;
     android_hardware_HardwareBuffer_convertToGrallocUsageBits(
-            &producerUsage, &consumerUsage, mUsage, 0);
+            &producerUsage, &consumerUsage, mUsage0, mUsage1);
+    mHalUsage = consumerUsage;
 
     sp<IGraphicBufferProducer> gbProducer;
     sp<IGraphicBufferConsumer> gbConsumer;
     BufferQueue::createBufferQueue(&gbProducer, &gbConsumer);
 
-    String8 consumerName = String8::format(
-            "ImageReader-%dx%df%xu%" PRIu64 "m%d-%d-%d", mWidth, mHeight, mFormat, mUsage,
-            mMaxImages, getpid(), createProcessUniqueId());
+    String8 consumerName = String8::format("ImageReader-%dx%df%xu%" PRIu64 "u%" PRIu64 "m%d-%d-%d",
+            mWidth, mHeight, mFormat, mUsage0, mUsage1, mMaxImages, getpid(),
+            createProcessUniqueId());
 
     mBufferItemConsumer =
-            new BufferItemConsumer(gbConsumer, consumerUsage, mMaxImages, /*controlledByApp*/ true);
+            new BufferItemConsumer(gbConsumer, mHalUsage, mMaxImages, /*controlledByApp*/ true);
     if (mBufferItemConsumer == nullptr) {
         ALOGE("Failed to allocate BufferItemConsumer");
         return AMEDIA_ERROR_UNKNOWN;
@@ -196,6 +280,7 @@
     mProducer = gbProducer;
     mBufferItemConsumer->setName(consumerName);
     mBufferItemConsumer->setFrameAvailableListener(mFrameListener);
+    mBufferItemConsumer->setBufferFreedListener(mBufferRemovedListener);
 
     status_t res;
     res = mBufferItemConsumer->setDefaultBufferSize(mWidth, mHeight);
@@ -247,6 +332,9 @@
     AImageReader_ImageListener nullListener = {nullptr, nullptr};
     setImageListenerLocked(&nullListener);
 
+    AImageReader_BufferRemovedListener nullBufferRemovedListener = {nullptr, nullptr};
+    setBufferRemovedListenerLocked(&nullBufferRemovedListener);
+
     if (mCbLooper != nullptr) {
         mCbLooper->unregisterHandler(mHandler->id());
         mCbLooper->stop();
@@ -274,7 +362,7 @@
 }
 
 media_status_t
-AImageReader::acquireImageLocked(/*out*/AImage** image) {
+AImageReader::acquireImageLocked(/*out*/AImage** image, /*out*/int* acquireFenceFd) {
     *image = nullptr;
     BufferItem* buffer = getBufferItemLocked();
     if (buffer == nullptr) {
@@ -283,7 +371,10 @@
         return AMEDIA_IMGREADER_MAX_IMAGES_ACQUIRED;
     }
 
-    status_t res = mBufferItemConsumer->acquireBuffer(buffer, 0);
+    // When the output paramter fence is not NULL, we are acquiring the image asynchronously.
+    bool waitForFence = acquireFenceFd == nullptr;
+    status_t res = mBufferItemConsumer->acquireBuffer(buffer, 0, waitForFence);
+
     if (res != NO_ERROR) {
         returnBufferItemLocked(buffer);
         if (res != BufferQueue::NO_BUFFER_AVAILABLE) {
@@ -301,10 +392,12 @@
     const int bufferWidth = getBufferWidth(buffer);
     const int bufferHeight = getBufferHeight(buffer);
     const int bufferFmt = buffer->mGraphicBuffer->getPixelFormat();
+    const int bufferUsage = buffer->mGraphicBuffer->getUsage();
 
     const int readerWidth = mWidth;
     const int readerHeight = mHeight;
     const int readerFmt = mHalFormat;
+    const int readerUsage = mHalUsage;
 
     // Check if the producer buffer configurations match what AImageReader configured. Add some
     // extra checks for non-opaque formats.
@@ -324,6 +417,13 @@
                     __FUNCTION__, bufferWidth, bufferHeight, readerWidth, readerHeight);
         }
 
+        // Check if the buffer usage is a super set of reader's usage bits, aka all usage bits that
+        // ImageReader requested has been supported from the producer side.
+        ALOGD_IF((readerUsage | bufferUsage) != bufferUsage,
+                "%s: Producer buffer usage: %x, doesn't cover all usage bits AImageReader "
+                "configured: %x",
+                __FUNCTION__, bufferUsage, readerUsage);
+
         if (readerFmt != bufferFmt) {
             if (readerFmt == HAL_PIXEL_FORMAT_YCbCr_420_888 && isPossiblyYUV(bufferFmt)) {
                 // Special casing for when producer switches to a format compatible with flexible
@@ -345,13 +445,19 @@
     }
 
     if (mHalFormat == HAL_PIXEL_FORMAT_BLOB) {
-        *image = new AImage(this, mFormat, mUsage, buffer, buffer->mTimestamp,
-                            readerWidth, readerHeight, mNumPlanes);
+        *image = new AImage(this, mFormat, mUsage0, mUsage1, buffer, buffer->mTimestamp,
+                readerWidth, readerHeight, mNumPlanes);
     } else {
-        *image = new AImage(this, mFormat, mUsage, buffer, buffer->mTimestamp,
-                            bufferWidth, bufferHeight, mNumPlanes);
+        *image = new AImage(this, mFormat, mUsage0, mUsage1, buffer, buffer->mTimestamp,
+                bufferWidth, bufferHeight, mNumPlanes);
     }
     mAcquiredImages.push_back(*image);
+
+    // When the output paramter fence is not NULL, we are acquiring the image asynchronously.
+    if (acquireFenceFd != nullptr) {
+        *acquireFenceFd = buffer->mFence->dup();
+    }
+
     return AMEDIA_OK;
 }
 
@@ -373,7 +479,7 @@
 }
 
 void
-AImageReader::releaseImageLocked(AImage* image) {
+AImageReader::releaseImageLocked(AImage* image, int releaseFenceFd) {
     BufferItem* buffer = image->mBuffer;
     if (buffer == nullptr) {
         // This should not happen, but is not fatal
@@ -381,15 +487,17 @@
         return;
     }
 
-    int fenceFd = -1;
-    media_status_t ret = image->unlockImageIfLocked(&fenceFd);
+    int unlockFenceFd = -1;
+    media_status_t ret = image->unlockImageIfLocked(&unlockFenceFd);
     if (ret < 0) {
         ALOGW("%s: AImage %p is cannot be unlocked.", __FUNCTION__, image);
         return;
     }
 
-    sp<Fence> releaseFence = fenceFd > 0 ? new Fence(fenceFd) : Fence::NO_FENCE;
-    mBufferItemConsumer->releaseBuffer(*buffer, releaseFence);
+    sp<Fence> unlockFence = unlockFenceFd > 0 ? new Fence(unlockFenceFd) : Fence::NO_FENCE;
+    sp<Fence> releaseFence = releaseFenceFd > 0 ? new Fence(releaseFenceFd) : Fence::NO_FENCE;
+    sp<Fence> bufferFence = Fence::merge("AImageReader", unlockFence, releaseFence);
+    mBufferItemConsumer->releaseBuffer(*buffer, bufferFence);
     returnBufferItemLocked(buffer);
     image->mBuffer = nullptr;
 
@@ -433,13 +541,13 @@
 }
 
 media_status_t
-AImageReader::acquireNextImage(/*out*/AImage** image) {
+AImageReader::acquireNextImage(/*out*/AImage** image, /*out*/int* acquireFenceFd) {
     Mutex::Autolock _l(mLock);
-    return acquireImageLocked(image);
+    return acquireImageLocked(image, acquireFenceFd);
 }
 
 media_status_t
-AImageReader::acquireLatestImage(/*out*/AImage** image) {
+AImageReader::acquireLatestImage(/*out*/AImage** image, /*out*/int* acquireFenceFd) {
     if (image == nullptr) {
         return AMEDIA_ERROR_INVALID_PARAMETER;
     }
@@ -447,17 +555,26 @@
     *image = nullptr;
     AImage* prevImage = nullptr;
     AImage* nextImage = nullptr;
-    media_status_t ret = acquireImageLocked(&prevImage);
+    media_status_t ret = acquireImageLocked(&prevImage, acquireFenceFd);
     if (prevImage == nullptr) {
         return ret;
     }
     for (;;) {
-        ret = acquireImageLocked(&nextImage);
+        ret = acquireImageLocked(&nextImage, acquireFenceFd);
         if (nextImage == nullptr) {
             *image = prevImage;
             return AMEDIA_OK;
         }
-        prevImage->close();
+
+        if (acquireFenceFd == nullptr) {
+            // No need for release fence here since the prevImage is unused and acquireImageLocked
+            // has already waited for acquired fence to be signaled.
+            prevImage->close();
+        } else {
+            // Use the acquire fence as release fence, so that producer can wait before trying to
+            // refill the buffer.
+            prevImage->close(*acquireFenceFd);
+        }
         prevImage->free();
         prevImage = nextImage;
         nextImage = nullptr;
@@ -469,6 +586,15 @@
         int32_t width, int32_t height, int32_t format, int32_t maxImages,
         /*out*/AImageReader** reader) {
     ALOGV("%s", __FUNCTION__);
+    return AImageReader_newWithUsage(
+            width, height, format, AHARDWAREBUFFER_USAGE0_CPU_READ_OFTEN, 0, maxImages, reader);
+}
+
+EXPORT
+media_status_t AImageReader_newWithUsage(
+        int32_t width, int32_t height, int32_t format, uint64_t usage0, uint64_t usage1,
+        int32_t maxImages, /*out*/ AImageReader** reader) {
+    ALOGV("%s", __FUNCTION__);
 
     if (width < 1 || height < 1) {
         ALOGE("%s: image dimension must be positive: w:%d h:%d",
@@ -499,10 +625,8 @@
         return AMEDIA_ERROR_INVALID_PARAMETER;
     }
 
-    // Set consumer usage to AHARDWAREBUFFER_USAGE0_CPU_READ_OFTEN by default so that
-    // AImageReader_new behaves as if it's backed by CpuConsumer.
     AImageReader* tmpReader = new AImageReader(
-        width, height, format, AImageReader::kDefaultUsage, maxImages);
+        width, height, format, usage0, usage1, maxImages);
     if (tmpReader == nullptr) {
         ALOGE("%s: AImageReader allocation failed", __FUNCTION__);
         return AMEDIA_ERROR_UNKNOWN;
@@ -590,23 +714,37 @@
 EXPORT
 media_status_t AImageReader_acquireNextImage(AImageReader* reader, /*out*/AImage** image) {
     ALOGV("%s", __FUNCTION__);
-    if (reader == nullptr || image == nullptr) {
-        ALOGE("%s: invalid argument. reader %p, image %p",
-                __FUNCTION__, reader, image);
-        return AMEDIA_ERROR_INVALID_PARAMETER;
-    }
-    return reader->acquireNextImage(image);
+    return AImageReader_acquireNextImageAsync(reader, image, nullptr);
 }
 
 EXPORT
 media_status_t AImageReader_acquireLatestImage(AImageReader* reader, /*out*/AImage** image) {
     ALOGV("%s", __FUNCTION__);
+    return AImageReader_acquireLatestImageAsync(reader, image, nullptr);
+}
+
+EXPORT
+media_status_t AImageReader_acquireNextImageAsync(
+    AImageReader* reader, /*out*/AImage** image, /*out*/int* acquireFenceFd) {
+    ALOGV("%s", __FUNCTION__);
     if (reader == nullptr || image == nullptr) {
         ALOGE("%s: invalid argument. reader %p, image %p",
                 __FUNCTION__, reader, image);
         return AMEDIA_ERROR_INVALID_PARAMETER;
     }
-    return reader->acquireLatestImage(image);
+    return reader->acquireNextImage(image, acquireFenceFd);
+}
+
+EXPORT
+media_status_t AImageReader_acquireLatestImageAsync(
+    AImageReader* reader, /*out*/AImage** image, /*out*/int* acquireFenceFd) {
+    ALOGV("%s", __FUNCTION__);
+    if (reader == nullptr || image == nullptr) {
+        ALOGE("%s: invalid argument. reader %p, image %p",
+                __FUNCTION__, reader, image);
+        return AMEDIA_ERROR_INVALID_PARAMETER;
+    }
+    return reader->acquireLatestImage(image, acquireFenceFd);
 }
 
 EXPORT
@@ -621,3 +759,16 @@
     reader->setImageListener(listener);
     return AMEDIA_OK;
 }
+
+EXPORT
+media_status_t AImageReader_setBufferRemovedListener(
+    AImageReader* reader, AImageReader_BufferRemovedListener* listener) {
+    ALOGV("%s", __FUNCTION__);
+    if (reader == nullptr) {
+        ALOGE("%s: invalid argument! reader %p", __FUNCTION__, reader);
+        return AMEDIA_ERROR_INVALID_PARAMETER;
+    }
+
+    reader->setBufferRemovedListener(listener);
+    return AMEDIA_OK;
+}
diff --git a/media/ndk/NdkImageReaderPriv.h b/media/ndk/NdkImageReaderPriv.h
index 8becb1d..a233ec8 100644
--- a/media/ndk/NdkImageReaderPriv.h
+++ b/media/ndk/NdkImageReaderPriv.h
@@ -49,15 +49,14 @@
 
 struct AImageReader : public RefBase {
   public:
-    static const int32_t kDefaultUsage;
-
     static bool isSupportedFormat(int32_t format);
     static int getNumPlanesForFormat(int32_t format);
 
     AImageReader(int32_t width,
                  int32_t height,
                  int32_t format,
-                 uint64_t usage,
+                 uint64_t usage0,
+                 uint64_t usage1,
                  int32_t maxImages);
     ~AImageReader();
 
@@ -66,15 +65,15 @@
     media_status_t init();
 
     media_status_t setImageListener(AImageReader_ImageListener* listener);
+    media_status_t setBufferRemovedListener(AImageReader_BufferRemovedListener* listener);
 
-    media_status_t acquireNextImage(/*out*/AImage** image);
-    media_status_t acquireLatestImage(/*out*/AImage** image);
+    media_status_t acquireNextImage(/*out*/AImage** image, /*out*/int* fenceFd);
+    media_status_t acquireLatestImage(/*out*/AImage** image, /*out*/int* fenceFd);
 
     ANativeWindow* getWindow()    const { return mWindow.get(); };
     int32_t        getWidth()     const { return mWidth; };
     int32_t        getHeight()    const { return mHeight; };
     int32_t        getFormat()    const { return mFormat; };
-    uint64_t       getUsage()     const { return mUsage; };
     int32_t        getMaxImages() const { return mMaxImages; };
 
   private:
@@ -85,22 +84,25 @@
     void returnBufferItemLocked(BufferItem* buffer);
 
     // Called by AImageReader_acquireXXX to acquire a Buffer and setup AImage.
-    media_status_t acquireImageLocked(/*out*/AImage** image);
+    media_status_t acquireImageLocked(/*out*/AImage** image, /*out*/int* fenceFd);
 
     // Called by AImage to close image
-    void releaseImageLocked(AImage* image);
+    void releaseImageLocked(AImage* image, int releaseFenceFd);
 
     static int getBufferWidth(BufferItem* buffer);
     static int getBufferHeight(BufferItem* buffer);
 
     media_status_t setImageListenerLocked(AImageReader_ImageListener* listener);
+    media_status_t setBufferRemovedListenerLocked(AImageReader_BufferRemovedListener* listener);
 
     // definition of handler and message
     enum {
-        kWhatImageAvailable
+        kWhatBufferRemoved,
+        kWhatImageAvailable,
     };
     static const char* kCallbackFpKey;
     static const char* kContextKey;
+    static const char* kGraphicBufferKey;
     class CallbackHandler : public AHandler {
       public:
         CallbackHandler(AImageReader* reader) : mReader(reader) {}
@@ -115,7 +117,8 @@
     const int32_t mWidth;
     const int32_t mHeight;
     const int32_t mFormat;
-    const uint64_t mUsage;
+    const uint64_t mUsage0;  // AHARDWAREBUFFER_USAGE0* flags.
+    const uint64_t mUsage1;  // AHARDWAREBUFFER_USAGE1* flags.
     const int32_t mMaxImages;
 
     // TODO(jwcai) Seems completely unused in AImageReader class.
@@ -136,8 +139,24 @@
     };
     sp<FrameListener> mFrameListener;
 
+    struct BufferRemovedListener : public BufferItemConsumer::BufferFreedListener {
+      public:
+        explicit BufferRemovedListener(AImageReader* parent) : mReader(parent) {}
+
+        void onBufferFreed(const wp<GraphicBuffer>& graphicBuffer) override;
+
+        media_status_t setBufferRemovedListener(AImageReader_BufferRemovedListener* listener);
+
+       private:
+        AImageReader_BufferRemovedListener mListener = {nullptr, nullptr};
+        wp<AImageReader>           mReader;
+        Mutex                      mLock;
+    };
+    sp<BufferRemovedListener> mBufferRemovedListener;
+
     int mHalFormat;
     android_dataspace mHalDataSpace;
+    uint64_t mHalUsage;
 
     sp<IGraphicBufferProducer> mProducer;
     sp<Surface>                mSurface;
diff --git a/media/ndk/NdkMediaCodec.cpp b/media/ndk/NdkMediaCodec.cpp
index 22c90e2..6d02cf1 100644
--- a/media/ndk/NdkMediaCodec.cpp
+++ b/media/ndk/NdkMediaCodec.cpp
@@ -31,9 +31,11 @@
 #include <media/stagefright/foundation/ALooper.h>
 #include <media/stagefright/foundation/AMessage.h>
 
+#include <media/stagefright/PersistentSurface.h>
 #include <media/stagefright/MediaCodec.h>
 #include <media/stagefright/MediaErrors.h>
 #include <media/MediaCodecBuffer.h>
+#include <android/native_window.h>
 
 using namespace android;
 
@@ -54,6 +56,18 @@
     kWhatStopActivityNotifications,
 };
 
+struct AMediaCodecPersistentSurface : public Surface {
+    sp<PersistentSurface> mPersistentSurface;
+    AMediaCodecPersistentSurface(
+            const sp<IGraphicBufferProducer>& igbp,
+            const sp<PersistentSurface>& ps)
+            : Surface(igbp) {
+        mPersistentSurface = ps;
+    }
+    virtual ~AMediaCodecPersistentSurface() {
+        //mPersistentSurface ref will be let go off here
+    }
+};
 
 class CodecHandler: public AHandler {
 private:
@@ -377,6 +391,94 @@
     return translate_error(mData->mCodec->setSurface(surface));
 }
 
+EXPORT
+media_status_t AMediaCodec_createInputSurface(AMediaCodec *mData, ANativeWindow **surface) {
+    if (surface == NULL || mData == NULL) {
+        return AMEDIA_ERROR_INVALID_PARAMETER;
+    }
+    *surface = NULL;
+
+    sp<IGraphicBufferProducer> igbp = NULL;
+    status_t err = mData->mCodec->createInputSurface(&igbp);
+    if (err != NO_ERROR) {
+        return translate_error(err);
+    }
+
+    *surface = new Surface(igbp);
+    ANativeWindow_acquire(*surface);
+    return AMEDIA_OK;
+}
+
+EXPORT
+media_status_t AMediaCodec_createPersistentInputSurface(ANativeWindow **surface) {
+    if (surface == NULL) {
+        return AMEDIA_ERROR_INVALID_PARAMETER;
+    }
+    *surface = NULL;
+
+    sp<PersistentSurface> ps = MediaCodec::CreatePersistentInputSurface();
+    if (ps == NULL) {
+        return AMEDIA_ERROR_UNKNOWN;
+    }
+
+    sp<IGraphicBufferProducer> igbp = ps->getBufferProducer();
+    if (igbp == NULL) {
+        return AMEDIA_ERROR_UNKNOWN;
+    }
+
+    *surface = new AMediaCodecPersistentSurface(igbp, ps);
+    ANativeWindow_acquire(*surface);
+
+    return AMEDIA_OK;
+}
+
+EXPORT
+media_status_t AMediaCodec_setInputSurface(
+        AMediaCodec *mData, ANativeWindow *surface) {
+
+    if (surface == NULL || mData == NULL) {
+        return AMEDIA_ERROR_INVALID_PARAMETER;
+    }
+
+    AMediaCodecPersistentSurface *aMediaPersistentSurface =
+            static_cast<AMediaCodecPersistentSurface *>(surface);
+    if (aMediaPersistentSurface->mPersistentSurface == NULL) {
+        return AMEDIA_ERROR_INVALID_PARAMETER;
+    }
+
+    return translate_error(mData->mCodec->setInputSurface(
+            aMediaPersistentSurface->mPersistentSurface));
+}
+
+EXPORT
+media_status_t AMediaCodec_setParameters(
+        AMediaCodec *mData, const AMediaFormat* params) {
+    if (params == NULL || mData == NULL) {
+        return AMEDIA_ERROR_INVALID_PARAMETER;
+    }
+    sp<AMessage> nativeParams;
+    AMediaFormat_getFormat(params, &nativeParams);
+    ALOGV("setParameters: %s", nativeParams->debugString(0).c_str());
+
+    return translate_error(mData->mCodec->setParameters(nativeParams));
+}
+
+EXPORT
+media_status_t AMediaCodec_signalEndOfInputStream(AMediaCodec *mData) {
+
+    if (mData == NULL) {
+        return AMEDIA_ERROR_INVALID_PARAMETER;
+    }
+
+    status_t err = mData->mCodec->signalEndOfInputStream();
+    if (err == INVALID_OPERATION) {
+        return AMEDIA_ERROR_INVALID_OPERATION;
+    }
+
+    return translate_error(err);
+
+}
+
 //EXPORT
 media_status_t AMediaCodec_setNotificationCallback(AMediaCodec *mData, OnCodecEvent callback,
         void *userdata) {
diff --git a/media/ndk/NdkMediaMuxer.cpp b/media/ndk/NdkMediaMuxer.cpp
index b1b0362..bbf33cd 100644
--- a/media/ndk/NdkMediaMuxer.cpp
+++ b/media/ndk/NdkMediaMuxer.cpp
@@ -81,7 +81,8 @@
 ssize_t AMediaMuxer_addTrack(AMediaMuxer *muxer, const AMediaFormat *format) {
     sp<AMessage> msg;
     AMediaFormat_getFormat(format, &msg);
-    return translate_error(muxer->mImpl->addTrack(msg));
+    ssize_t ret = muxer->mImpl->addTrack(msg);
+    return (ret >= 0) ? ret : translate_error(ret);
 }
 
 EXPORT
diff --git a/media/ndk/libmediandk.map.txt b/media/ndk/libmediandk.map.txt
index 7db4d06..d7ad370 100644
--- a/media/ndk/libmediandk.map.txt
+++ b/media/ndk/libmediandk.map.txt
@@ -1,7 +1,9 @@
 LIBMEDIANDK {
   global:
     AImageReader_acquireLatestImage; # introduced=24
+    AImageReader_acquireLatestImageAsync; # introduced=26
     AImageReader_acquireNextImage; # introduced=24
+    AImageReader_acquireNextImageAsync; # introduced=26
     AImageReader_delete; # introduced=24
     AImageReader_getFormat; # introduced=24
     AImageReader_getHeight; # introduced=24
@@ -9,10 +11,14 @@
     AImageReader_getWidth; # introduced=24
     AImageReader_getWindow; # introduced=24
     AImageReader_new; # introduced=24
+    AImageReader_newWithUsage; # introduced=26
+    AImageReader_setBufferRemovedListener; # introduced=26
     AImageReader_setImageListener; # introduced=24
     AImage_delete; # introduced=24
+    AImage_deleteAsync; # introduced=26
     AImage_getCropRect; # introduced=24
     AImage_getFormat; # introduced=24
+    AImage_getHardwareBuffer; # introduced=26
     AImage_getHeight; # introduced=24
     AImage_getNumberOfPlanes; # introduced=24
     AImage_getPlaneData; # introduced=24
@@ -69,6 +75,11 @@
     AMediaCodec_releaseOutputBuffer;
     AMediaCodec_releaseOutputBufferAtTime;
     AMediaCodec_setOutputSurface; # introduced=24
+    AMediaCodec_setParameters; # introduced=26
+    AMediaCodec_setInputSurface; # introduced=26
+    AMediaCodec_createInputSurface; # introduced=26
+    AMediaCodec_signalEndOfInputStream; # introduced=26
+    AMediaCodec_createPersistentInputSurface; # introduced=26
     AMediaCodec_start;
     AMediaCodec_stop;
     AMediaCrypto_delete;
diff --git a/services/audioflinger/AudioFlinger.h b/services/audioflinger/AudioFlinger.h
index fca840b..75b4e4c 100644
--- a/services/audioflinger/AudioFlinger.h
+++ b/services/audioflinger/AudioFlinger.h
@@ -58,6 +58,8 @@
 #include <media/LinearMap.h>
 #include <media/VolumeShaper.h>
 
+#include <audio_utils/SimpleLog.h>
+
 #include "FastCapture.h"
 #include "FastMixer.h"
 #include <media/nbaio/NBAIO.h>
diff --git a/services/audioflinger/FastMixerDumpState.h b/services/audioflinger/FastMixerDumpState.h
index 301c5b1..8ef31d1 100644
--- a/services/audioflinger/FastMixerDumpState.h
+++ b/services/audioflinger/FastMixerDumpState.h
@@ -35,7 +35,7 @@
 // This packed representation is used to keep the information atomic.
 union FastTrackUnderruns {
     FastTrackUnderruns() { mAtomic = 0;
-            COMPILE_TIME_ASSERT_FUNCTION_SCOPE(sizeof(FastTrackUnderruns) == sizeof(uint32_t)); }
+            static_assert(sizeof(FastTrackUnderruns) == sizeof(uint32_t), "FastTrackUnderrun"); }
     FastTrackUnderruns(const FastTrackUnderruns& copyFrom) : mAtomic(copyFrom.mAtomic) { }
     FastTrackUnderruns& operator=(const FastTrackUnderruns& rhs)
             { if (this != &rhs) mAtomic = rhs.mAtomic; return *this; }
diff --git a/services/audioflinger/Threads.cpp b/services/audioflinger/Threads.cpp
index 54e07c0..3b1edec 100644
--- a/services/audioflinger/Threads.cpp
+++ b/services/audioflinger/Threads.cpp
@@ -699,17 +699,29 @@
             SetParameterConfigEventData *data = (SetParameterConfigEventData *)event->mData.get();
             if (checkForNewParameter_l(data->mKeyValuePairs, event->mStatus)) {
                 configChanged = true;
+                mLocalLog.log("CFG_EVENT_SET_PARAMETER: (%s) configuration changed",
+                        data->mKeyValuePairs.string());
             }
         } break;
         case CFG_EVENT_CREATE_AUDIO_PATCH: {
+            const audio_devices_t oldDevice = getDevice();
             CreateAudioPatchConfigEventData *data =
                                             (CreateAudioPatchConfigEventData *)event->mData.get();
             event->mStatus = createAudioPatch_l(&data->mPatch, &data->mHandle);
+            const audio_devices_t newDevice = getDevice();
+            mLocalLog.log("CFG_EVENT_CREATE_AUDIO_PATCH: old device %#x (%s) new device %#x (%s)",
+                    (unsigned)oldDevice, devicesToString(oldDevice).c_str(),
+                    (unsigned)newDevice, devicesToString(newDevice).c_str());
         } break;
         case CFG_EVENT_RELEASE_AUDIO_PATCH: {
+            const audio_devices_t oldDevice = getDevice();
             ReleaseAudioPatchConfigEventData *data =
                                             (ReleaseAudioPatchConfigEventData *)event->mData.get();
             event->mStatus = releaseAudioPatch_l(data->mHandle);
+            const audio_devices_t newDevice = getDevice();
+            mLocalLog.log("CFG_EVENT_RELEASE_AUDIO_PATCH: old device %#x (%s) new device %#x (%s)",
+                    (unsigned)oldDevice, devicesToString(oldDevice).c_str(),
+                    (unsigned)newDevice, devicesToString(newDevice).c_str());
         } break;
         default:
             ALOG_ASSERT(false, "processConfigEvents_l() unknown event type %d", event->mType);
@@ -826,6 +838,7 @@
     } else {
         dprintf(fd, " none\n");
     }
+    // Note: output device may be used by capture threads for effects such as AEC.
     dprintf(fd, "  Output device: %#x (%s)\n", mOutDevice, devicesToString(mOutDevice).c_str());
     dprintf(fd, "  Input device: %#x (%s)\n", mInDevice, devicesToString(mInDevice).c_str());
     dprintf(fd, "  Audio source: %d (%s)\n", mAudioSource, sourceToString(mAudioSource));
@@ -1694,7 +1707,8 @@
     dumpInternals(fd, args);
     dumpTracks(fd, args);
     dumpEffectChains(fd, args);
-    mLocalLog.dump(fd, args, "  " /* prefix */);
+    dprintf(fd, "  Local log:\n");
+    mLocalLog.dump(fd, "   " /* prefix */, 40 /* lines */);
 }
 
 void AudioFlinger::PlaybackThread::dumpTracks(int fd, const Vector<String16>& args __unused)
diff --git a/services/audioflinger/Threads.h b/services/audioflinger/Threads.h
index 422eeb5..8270e74 100644
--- a/services/audioflinger/Threads.h
+++ b/services/audioflinger/Threads.h
@@ -288,6 +288,9 @@
                 bool        standby() const { return mStandby; }
                 audio_devices_t outDevice() const { return mOutDevice; }
                 audio_devices_t inDevice() const { return mInDevice; }
+                audio_devices_t getDevice() const { return isOutput() ? mOutDevice : mInDevice; }
+
+    virtual     bool        isOutput() const = 0;
 
     virtual     sp<StreamHalInterface> stream() const = 0;
 
@@ -575,6 +578,8 @@
                     int                 mLastActiveTracksGeneration;
                     wp<T>               mLatestActiveTrack; // latest track added to ActiveTracks
                 };
+
+                SimpleLog mLocalLog;
 };
 
 class VolumeInterface {
@@ -760,6 +765,8 @@
                 // Return the asynchronous signal wait time.
     virtual     int64_t     computeWaitTimeNs_l() const { return INT64_MAX; }
 
+    virtual     bool        isOutput() const override { return true; }
+
 protected:
     // updated by readOutputParameters_l()
     size_t                          mNormalFrameCount;  // normal mixer and effects
@@ -971,80 +978,6 @@
     static const size_t     kFastMixerLogSize = 4 * 1024;
     sp<NBLog::Writer>       mFastMixerNBLogWriter;
 
-    // Do not call from a sched_fifo thread as it uses a system time call
-    // and obtains a local mutex.
-    class LocalLog {
-    public:
-        void log(const char *fmt, ...) {
-            va_list val;
-            va_start(val, fmt);
-
-            // format to buffer
-            char buffer[512];
-            int length = vsnprintf(buffer, sizeof(buffer), fmt, val);
-            if (length >= (signed)sizeof(buffer)) {
-                length = sizeof(buffer) - 1;
-            }
-
-            // strip out trailing newline
-            while (length > 0 && buffer[length - 1] == '\n') {
-                buffer[--length] = 0;
-            }
-
-            // store in circular array
-            AutoMutex _l(mLock);
-            mLog.emplace_back(
-                    std::make_pair(systemTime(SYSTEM_TIME_REALTIME), std::string(buffer)));
-            if (mLog.size() > kLogSize) {
-                mLog.pop_front();
-            }
-
-            va_end(val);
-        }
-
-        void dump(int fd, const Vector<String16>& args, const char *prefix = "") {
-            if (!AudioFlinger::dumpTryLock(mLock)) return; // a local lock, shouldn't happen
-            if (mLog.size() > 0) {
-                bool dumpAll = false;
-                for (const auto &arg : args) {
-                    if (arg == String16("--locallog")) {
-                        dumpAll = true;
-                    }
-                }
-
-                dprintf(fd, "Local Log:\n");
-                auto it = mLog.begin();
-                if (!dumpAll) {
-                    const size_t lines =
-                            (size_t)property_get_int32("audio.locallog.lines", kLogPrint);
-                    if (mLog.size() > lines) {
-                        it += (mLog.size() - lines);
-                    }
-                }
-                for (; it != mLog.end(); ++it) {
-                    const int64_t ns = it->first;
-                    const int ns_per_sec = 1000000000;
-                    const time_t sec = ns / ns_per_sec;
-                    struct tm tm;
-                    localtime_r(&sec, &tm);
-
-                    dprintf(fd, "%s%02d-%02d %02d:%02d:%02d.%03d %s\n",
-                            prefix,
-                            tm.tm_mon + 1, // localtime_r uses months in 0 - 11 range
-                            tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec,
-                            (int)(ns % ns_per_sec / 1000000),
-                            it->second.c_str());
-                }
-            }
-            mLock.unlock();
-        }
-
-    private:
-        Mutex mLock;
-        static const size_t kLogSize = 256; // full history
-        static const size_t kLogPrint = 32; // default print history
-        std::deque<std::pair<int64_t, std::string>> mLog;
-    } mLocalLog;
 
 public:
     virtual     bool        hasFastMixer() const = 0;
@@ -1446,6 +1379,7 @@
                             ThreadBase::acquireWakeLock_l();
                             mActiveTracks.updatePowerState(this, true /* force */);
                         }
+    virtual bool        isOutput() const override { return false; }
 
 private:
             // Enter standby if not already in standby, and set mStandby flag
@@ -1587,8 +1521,6 @@
     virtual     void        dumpInternals(int fd, const Vector<String16>& args);
                 void        dumpTracks(int fd, const Vector<String16>& args);
 
-    virtual     bool        isOutput() const = 0;
-
  protected:
 
                 audio_attributes_t      mAttr;
@@ -1636,7 +1568,7 @@
 
     virtual     void        dumpInternals(int fd, const Vector<String16>& args);
 
-    virtual     bool        isOutput() const { return true; }
+    virtual     bool        isOutput() const override { return true; }
 
 protected:
 
@@ -1660,7 +1592,7 @@
 
                 AudioStreamIn* clearInput();
 
-    virtual     bool           isOutput() const { return false; }
+    virtual     bool           isOutput() const override { return false; }
 
 protected:
 
diff --git a/services/audiopolicy/common/include/Volume.h b/services/audiopolicy/common/include/Volume.h
index d091179..1239fe0 100644
--- a/services/audiopolicy/common/include/Volume.h
+++ b/services/audiopolicy/common/include/Volume.h
@@ -124,16 +124,16 @@
         case AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET:
         case AUDIO_DEVICE_OUT_BLUETOOTH_A2DP:
         case AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES:
+        case AUDIO_DEVICE_OUT_USB_HEADSET:
             return DEVICE_CATEGORY_HEADSET;
         case AUDIO_DEVICE_OUT_LINE:
         case AUDIO_DEVICE_OUT_AUX_DIGITAL:
-            /*USB?  Remote submix?*/
+        case AUDIO_DEVICE_OUT_USB_DEVICE:
             return DEVICE_CATEGORY_EXT_MEDIA;
         case AUDIO_DEVICE_OUT_SPEAKER:
         case AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT:
         case AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER:
         case AUDIO_DEVICE_OUT_USB_ACCESSORY:
-        case AUDIO_DEVICE_OUT_USB_DEVICE:
         case AUDIO_DEVICE_OUT_REMOTE_SUBMIX:
         default:
             return DEVICE_CATEGORY_SPEAKER;
diff --git a/services/audiopolicy/enginedefault/src/Engine.cpp b/services/audiopolicy/enginedefault/src/Engine.cpp
index 895818c..096ffd1 100644
--- a/services/audiopolicy/enginedefault/src/Engine.cpp
+++ b/services/audiopolicy/enginedefault/src/Engine.cpp
@@ -356,6 +356,8 @@
             if (device) break;
             device = availableOutputDevicesType & AUDIO_DEVICE_OUT_LINE;
             if (device) break;
+            device = availableOutputDevicesType & AUDIO_DEVICE_OUT_USB_HEADSET;
+            if (device) break;
             device = availableOutputDevicesType & AUDIO_DEVICE_OUT_USB_DEVICE;
             if (device) break;
             if (!isInCall()) {
@@ -418,6 +420,25 @@
                 (mForceUse[AUDIO_POLICY_FORCE_FOR_SYSTEM] == AUDIO_POLICY_FORCE_SYSTEM_ENFORCED)) {
             device = availableOutputDevicesType & AUDIO_DEVICE_OUT_SPEAKER;
         }
+
+        // if SCO headset is connected and we are told to use it, play ringtone over
+        // speaker and BT SCO
+        if (((availableOutputDevicesType & AUDIO_DEVICE_OUT_ALL_SCO) != 0) &&
+                (mForceUse[AUDIO_POLICY_FORCE_FOR_COMMUNICATION] == AUDIO_POLICY_FORCE_BT_SCO)) {
+            uint32_t device2 = AUDIO_DEVICE_NONE;
+            device2 = availableOutputDevicesType & AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT;
+            if (device2 == AUDIO_DEVICE_NONE) {
+                device2 = availableOutputDevicesType & AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET;
+            }
+            if (device2 == AUDIO_DEVICE_NONE) {
+                device2 = availableOutputDevicesType & AUDIO_DEVICE_OUT_BLUETOOTH_SCO;
+            }
+
+            if (device2 != AUDIO_DEVICE_NONE) {
+                device |= device2;
+                break;
+            }
+        }
         // The second device used for sonification is the same as the device used by media strategy
         // FALL THROUGH
 
@@ -490,6 +511,9 @@
             device2 = availableOutputDevicesType & AUDIO_DEVICE_OUT_WIRED_HEADSET;
         }
         if (device2 == AUDIO_DEVICE_NONE) {
+            device2 = availableOutputDevicesType & AUDIO_DEVICE_OUT_USB_HEADSET;
+        }
+        if (device2 == AUDIO_DEVICE_NONE) {
             device2 = availableOutputDevicesType & AUDIO_DEVICE_OUT_USB_ACCESSORY;
         }
         if (device2 == AUDIO_DEVICE_NONE) {
@@ -572,6 +596,8 @@
         device = AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET;
     } else if (availableDeviceTypes & AUDIO_DEVICE_IN_WIRED_HEADSET) {
         device = AUDIO_DEVICE_IN_WIRED_HEADSET;
+    } else if (availableDeviceTypes & AUDIO_DEVICE_IN_USB_HEADSET) {
+        device = AUDIO_DEVICE_IN_USB_HEADSET;
     } else if (availableDeviceTypes & AUDIO_DEVICE_IN_USB_DEVICE) {
         device = AUDIO_DEVICE_IN_USB_DEVICE;
     } else if (availableDeviceTypes & AUDIO_DEVICE_IN_BUILTIN_MIC) {
@@ -602,6 +628,8 @@
         default:    // FORCE_NONE
             if (availableDeviceTypes & AUDIO_DEVICE_IN_WIRED_HEADSET) {
                 device = AUDIO_DEVICE_IN_WIRED_HEADSET;
+            } else if (availableDeviceTypes & AUDIO_DEVICE_IN_USB_HEADSET) {
+                device = AUDIO_DEVICE_IN_USB_HEADSET;
             } else if (availableDeviceTypes & AUDIO_DEVICE_IN_USB_DEVICE) {
                 device = AUDIO_DEVICE_IN_USB_DEVICE;
             } else if (availableDeviceTypes & AUDIO_DEVICE_IN_BUILTIN_MIC) {
@@ -627,6 +655,8 @@
             device = AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET;
         } else if (availableDeviceTypes & AUDIO_DEVICE_IN_WIRED_HEADSET) {
             device = AUDIO_DEVICE_IN_WIRED_HEADSET;
+        } else if (availableDeviceTypes & AUDIO_DEVICE_IN_USB_HEADSET) {
+            device = AUDIO_DEVICE_IN_USB_HEADSET;
         } else if (availableDeviceTypes & AUDIO_DEVICE_IN_USB_DEVICE) {
             device = AUDIO_DEVICE_IN_USB_DEVICE;
         } else if (availableDeviceTypes & AUDIO_DEVICE_IN_BUILTIN_MIC) {
diff --git a/services/audiopolicy/managerdefault/AudioPolicyManager.cpp b/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
index 7634664..ce6354d 100644
--- a/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
+++ b/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
@@ -5160,7 +5160,8 @@
     if ((device & (AUDIO_DEVICE_OUT_BLUETOOTH_A2DP |
             AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES |
             AUDIO_DEVICE_OUT_WIRED_HEADSET |
-            AUDIO_DEVICE_OUT_WIRED_HEADPHONE)) &&
+            AUDIO_DEVICE_OUT_WIRED_HEADPHONE |
+            AUDIO_DEVICE_OUT_USB_HEADSET)) &&
         ((stream_strategy == STRATEGY_SONIFICATION)
                 || (stream_strategy == STRATEGY_SONIFICATION_RESPECTFUL)
                 || (stream == AUDIO_STREAM_SYSTEM)
diff --git a/services/camera/libcameraservice/CameraFlashlight.cpp b/services/camera/libcameraservice/CameraFlashlight.cpp
index 07d88f6..0ff9314 100644
--- a/services/camera/libcameraservice/CameraFlashlight.cpp
+++ b/services/camera/libcameraservice/CameraFlashlight.cpp
@@ -64,7 +64,13 @@
     status_t res = OK;
 
     if (mCameraModule == nullptr) {
-        mFlashControl = new ProviderFlashControl(mProviderManager);
+        if (mProviderManager->supportSetTorchMode(cameraId.string())) {
+            mFlashControl = new ProviderFlashControl(mProviderManager);
+        } else {
+            // Only HAL1 devices do not support setTorchMode
+            mFlashControl =
+                    new CameraHardwareInterfaceFlashControl(mProviderManager, *mCallbacks);
+        }
     } else if (mCameraModule->getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_4) {
         mFlashControl = new ModuleFlashControl(*mCameraModule);
         if (mFlashControl == NULL) {
@@ -99,8 +105,7 @@
             mFlashControl = flashControl;
         } else {
             mFlashControl =
-                    new CameraHardwareInterfaceFlashControl(*mCameraModule,
-                                                            *mCallbacks);
+                    new CameraHardwareInterfaceFlashControl(mCameraModule, *mCallbacks);
         }
     }
 
@@ -164,20 +169,28 @@
     return res;
 }
 
+int CameraFlashlight::getNumberOfCameras() {
+    if (mCameraModule) {
+        return mCameraModule->getNumberOfCameras();
+    } else {
+        return mProviderManager->getStandardCameraCount();
+    }
+}
+
 status_t CameraFlashlight::findFlashUnits() {
     Mutex::Autolock l(mLock);
     status_t res;
 
     std::vector<String8> cameraIds;
+    int numberOfCameras = getNumberOfCameras();
+    cameraIds.resize(numberOfCameras);
     if (mCameraModule) {
-        cameraIds.resize(mCameraModule->getNumberOfCameras());
         for (size_t i = 0; i < cameraIds.size(); i++) {
             cameraIds[i] = String8::format("%zu", i);
         }
     } else {
         // No module, must be provider
-        std::vector<std::string> ids = mProviderManager->getCameraDeviceIds();
-        cameraIds.resize(ids.size());
+        std::vector<std::string> ids = mProviderManager->getStandardCameraDeviceIds();
         for (size_t i = 0; i < cameraIds.size(); i++) {
             cameraIds[i] = String8(ids[i].c_str());
         }
@@ -236,6 +249,17 @@
     return mHasFlashlightMap.valueAt(index);
 }
 
+bool CameraFlashlight::isBackwardCompatibleMode(const String8& cameraId) {
+    bool backwardCompatibleMode = false;
+    if (mCameraModule && mCameraModule->getModuleApiVersion() < CAMERA_MODULE_API_VERSION_2_4) {
+        backwardCompatibleMode = true;
+    } else if (mProviderManager != nullptr &&
+            !mProviderManager->supportSetTorchMode(cameraId.string())) {
+        backwardCompatibleMode = true;
+    }
+    return backwardCompatibleMode;
+}
+
 status_t CameraFlashlight::prepareDeviceOpen(const String8& cameraId) {
     ALOGV("%s: prepare for device open", __FUNCTION__);
 
@@ -246,14 +270,14 @@
         return NO_INIT;
     }
 
-    if (mCameraModule && mCameraModule->getModuleApiVersion() < CAMERA_MODULE_API_VERSION_2_4) {
+    if (isBackwardCompatibleMode(cameraId)) {
         // framework is going to open a camera device, all flash light control
         // should be closed for backward compatible support.
         mFlashControl.clear();
 
         if (mOpenedCameraIds.size() == 0) {
             // notify torch unavailable for all cameras with a flash
-            int numCameras = mCameraModule->getNumberOfCameras();
+            int numCameras = getNumberOfCameras();
             for (int i = 0; i < numCameras; i++) {
                 if (hasFlashUnitLocked(String8::format("%d", i))) {
                     mCallbacks->torch_mode_status_change(mCallbacks,
@@ -296,9 +320,9 @@
     if (mOpenedCameraIds.size() != 0)
         return OK;
 
-    if (mCameraModule && mCameraModule->getModuleApiVersion() < CAMERA_MODULE_API_VERSION_2_4) {
+    if (isBackwardCompatibleMode(cameraId)) {
         // notify torch available for all cameras with a flash
-        int numCameras = mCameraModule->getNumberOfCameras();
+        int numCameras = getNumberOfCameras();
         for (int i = 0; i < numCameras; i++) {
             if (hasFlashUnitLocked(String8::format("%d", i))) {
                 mCallbacks->torch_mode_status_change(mCallbacks,
@@ -692,12 +716,21 @@
 // Flash control for camera module <= v2.3 and camera HAL v1
 /////////////////////////////////////////////////////////////////////
 CameraHardwareInterfaceFlashControl::CameraHardwareInterfaceFlashControl(
-        CameraModule& cameraModule,
+        CameraModule* cameraModule,
         const camera_module_callbacks_t& callbacks) :
-        mCameraModule(&cameraModule),
+        mCameraModule(cameraModule),
+        mProviderManager(nullptr),
         mCallbacks(&callbacks),
         mTorchEnabled(false) {
+}
 
+CameraHardwareInterfaceFlashControl::CameraHardwareInterfaceFlashControl(
+        sp<CameraProviderManager> manager,
+        const camera_module_callbacks_t& callbacks) :
+        mCameraModule(nullptr),
+        mProviderManager(manager),
+        mCallbacks(&callbacks),
+        mTorchEnabled(false) {
 }
 
 CameraHardwareInterfaceFlashControl::~CameraHardwareInterfaceFlashControl() {
@@ -898,7 +931,12 @@
     sp<CameraHardwareInterface> device =
             new CameraHardwareInterface(cameraId.string());
 
-    status_t res = device->initialize(mCameraModule);
+    status_t res;
+    if (mCameraModule != nullptr) {
+        res = device->initialize(mCameraModule);
+    } else {
+        res = device->initialize(mProviderManager);
+    }
     if (res) {
         ALOGE("%s: initializing camera %s failed", __FUNCTION__,
                 cameraId.string());
diff --git a/services/camera/libcameraservice/CameraFlashlight.h b/services/camera/libcameraservice/CameraFlashlight.h
index b7c7690..98f269a 100644
--- a/services/camera/libcameraservice/CameraFlashlight.h
+++ b/services/camera/libcameraservice/CameraFlashlight.h
@@ -92,6 +92,12 @@
         // mLock should be locked.
         bool hasFlashUnitLocked(const String8& cameraId);
 
+        // Check if flash control is in backward compatible mode (simulated torch API by
+        // opening cameras)
+        bool isBackwardCompatibleMode(const String8& cameraId);
+
+        int getNumberOfCameras();
+
         sp<FlashControlBase> mFlashControl;
 
         CameraModule *mCameraModule;
@@ -202,7 +208,11 @@
  */
 class CameraHardwareInterfaceFlashControl : public FlashControlBase {
     public:
-        CameraHardwareInterfaceFlashControl(CameraModule& cameraModule,
+        CameraHardwareInterfaceFlashControl(
+                CameraModule* cameraModule,
+                const camera_module_callbacks_t& callbacks);
+        CameraHardwareInterfaceFlashControl(
+                sp<CameraProviderManager> manager,
                 const camera_module_callbacks_t& callbacks);
         virtual ~CameraHardwareInterfaceFlashControl();
 
@@ -235,6 +245,7 @@
         status_t hasFlashUnitLocked(const String8& cameraId, bool *hasFlash, bool keepDeviceOpen);
 
         CameraModule *mCameraModule;
+        sp<CameraProviderManager> mProviderManager;
         const camera_module_callbacks_t *mCallbacks;
         sp<CameraHardwareInterface> mDevice;
         String8 mCameraId;
diff --git a/services/camera/libcameraservice/api2/CameraDeviceClient.cpp b/services/camera/libcameraservice/api2/CameraDeviceClient.cpp
index 4428f75..a77a90b7 100644
--- a/services/camera/libcameraservice/api2/CameraDeviceClient.cpp
+++ b/services/camera/libcameraservice/api2/CameraDeviceClient.cpp
@@ -867,23 +867,22 @@
         ALOGE("%s: %s", __FUNCTION__, msg.string());
         return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
     }
-    if (dataSpace != streamInfo.dataSpace) {
-        String8 msg = String8::format("Camera %s:Surface dataSpace doesn't match: %d vs %d",
-                 mCameraIdStr.string(), dataSpace, streamInfo.dataSpace);
-        ALOGE("%s: %s", __FUNCTION__, msg.string());
-        return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
-    }
-    //At the native side, there isn't a way to check whether 2 surfaces come from the same
-    //surface class type. Use usage flag to approximate the comparison. Treat
-    //different preview surface usage flags as the same.
-    int32_t previewUsageMask =
-            GraphicBuffer::USAGE_HW_TEXTURE | GraphicBuffer::USAGE_HW_COMPOSER;
-    if ((consumerUsage & ~previewUsageMask) != (streamInfo.consumerUsage & ~previewUsageMask)) {
-        String8 msg = String8::format(
-                "Camera %s:Surface usage flag doesn't match 0x%x vs 0x%x",
-                mCameraIdStr.string(), consumerUsage, streamInfo.consumerUsage);
-        ALOGE("%s: %s", __FUNCTION__, msg.string());
-        return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
+    if (format != HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) {
+        if (dataSpace != streamInfo.dataSpace) {
+            String8 msg = String8::format("Camera %s:Surface dataSpace doesn't match: %d vs %d",
+                    mCameraIdStr.string(), dataSpace, streamInfo.dataSpace);
+            ALOGE("%s: %s", __FUNCTION__, msg.string());
+            return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
+        }
+        //At the native side, there isn't a way to check whether 2 surfaces come from the same
+        //surface class type. Use usage flag to approximate the comparison.
+        if (consumerUsage != streamInfo.consumerUsage) {
+            String8 msg = String8::format(
+                    "Camera %s:Surface usage flag doesn't match 0x%x vs 0x%x",
+                    mCameraIdStr.string(), consumerUsage, streamInfo.consumerUsage);
+            ALOGE("%s: %s", __FUNCTION__, msg.string());
+            return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
+        }
     }
     return binder::Status::ok();
 }
diff --git a/services/camera/libcameraservice/common/CameraProviderManager.cpp b/services/camera/libcameraservice/common/CameraProviderManager.cpp
index f8b2908..bbeeca6 100644
--- a/services/camera/libcameraservice/common/CameraProviderManager.cpp
+++ b/services/camera/libcameraservice/common/CameraProviderManager.cpp
@@ -75,7 +75,7 @@
     std::lock_guard<std::mutex> lock(mInterfaceMutex);
     int count = 0;
     for (auto& provider : mProviders) {
-        count += provider->mDevices.size();
+        count += provider->mUniqueDeviceCount;
     }
     return count;
 }
@@ -85,7 +85,7 @@
     int count = 0;
     for (auto& provider : mProviders) {
         if (kStandardProviderTypes.find(provider->getType()) != std::string::npos) {
-            count += provider->mDevices.size();
+            count += provider->mUniqueDeviceCount;
         }
     }
     return count;
@@ -95,8 +95,21 @@
     std::lock_guard<std::mutex> lock(mInterfaceMutex);
     std::vector<std::string> deviceIds;
     for (auto& provider : mProviders) {
-        for (auto& deviceInfo : provider->mDevices) {
-            deviceIds.push_back(deviceInfo->mId);
+        for (auto& id : provider->mUniqueCameraIds) {
+            deviceIds.push_back(id);
+        }
+    }
+    return deviceIds;
+}
+
+std::vector<std::string> CameraProviderManager::getStandardCameraDeviceIds() const {
+    std::lock_guard<std::mutex> lock(mInterfaceMutex);
+    std::vector<std::string> deviceIds;
+    for (auto& provider : mProviders) {
+        if (kStandardProviderTypes.find(provider->getType()) != std::string::npos) {
+            for (auto& id : provider->mUniqueCameraIds) {
+                deviceIds.push_back(id);
+            }
         }
     }
     return deviceIds;
@@ -181,6 +194,23 @@
     return OK;
 }
 
+bool CameraProviderManager::supportSetTorchMode(const std::string &id) {
+    std::lock_guard<std::mutex> lock(mInterfaceMutex);
+    bool support = false;
+    for (auto& provider : mProviders) {
+        auto deviceInfo = findDeviceInfoLocked(id);
+        if (deviceInfo != nullptr) {
+            provider->mInterface->isSetTorchModeSupported(
+                [&support](auto status, bool supported) {
+                    if (status == Status::OK) {
+                        support = supported;
+                    }
+                });
+        }
+    }
+    return support;
+}
+
 status_t CameraProviderManager::setTorchMode(const std::string &id, bool enabled) {
     std::lock_guard<std::mutex> lock(mInterfaceMutex);
 
@@ -471,6 +501,11 @@
         }
     }
 
+    for (auto& device : mDevices) {
+        mUniqueCameraIds.insert(device->mId);
+    }
+    mUniqueDeviceCount = mUniqueCameraIds.size();
+
     ALOGI("Camera provider %s ready with %zu camera devices",
             mProviderName.c_str(), mDevices.size());
 
diff --git a/services/camera/libcameraservice/common/CameraProviderManager.h b/services/camera/libcameraservice/common/CameraProviderManager.h
index b1da831..a388db5 100644
--- a/services/camera/libcameraservice/common/CameraProviderManager.h
+++ b/services/camera/libcameraservice/common/CameraProviderManager.h
@@ -18,6 +18,7 @@
 #define ANDROID_SERVERS_CAMERA_CAMERAPROVIDER_H
 
 #include <vector>
+#include <set>
 #include <string>
 #include <mutex>
 
@@ -133,6 +134,8 @@
 
     std::vector<std::string> getCameraDeviceIds() const;
 
+    std::vector<std::string> getStandardCameraDeviceIds() const;
+
     /**
      * Return true if a device with a given ID and major version exists
      */
@@ -170,8 +173,14 @@
             hardware::hidl_version *v);
 
     /**
+     * Check if a given camera device support setTorchMode API.
+     */
+    bool supportSetTorchMode(const std::string &id);
+
+    /**
      * Turn on or off the flashlight on a given camera device.
-     * May fail if the device is in active use, or if the device doesn't exist, etc.
+     * May fail if the device does not support this API, is in active use, or if the device
+     * doesn't exist, etc.
      */
     status_t setTorchMode(const std::string &id, bool enabled);
 
@@ -292,6 +301,8 @@
             static status_t setTorchMode(InterfaceT& interface, bool enabled);
         };
         std::vector<std::unique_ptr<DeviceInfo>> mDevices;
+        std::set<std::string> mUniqueCameraIds;
+        int mUniqueDeviceCount;
 
         // HALv1-specific camera fields, including the actual device interface
         struct DeviceInfo1 : public DeviceInfo {
diff --git a/services/camera/libcameraservice/device3/Camera3Device.cpp b/services/camera/libcameraservice/device3/Camera3Device.cpp
index 60c716f..1de2edc 100644
--- a/services/camera/libcameraservice/device3/Camera3Device.cpp
+++ b/services/camera/libcameraservice/device3/Camera3Device.cpp
@@ -933,8 +933,18 @@
     return res;
 }
 
+
 hardware::Return<void> Camera3Device::processCaptureResult(
-        const device::V3_2::CaptureResult& result) {
+        const hardware::hidl_vec<
+                hardware::camera::device::V3_2::CaptureResult>& results) {
+    for (const auto& result : results) {
+        processOneCaptureResult(result);
+    }
+    return hardware::Void();
+}
+
+void Camera3Device::processOneCaptureResult(
+        const hardware::camera::device::V3_2::CaptureResult& result) {
     camera3_capture_result r;
     status_t res;
     r.frame_number = result.frameNumber;
@@ -944,7 +954,7 @@
         if ((res = validate_camera_metadata_structure(r.result, &expected_metadata_size)) != OK) {
             ALOGE("%s: Frame %d: Invalid camera metadata received by camera service from HAL: %s (%d)",
                     __FUNCTION__, result.frameNumber, strerror(-res), res);
-            return hardware::Void();
+            return;
         }
     } else {
         r.result = nullptr;
@@ -957,10 +967,10 @@
         const StreamBuffer &bSrc = result.outputBuffers[i];
 
         ssize_t idx = mOutputStreams.indexOfKey(bSrc.streamId);
-        if (idx == -1) {
+        if (idx == NAME_NOT_FOUND) {
             ALOGE("%s: Frame %d: Buffer %zu: Invalid output stream id %d",
                     __FUNCTION__, result.frameNumber, i, bSrc.streamId);
-            return hardware::Void();
+            return;
         }
         bDst.stream = mOutputStreams.valueAt(idx)->asHalStream();
 
@@ -969,7 +979,7 @@
         if (res != OK) {
             ALOGE("%s: Frame %d: Buffer %zu: No in-flight buffer for stream %d",
                     __FUNCTION__, result.frameNumber, i, bSrc.streamId);
-            return hardware::Void();
+            return;
         }
         bDst.buffer = buffer;
         bDst.status = mapHidlBufferStatus(bSrc.status);
@@ -981,7 +991,7 @@
         } else {
             ALOGE("%s: Frame %d: Invalid release fence for buffer %zu, fd count is %d, not 1",
                     __FUNCTION__, result.frameNumber, i, bSrc.releaseFence->numFds);
-            return hardware::Void();
+            return;
         }
     }
     r.num_output_buffers = outputBuffers.size();
@@ -994,7 +1004,7 @@
         if (mInputStream->getId() != result.inputBuffer.streamId) {
             ALOGE("%s: Frame %d: Invalid input stream id %d", __FUNCTION__,
                     result.frameNumber, result.inputBuffer.streamId);
-            return hardware::Void();
+            return;
         }
         inputBuffer.stream = mInputStream->asHalStream();
         buffer_handle_t *buffer;
@@ -1003,7 +1013,7 @@
         if (res != OK) {
             ALOGE("%s: Frame %d: Input buffer: No in-flight buffer for stream %d",
                     __FUNCTION__, result.frameNumber, result.inputBuffer.streamId);
-            return hardware::Void();
+            return;
         }
         inputBuffer.buffer = buffer;
         inputBuffer.status = mapHidlBufferStatus(result.inputBuffer.status);
@@ -1015,7 +1025,7 @@
         } else {
             ALOGE("%s: Frame %d: Invalid release fence for input buffer, fd count is %d, not 1",
                     __FUNCTION__, result.frameNumber, result.inputBuffer.releaseFence->numFds);
-            return hardware::Void();
+            return;
         }
         r.input_buffer = &inputBuffer;
     }
@@ -1023,12 +1033,19 @@
     r.partial_result = result.partialResult;
 
     processCaptureResult(&r);
-
-    return hardware::Void();
 }
 
 hardware::Return<void> Camera3Device::notify(
-        const NotifyMsg& msg) {
+        const hardware::hidl_vec<hardware::camera::device::V3_2::NotifyMsg>& msgs) {
+    for (const auto& msg : msgs) {
+        notify(msg);
+    }
+    return hardware::Void();
+}
+
+void Camera3Device::notify(
+        const hardware::camera::device::V3_2::NotifyMsg& msg) {
+
     camera3_notify_msg m;
     switch (msg.type) {
         case MsgType::ERROR:
@@ -1036,10 +1053,10 @@
             m.message.error.frame_number = msg.msg.error.frameNumber;
             if (msg.msg.error.errorStreamId >= 0) {
                 ssize_t idx = mOutputStreams.indexOfKey(msg.msg.error.errorStreamId);
-                if (idx == -1) {
+                if (idx == NAME_NOT_FOUND) {
                     ALOGE("%s: Frame %d: Invalid error stream id %d",
                             __FUNCTION__, m.message.error.frame_number, msg.msg.error.errorStreamId);
-                    return hardware::Void();
+                    return;
                 }
                 m.message.error.error_stream = mOutputStreams.valueAt(idx)->asHalStream();
             } else {
@@ -1067,8 +1084,6 @@
             break;
     }
     notify(&m);
-
-    return hardware::Void();
 }
 
 status_t Camera3Device::captureList(const List<const CameraMetadata> &requests,
@@ -2452,13 +2467,14 @@
 
 status_t Camera3Device::registerInFlight(uint32_t frameNumber,
         int32_t numBuffers, CaptureResultExtras resultExtras, bool hasInput,
-        const AeTriggerCancelOverride_t &aeTriggerCancelOverride) {
+        const AeTriggerCancelOverride_t &aeTriggerCancelOverride,
+        bool hasAppCallback) {
     ATRACE_CALL();
     Mutex::Autolock l(mInFlightLock);
 
     ssize_t res;
     res = mInFlightMap.add(frameNumber, InFlightRequest(numBuffers, resultExtras, hasInput,
-            aeTriggerCancelOverride));
+            aeTriggerCancelOverride, hasAppCallback));
     if (res < 0) return res;
 
     if (mInFlightMap.size() == 1) {
@@ -2512,8 +2528,9 @@
             (request.haveResultMetadata && shutterTimestamp != 0))) {
         ATRACE_ASYNC_END("frame capture", frameNumber);
 
-        // Sanity check - if sensor timestamp matches shutter timestamp
-        if (request.requestStatus == OK &&
+        // Sanity check - if sensor timestamp matches shutter timestamp in the
+        // case of request having callback.
+        if (request.hasCallback && request.requestStatus == OK &&
                 sensorTimestamp != shutterTimestamp) {
             SET_ERR("sensor timestamp (%" PRId64
                 ") for frame %d doesn't match shutter timestamp (%" PRId64 ")",
@@ -2702,10 +2719,10 @@
         InFlightRequest &request = mInFlightMap.editValueAt(idx);
         ALOGVV("%s: got InFlightRequest requestId = %" PRId32
                 ", frameNumber = %" PRId64 ", burstId = %" PRId32
-                ", partialResultCount = %d",
+                ", partialResultCount = %d, hasCallback = %d",
                 __FUNCTION__, request.resultExtras.requestId,
                 request.resultExtras.frameNumber, request.resultExtras.burstId,
-                result->partial_result);
+                result->partial_result, request.hasCallback);
         // Always update the partial count to the latest one if it's not 0
         // (buffers only). When framework aggregates adjacent partial results
         // into one, the latest partial count will be used.
@@ -2743,7 +2760,7 @@
                 }
             }
 
-            if (isPartialResult) {
+            if (isPartialResult && request.hasCallback) {
                 // Send partial capture result
                 sendPartialCaptureResult(result->result, request.resultExtras, frameNumber,
                         request.aeTriggerCancelOverride);
@@ -2807,7 +2824,7 @@
             if (shutterTimestamp == 0) {
                 request.pendingMetadata = result->result;
                 request.collectedPartialResult = collectedPartialResult;
-            } else {
+            } else if (request.hasCallback) {
                 CameraMetadata metadata;
                 metadata = result->result;
                 sendCaptureResult(metadata, request.resultExtras,
@@ -2973,20 +2990,20 @@
                 }
             }
 
-            ALOGVV("Camera %s: %s: Shutter fired for frame %d (id %d) at %" PRId64,
+            r.shutterTimestamp = msg.timestamp;
+            if (r.hasCallback) {
+                ALOGVV("Camera %s: %s: Shutter fired for frame %d (id %d) at %" PRId64,
                     mId.string(), __FUNCTION__,
                     msg.frame_number, r.resultExtras.requestId, msg.timestamp);
-            // Call listener, if any
-            if (listener != NULL) {
-                listener->notifyShutter(r.resultExtras, msg.timestamp);
+                // Call listener, if any
+                if (listener != NULL) {
+                    listener->notifyShutter(r.resultExtras, msg.timestamp);
+                }
+                // send pending result and buffers
+                sendCaptureResult(r.pendingMetadata, r.resultExtras,
+                    r.collectedPartialResult, msg.frame_number,
+                    r.hasInputBuffer, r.aeTriggerCancelOverride);
             }
-
-            r.shutterTimestamp = msg.timestamp;
-
-            // send pending result and buffers
-            sendCaptureResult(r.pendingMetadata, r.resultExtras,
-                r.collectedPartialResult, msg.frame_number,
-                r.hasInputBuffer, r.aeTriggerCancelOverride);
             returnOutputBuffers(r.pendingOutputBuffers.array(),
                 r.pendingOutputBuffers.size(), r.shutterTimestamp);
             r.pendingOutputBuffers.clear();
@@ -3034,7 +3051,8 @@
         mHal3Device(nullptr) {}
 
 Camera3Device::HalInterface::HalInterface(const HalInterface& other) :
-        mHal3Device(other.mHal3Device), mHidlSession(other.mHidlSession) {}
+        mHal3Device(other.mHal3Device),
+        mHidlSession(other.mHidlSession) {}
 
 bool Camera3Device::HalInterface::valid() {
     return (mHal3Device != nullptr) || (mHidlSession != nullptr);
@@ -3045,6 +3063,10 @@
     mHidlSession.clear();
 }
 
+bool Camera3Device::HalInterface::supportBatchRequest() {
+    return mHidlSession != nullptr;
+}
+
 status_t Camera3Device::HalInterface::constructDefaultRequestSettings(
         camera3_request_template_t templateId,
         /*out*/ camera_metadata_t **requestTemplate) {
@@ -3249,6 +3271,114 @@
     return res;
 }
 
+void Camera3Device::HalInterface::wrapAsHidlRequest(camera3_capture_request_t* request,
+        /*out*/device::V3_2::CaptureRequest* captureRequest,
+        /*out*/std::vector<native_handle_t*>* handlesCreated) {
+
+    if (captureRequest == nullptr || handlesCreated == nullptr) {
+        ALOGE("%s: captureRequest (%p) and handlesCreated (%p) must not be null",
+                __FUNCTION__, captureRequest, handlesCreated);
+        return;
+    }
+
+    captureRequest->frameNumber = request->frame_number;
+    // A null request settings maps to a size-0 CameraMetadata
+    if (request->settings != nullptr) {
+        captureRequest->settings.setToExternal(
+                reinterpret_cast<uint8_t*>(const_cast<camera_metadata_t*>(request->settings)),
+                get_camera_metadata_size(request->settings));
+    }
+
+    {
+        std::lock_guard<std::mutex> lock(mInflightLock);
+        if (request->input_buffer != nullptr) {
+            int32_t streamId = Camera3Stream::cast(request->input_buffer->stream)->getId();
+            buffer_handle_t buf = *(request->input_buffer->buffer);
+            auto pair = getBufferId(buf, streamId);
+            bool isNewBuffer = pair.first;
+            uint64_t bufferId = pair.second;
+            captureRequest->inputBuffer.streamId = streamId;
+            captureRequest->inputBuffer.bufferId = bufferId;
+            captureRequest->inputBuffer.buffer = (isNewBuffer) ? buf : nullptr;
+            captureRequest->inputBuffer.status = BufferStatus::OK;
+            native_handle_t *acquireFence = nullptr;
+            if (request->input_buffer->acquire_fence != -1) {
+                acquireFence = native_handle_create(1,0);
+                acquireFence->data[0] = request->input_buffer->acquire_fence;
+                handlesCreated->push_back(acquireFence);
+            }
+            captureRequest->inputBuffer.acquireFence = acquireFence;
+            captureRequest->inputBuffer.releaseFence = nullptr;
+
+            pushInflightBufferLocked(captureRequest->frameNumber, streamId,
+                    request->input_buffer->buffer,
+                    request->input_buffer->acquire_fence);
+        } else {
+            captureRequest->inputBuffer.streamId = -1;
+            captureRequest->inputBuffer.bufferId = BUFFER_ID_NO_BUFFER;
+        }
+
+        captureRequest->outputBuffers.resize(request->num_output_buffers);
+        for (size_t i = 0; i < request->num_output_buffers; i++) {
+            const camera3_stream_buffer_t *src = request->output_buffers + i;
+            StreamBuffer &dst = captureRequest->outputBuffers[i];
+            int32_t streamId = Camera3Stream::cast(src->stream)->getId();
+            buffer_handle_t buf = *(src->buffer);
+            auto pair = getBufferId(buf, streamId);
+            bool isNewBuffer = pair.first;
+            dst.streamId = streamId;
+            dst.bufferId = pair.second;
+            dst.buffer = isNewBuffer ? buf : nullptr;
+            dst.status = BufferStatus::OK;
+            native_handle_t *acquireFence = nullptr;
+            if (src->acquire_fence != -1) {
+                acquireFence = native_handle_create(1,0);
+                acquireFence->data[0] = src->acquire_fence;
+                handlesCreated->push_back(acquireFence);
+            }
+            dst.acquireFence = acquireFence;
+            dst.releaseFence = nullptr;
+
+            pushInflightBufferLocked(captureRequest->frameNumber, streamId,
+                    src->buffer, src->acquire_fence);
+        }
+    }
+}
+
+status_t Camera3Device::HalInterface::processBatchCaptureRequests(
+        std::vector<camera3_capture_request_t*>& requests,/*out*/uint32_t* numRequestProcessed) {
+    ATRACE_NAME("CameraHal::processBatchCaptureRequests");
+    if (!valid()) return INVALID_OPERATION;
+
+    hardware::hidl_vec<device::V3_2::CaptureRequest> captureRequests;
+    size_t batchSize = requests.size();
+    captureRequests.resize(batchSize);
+    std::vector<native_handle_t*> handlesCreated;
+
+    for (size_t i = 0; i < batchSize; i++) {
+        wrapAsHidlRequest(requests[i], /*out*/&captureRequests[i], /*out*/&handlesCreated);
+    }
+
+    common::V1_0::Status status = common::V1_0::Status::INTERNAL_ERROR;
+    *numRequestProcessed = 0;
+    mHidlSession->processCaptureRequest(captureRequests,
+            [&status, &numRequestProcessed] (auto s, uint32_t n) {
+                status = s;
+                *numRequestProcessed = n;
+            });
+
+    if (status == common::V1_0::Status::OK && *numRequestProcessed != batchSize) {
+        ALOGE("%s: processCaptureRequest returns OK but processed %d/%zu requests",
+                __FUNCTION__, *numRequestProcessed, batchSize);
+        status = common::V1_0::Status::INTERNAL_ERROR;
+    }
+
+    for (auto& handle : handlesCreated) {
+        native_handle_delete(handle);
+    }
+    return CameraProviderManager::mapToStatusT(status);
+}
+
 status_t Camera3Device::HalInterface::processCaptureRequest(
         camera3_capture_request_t *request) {
     ATRACE_NAME("CameraHal::processCaptureRequest");
@@ -3258,76 +3388,10 @@
     if (mHal3Device != nullptr) {
         res = mHal3Device->ops->process_capture_request(mHal3Device, request);
     } else {
-        device::V3_2::CaptureRequest captureRequest;
-        captureRequest.frameNumber = request->frame_number;
-        std::vector<native_handle_t*> handlesCreated;
-        // A null request settings maps to a size-0 CameraMetadata
-        if (request->settings != nullptr) {
-            captureRequest.settings.setToExternal(
-                    reinterpret_cast<uint8_t*>(const_cast<camera_metadata_t*>(request->settings)),
-                    get_camera_metadata_size(request->settings));
-        }
-
-        {
-            std::lock_guard<std::mutex> lock(mInflightLock);
-            if (request->input_buffer != nullptr) {
-                int32_t streamId = Camera3Stream::cast(request->input_buffer->stream)->getId();
-                buffer_handle_t buf = *(request->input_buffer->buffer);
-                auto pair = getBufferId(buf, streamId);
-                bool isNewBuffer = pair.first;
-                uint64_t bufferId = pair.second;
-                captureRequest.inputBuffer.streamId = streamId;
-                captureRequest.inputBuffer.bufferId = bufferId;
-                captureRequest.inputBuffer.buffer = (isNewBuffer) ? buf : nullptr;
-                captureRequest.inputBuffer.status = BufferStatus::OK;
-                native_handle_t *acquireFence = nullptr;
-                if (request->input_buffer->acquire_fence != -1) {
-                    acquireFence = native_handle_create(1,0);
-                    acquireFence->data[0] = request->input_buffer->acquire_fence;
-                    handlesCreated.push_back(acquireFence);
-                }
-                captureRequest.inputBuffer.acquireFence = acquireFence;
-                captureRequest.inputBuffer.releaseFence = nullptr;
-
-                pushInflightBufferLocked(captureRequest.frameNumber, streamId,
-                        request->input_buffer->buffer,
-                        request->input_buffer->acquire_fence);
-            } else {
-                captureRequest.inputBuffer.streamId = -1;
-                captureRequest.inputBuffer.bufferId = BUFFER_ID_NO_BUFFER;
-            }
-
-            captureRequest.outputBuffers.resize(request->num_output_buffers);
-            for (size_t i = 0; i < request->num_output_buffers; i++) {
-                const camera3_stream_buffer_t *src = request->output_buffers + i;
-                StreamBuffer &dst = captureRequest.outputBuffers[i];
-                int32_t streamId = Camera3Stream::cast(src->stream)->getId();
-                buffer_handle_t buf = *(src->buffer);
-                auto pair = getBufferId(buf, streamId);
-                bool isNewBuffer = pair.first;
-                dst.streamId = streamId;
-                dst.bufferId = pair.second;
-                dst.buffer = isNewBuffer ? buf : nullptr;
-                dst.status = BufferStatus::OK;
-                native_handle_t *acquireFence = nullptr;
-                if (src->acquire_fence != -1) {
-                    acquireFence = native_handle_create(1,0);
-                    acquireFence->data[0] = src->acquire_fence;
-                    handlesCreated.push_back(acquireFence);
-                }
-                dst.acquireFence = acquireFence;
-                dst.releaseFence = nullptr;
-
-                pushInflightBufferLocked(captureRequest.frameNumber, streamId,
-                        src->buffer, src->acquire_fence);
-            }
-        }
-        common::V1_0::Status status = mHidlSession->processCaptureRequest(captureRequest);
-
-        for (auto& handle : handlesCreated) {
-            native_handle_delete(handle);
-        }
-        res = CameraProviderManager::mapToStatusT(status);
+        uint32_t numRequestProcessed = 0;
+        std::vector<camera3_capture_request_t*> requests(1);
+        requests[0] = request;
+        res = processBatchCaptureRequests(requests, &numRequestProcessed);
     }
     return res;
 }
@@ -3755,6 +3819,128 @@
     }
 }
 
+bool Camera3Device::RequestThread::sendRequestsBatch() {
+    status_t res;
+    size_t batchSize = mNextRequests.size();
+    std::vector<camera3_capture_request_t*> requests(batchSize);
+    uint32_t numRequestProcessed = 0;
+    for (size_t i = 0; i < batchSize; i++) {
+        requests[i] = &mNextRequests.editItemAt(i).halRequest;
+    }
+
+    ATRACE_ASYNC_BEGIN("batch frame capture", mNextRequests[0].halRequest.frame_number);
+    res = mInterface->processBatchCaptureRequests(requests, &numRequestProcessed);
+
+    bool triggerRemoveFailed = false;
+    NextRequest& triggerFailedRequest = mNextRequests.editItemAt(0);
+    for (size_t i = 0; i < numRequestProcessed; i++) {
+        NextRequest& nextRequest = mNextRequests.editItemAt(i);
+        nextRequest.submitted = true;
+
+
+        // Update the latest request sent to HAL
+        if (nextRequest.halRequest.settings != NULL) { // Don't update if they were unchanged
+            Mutex::Autolock al(mLatestRequestMutex);
+
+            camera_metadata_t* cloned = clone_camera_metadata(nextRequest.halRequest.settings);
+            mLatestRequest.acquire(cloned);
+
+            sp<Camera3Device> parent = mParent.promote();
+            if (parent != NULL) {
+                parent->monitorMetadata(TagMonitor::REQUEST,
+                        nextRequest.halRequest.frame_number,
+                        0, mLatestRequest);
+            }
+        }
+
+        if (nextRequest.halRequest.settings != NULL) {
+            nextRequest.captureRequest->mSettings.unlock(nextRequest.halRequest.settings);
+        }
+
+        if (!triggerRemoveFailed) {
+            // Remove any previously queued triggers (after unlock)
+            status_t removeTriggerRes = removeTriggers(mPrevRequest);
+            if (removeTriggerRes != OK) {
+                triggerRemoveFailed = true;
+                triggerFailedRequest = nextRequest;
+            }
+        }
+    }
+
+    if (triggerRemoveFailed) {
+        SET_ERR("RequestThread: Unable to remove triggers "
+              "(capture request %d, HAL device: %s (%d)",
+              triggerFailedRequest.halRequest.frame_number, strerror(-res), res);
+        cleanUpFailedRequests(/*sendRequestError*/ false);
+        return false;
+    }
+
+    if (res != OK) {
+        // Should only get a failure here for malformed requests or device-level
+        // errors, so consider all errors fatal.  Bad metadata failures should
+        // come through notify.
+        SET_ERR("RequestThread: Unable to submit capture request %d to HAL device: %s (%d)",
+                mNextRequests[numRequestProcessed].halRequest.frame_number,
+                strerror(-res), res);
+        cleanUpFailedRequests(/*sendRequestError*/ false);
+        return false;
+    }
+    return true;
+}
+
+bool Camera3Device::RequestThread::sendRequestsOneByOne() {
+    status_t res;
+
+    for (auto& nextRequest : mNextRequests) {
+        // Submit request and block until ready for next one
+        ATRACE_ASYNC_BEGIN("frame capture", nextRequest.halRequest.frame_number);
+        res = mInterface->processCaptureRequest(&nextRequest.halRequest);
+
+        if (res != OK) {
+            // Should only get a failure here for malformed requests or device-level
+            // errors, so consider all errors fatal.  Bad metadata failures should
+            // come through notify.
+            SET_ERR("RequestThread: Unable to submit capture request %d to HAL"
+                    " device: %s (%d)", nextRequest.halRequest.frame_number, strerror(-res),
+                    res);
+            cleanUpFailedRequests(/*sendRequestError*/ false);
+            return false;
+        }
+
+        // Mark that the request has be submitted successfully.
+        nextRequest.submitted = true;
+
+        // Update the latest request sent to HAL
+        if (nextRequest.halRequest.settings != NULL) { // Don't update if they were unchanged
+            Mutex::Autolock al(mLatestRequestMutex);
+
+            camera_metadata_t* cloned = clone_camera_metadata(nextRequest.halRequest.settings);
+            mLatestRequest.acquire(cloned);
+
+            sp<Camera3Device> parent = mParent.promote();
+            if (parent != NULL) {
+                parent->monitorMetadata(TagMonitor::REQUEST, nextRequest.halRequest.frame_number,
+                        0, mLatestRequest);
+            }
+        }
+
+        if (nextRequest.halRequest.settings != NULL) {
+            nextRequest.captureRequest->mSettings.unlock(nextRequest.halRequest.settings);
+        }
+
+        // Remove any previously queued triggers (after unlock)
+        res = removeTriggers(mPrevRequest);
+        if (res != OK) {
+            SET_ERR("RequestThread: Unable to remove triggers "
+                  "(capture request %d, HAL device: %s (%d)",
+                  nextRequest.halRequest.frame_number, strerror(-res), res);
+            cleanUpFailedRequests(/*sendRequestError*/ false);
+            return false;
+        }
+    }
+    return true;
+}
+
 bool Camera3Device::RequestThread::threadLoop() {
     ATRACE_CALL();
     status_t res;
@@ -3817,58 +4003,12 @@
 
     ALOGVV("%s: %d: submitting %zu requests in a batch.", __FUNCTION__, __LINE__,
             mNextRequests.size());
-    for (auto& nextRequest : mNextRequests) {
-        // Submit request and block until ready for next one
-        ATRACE_ASYNC_BEGIN("frame capture", nextRequest.halRequest.frame_number);
-        res = mInterface->processCaptureRequest(&nextRequest.halRequest);
 
-        if (res != OK) {
-            // Should only get a failure here for malformed requests or device-level
-            // errors, so consider all errors fatal.  Bad metadata failures should
-            // come through notify.
-            SET_ERR("RequestThread: Unable to submit capture request %d to HAL"
-                    " device: %s (%d)", nextRequest.halRequest.frame_number, strerror(-res),
-                    res);
-            cleanUpFailedRequests(/*sendRequestError*/ false);
-            if (useFlushLock) {
-                mFlushLock.unlock();
-            }
-            return false;
-        }
-
-        // Mark that the request has be submitted successfully.
-        nextRequest.submitted = true;
-
-        // Update the latest request sent to HAL
-        if (nextRequest.halRequest.settings != NULL) { // Don't update if they were unchanged
-            Mutex::Autolock al(mLatestRequestMutex);
-
-            camera_metadata_t* cloned = clone_camera_metadata(nextRequest.halRequest.settings);
-            mLatestRequest.acquire(cloned);
-
-            sp<Camera3Device> parent = mParent.promote();
-            if (parent != NULL) {
-                parent->monitorMetadata(TagMonitor::REQUEST, nextRequest.halRequest.frame_number,
-                        0, mLatestRequest);
-            }
-        }
-
-        if (nextRequest.halRequest.settings != NULL) {
-            nextRequest.captureRequest->mSettings.unlock(nextRequest.halRequest.settings);
-        }
-
-        // Remove any previously queued triggers (after unlock)
-        res = removeTriggers(mPrevRequest);
-        if (res != OK) {
-            SET_ERR("RequestThread: Unable to remove triggers "
-                  "(capture request %d, HAL device: %s (%d)",
-                  nextRequest.halRequest.frame_number, strerror(-res), res);
-            cleanUpFailedRequests(/*sendRequestError*/ false);
-            if (useFlushLock) {
-                mFlushLock.unlock();
-            }
-            return false;
-        }
+    bool submitRequestSuccess = false;
+    if (mInterface->supportBatchRequest()) {
+        submitRequestSuccess = sendRequestsBatch();
+    } else {
+        submitRequestSuccess = sendRequestsOneByOne();
     }
 
     if (useFlushLock) {
@@ -3881,13 +4021,14 @@
         mNextRequests.clear();
     }
 
-    return true;
+    return submitRequestSuccess;
 }
 
 status_t Camera3Device::RequestThread::prepareHalRequests() {
     ATRACE_CALL();
 
-    for (auto& nextRequest : mNextRequests) {
+    for (size_t i = 0; i < mNextRequests.size(); i++) {
+        auto& nextRequest = mNextRequests.editItemAt(i);
         sp<CaptureRequest> captureRequest = nextRequest.captureRequest;
         camera3_capture_request_t* halRequest = &nextRequest.halRequest;
         Vector<camera3_stream_buffer_t>* outputBuffers = &nextRequest.outputBuffers;
@@ -3964,8 +4105,8 @@
         outputBuffers->insertAt(camera3_stream_buffer_t(), 0,
                 captureRequest->mOutputStreams.size());
         halRequest->output_buffers = outputBuffers->array();
-        for (size_t i = 0; i < captureRequest->mOutputStreams.size(); i++) {
-            sp<Camera3OutputStreamInterface> outputStream = captureRequest->mOutputStreams.editItemAt(i);
+        for (size_t j = 0; j < captureRequest->mOutputStreams.size(); j++) {
+            sp<Camera3OutputStreamInterface> outputStream = captureRequest->mOutputStreams.editItemAt(j);
 
             // Prepare video buffers for high speed recording on the first video request.
             if (mPrepareVideoStream && outputStream->isVideoStream()) {
@@ -3983,8 +4124,8 @@
                 }
             }
 
-            res = outputStream->getBuffer(&outputBuffers->editItemAt(i),
-                    captureRequest->mOutputSurfaces[i]);
+            res = outputStream->getBuffer(&outputBuffers->editItemAt(j),
+                    captureRequest->mOutputSurfaces[j]);
             if (res != OK) {
                 // Can't get output buffer from gralloc queue - this could be due to
                 // abandoned queue or other consumer misbehavior, so not a fatal
@@ -4006,10 +4147,19 @@
             CLOGE("RequestThread: Parent is gone");
             return INVALID_OPERATION;
         }
+
+        // If this request list is for constrained high speed recording (not
+        // preview), and the current request is not the last one in the batch,
+        // do not send callback to the app.
+        bool hasCallback = true;
+        if (mNextRequests[0].captureRequest->mBatchSize > 1 && i != mNextRequests.size()-1) {
+            hasCallback = false;
+        }
         res = parent->registerInFlight(halRequest->frame_number,
                 totalNumBuffers, captureRequest->mResultExtras,
                 /*hasInput*/halRequest->input_buffer != NULL,
-                captureRequest->mAeTriggerCancelOverride);
+                captureRequest->mAeTriggerCancelOverride,
+                hasCallback);
         ALOGVV("%s: registered in flight requestId = %" PRId32 ", frameNumber = %" PRId64
                ", burstId = %" PRId32 ".",
                 __FUNCTION__,
diff --git a/services/camera/libcameraservice/device3/Camera3Device.h b/services/camera/libcameraservice/device3/Camera3Device.h
index 998cc0b..d873b27 100644
--- a/services/camera/libcameraservice/device3/Camera3Device.h
+++ b/services/camera/libcameraservice/device3/Camera3Device.h
@@ -241,6 +241,9 @@
         // Reset this HalInterface object (does not call close())
         void clear();
 
+        // Check if HalInterface support sending requests in batch
+        bool supportBatchRequest();
+
         // Calls into the HAL interface
 
         // Caller takes ownership of requestTemplate
@@ -248,6 +251,9 @@
                 /*out*/ camera_metadata_t **requestTemplate);
         status_t configureStreams(/*inout*/ camera3_stream_configuration *config);
         status_t processCaptureRequest(camera3_capture_request_t *request);
+        status_t processBatchCaptureRequests(
+                std::vector<camera3_capture_request_t*>& requests,
+                /*out*/uint32_t* numRequestProcessed);
         status_t flush();
         status_t dump(int fd);
         status_t close();
@@ -262,6 +268,12 @@
 
         std::mutex mInflightLock;
 
+        // The output HIDL request still depends on input camera3_capture_request_t
+        // Do not free input camera3_capture_request_t before output HIDL request
+        void wrapAsHidlRequest(camera3_capture_request_t* in,
+                /*out*/hardware::camera::device::V3_2::CaptureRequest* out,
+                /*out*/std::vector<native_handle_t*>* handlesCreated);
+
         status_t pushInflightBufferLocked(int32_t frameNumber, int32_t streamId,
                 buffer_handle_t *buffer, int acquireFence);
         // Cache of buffer handles keyed off (frameNumber << 32 | streamId)
@@ -438,9 +450,17 @@
      */
 
     hardware::Return<void> processCaptureResult(
-            const hardware::camera::device::V3_2::CaptureResult& result) override;
+            const hardware::hidl_vec<
+                    hardware::camera::device::V3_2::CaptureResult>& results) override;
     hardware::Return<void> notify(
-            const hardware::camera::device::V3_2::NotifyMsg& msg) override;
+            const hardware::hidl_vec<
+                    hardware::camera::device::V3_2::NotifyMsg>& msgs) override;
+
+    // Handle one capture result
+    void processOneCaptureResult(
+            const hardware::camera::device::V3_2::CaptureResult& results);
+    // Handle one notify message
+    void notify(const hardware::camera::device::V3_2::NotifyMsg& msg);
 
     /**
      * Common initialization code shared by both HAL paths
@@ -759,6 +779,12 @@
         // Clear repeating requests. Must be called with mRequestLock held.
         status_t clearRepeatingRequestsLocked(/*out*/ int64_t *lastFrameNumber = NULL);
 
+        // send request in mNextRequests to HAL one by one. Return true = sucssess
+        bool sendRequestsOneByOne();
+
+        // send request in mNextRequests to HAL in a batch. Return true = sucssess
+        bool sendRequestsBatch();
+
         wp<Camera3Device>  mParent;
         wp<camera3::StatusTracker>  mStatusTracker;
         HalInterface*      mInterface;
@@ -859,6 +885,12 @@
         // CONTROL_AE_PRECAPTURE_TRIGGER_CANCEL
         AeTriggerCancelOverride_t aeTriggerCancelOverride;
 
+        // Whether this inflight request's shutter and result callback are to be
+        // called. The policy is that if the request is the last one in the constrained
+        // high speed recording request list, this flag will be true. If the request list
+        // is not for constrained high speed recording, this flag will also be true.
+        bool hasCallback;
+
         // Default constructor needed by KeyedVector
         InFlightRequest() :
                 shutterTimestamp(0),
@@ -867,11 +899,12 @@
                 haveResultMetadata(false),
                 numBuffersLeft(0),
                 hasInputBuffer(false),
-                aeTriggerCancelOverride({false, 0, false, 0}){
+                aeTriggerCancelOverride({false, 0, false, 0}),
+                hasCallback(true) {
         }
 
         InFlightRequest(int numBuffers, CaptureResultExtras extras, bool hasInput,
-                AeTriggerCancelOverride aeTriggerCancelOverride) :
+                AeTriggerCancelOverride aeTriggerCancelOverride, bool hasAppCallback) :
                 shutterTimestamp(0),
                 sensorTimestamp(0),
                 requestStatus(OK),
@@ -879,7 +912,8 @@
                 numBuffersLeft(numBuffers),
                 resultExtras(extras),
                 hasInputBuffer(hasInput),
-                aeTriggerCancelOverride(aeTriggerCancelOverride){
+                aeTriggerCancelOverride(aeTriggerCancelOverride),
+                hasCallback(hasAppCallback) {
         }
     };
 
@@ -892,7 +926,7 @@
 
     status_t registerInFlight(uint32_t frameNumber,
             int32_t numBuffers, CaptureResultExtras resultExtras, bool hasInput,
-            const AeTriggerCancelOverride_t &aeTriggerCancelOverride);
+            const AeTriggerCancelOverride_t &aeTriggerCancelOverride, bool callback);
 
     /**
      * Override result metadata for cancelling AE precapture trigger applied in
diff --git a/services/camera/libcameraservice/device3/Camera3StreamSplitter.cpp b/services/camera/libcameraservice/device3/Camera3StreamSplitter.cpp
index bf6af86..869e93a 100644
--- a/services/camera/libcameraservice/device3/Camera3StreamSplitter.cpp
+++ b/services/camera/libcameraservice/device3/Camera3StreamSplitter.cpp
@@ -461,9 +461,9 @@
     } else if (res == NO_MEMORY) {
         SP_LOGV("%s: No free buffers", __FUNCTION__);
         return;
-    } else {
-        LOG_ALWAYS_FATAL_IF(res != NO_ERROR,
-                "detaching buffer from output failed (%d)", res);
+    } else if (res != OK) {
+        SP_LOGE("%s: detaching buffer from output failed (%d)", __FUNCTION__, res);
+        return;
     }
 
     BufferTracker& tracker = *(mBuffers[buffer->getId()]);
diff --git a/services/mediacodec/Android.mk b/services/mediacodec/Android.mk
index 5cb7f92..8eb4aa0 100644
--- a/services/mediacodec/Android.mk
+++ b/services/mediacodec/Android.mk
@@ -41,9 +41,11 @@
     $(TOP)/frameworks/av/media/libstagefright \
     $(TOP)/frameworks/av/media/libstagefright/include \
     $(TOP)/frameworks/native/include/media/openmax
-LOCAL_MODULE := mediacodec
+LOCAL_MODULE := android.hardware.media.omx@1.0-service
+LOCAL_MODULE_RELATIVE_PATH := hw
+LOCAL_PROPRIETARY_MODULE := true
 LOCAL_32_BIT_ONLY := true
-LOCAL_INIT_RC := mediacodec.rc
+LOCAL_INIT_RC := android.hardware.media.omx@1.0-service.rc
 include $(BUILD_EXECUTABLE)
 
 # service seccomp policy
diff --git a/services/mediacodec/mediacodec.rc b/services/mediacodec/android.hardware.media.omx@1.0-service.rc
similarity index 63%
rename from services/mediacodec/mediacodec.rc
rename to services/mediacodec/android.hardware.media.omx@1.0-service.rc
index d78e0a4..ec51d65 100644
--- a/services/mediacodec/mediacodec.rc
+++ b/services/mediacodec/android.hardware.media.omx@1.0-service.rc
@@ -1,4 +1,4 @@
-service mediacodec /system/bin/mediacodec
+service mediacodec /vendor/bin/hw/android.hardware.media.omx@1.0-service
     class main
     user mediacodec
     group camera drmrpc mediadrm
diff --git a/services/mediaextractor/seccomp_policy/mediaextractor-x86.policy b/services/mediaextractor/seccomp_policy/mediaextractor-x86.policy
index 19016cd..2ce6cf8 100644
--- a/services/mediaextractor/seccomp_policy/mediaextractor-x86.policy
+++ b/services/mediaextractor/seccomp_policy/mediaextractor-x86.policy
@@ -51,3 +51,7 @@
 getdents64: 1
 pipe2: 1
 ppoll: 1
+
+# Required by AddressSanitizer
+gettid: 1
+sched_yield: 1