/*
 * Copyright (C) 2022 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#include <NdkMediaCodecFuzzerBase.h>

static const std::string kMimeTypes[] = {
        MIMETYPE_AUDIO_AMR_NB, MIMETYPE_AUDIO_AMR_WB,    MIMETYPE_AUDIO_MPEG,
        MIMETYPE_AUDIO_AAC,    MIMETYPE_AUDIO_FLAC,      MIMETYPE_AUDIO_VORBIS,
        MIMETYPE_AUDIO_OPUS,   MIMETYPE_AUDIO_RAW,       MIMETYPE_AUDIO_MSGSM,
        MIMETYPE_AUDIO_EAC3,   MIMETYPE_AUDIO_SCRAMBLED, MIMETYPE_VIDEO_VP8,
        MIMETYPE_VIDEO_VP9,    MIMETYPE_VIDEO_AV1,       MIMETYPE_VIDEO_AVC,
        MIMETYPE_VIDEO_HEVC,   MIMETYPE_VIDEO_MPEG4,     MIMETYPE_VIDEO_H263,
        MIMETYPE_VIDEO_MPEG2,  MIMETYPE_VIDEO_RAW,       MIMETYPE_VIDEO_SCRAMBLED};

static const std::string kEncoderNames[] = {
        "c2.android.avc.encoder",    "c2.android.vp8.encoder",   "c2.android.vp9.encoder",
        "c2.android.hevc.encoder",   "c2.android.mpeg2.encoder", "c2.android.mpeg4.encoder",
        "c2.android.opus.encoder",   "c2.android.amrnb.encoder", "c2.android.flac.encoder",
        "c2.android.av1-aom.encoder"};

static const std::string kDecoderNames[] = {"c2.android.avc.decoder",
                                            "c2.android.vp8.decoder",
                                            "c2.android.vp9.decoder"
                                            "c2.android.hevc.decoder",
                                            "c2.android.mpeg2.decoder",
                                            "c2.android.mpeg4.decoder",
                                            "c2.android.opus.decoder",
                                            "c2.android.amrnb.decoder",
                                            "c2.android.flac.decoder",
                                            "c2.android.av1-aom.decoder"};

static const std::string kFormatIntKeys[] = {AMEDIAFORMAT_KEY_BIT_RATE,
                                             AMEDIAFORMAT_KEY_SAMPLE_RATE,
                                             AMEDIAFORMAT_KEY_FLAC_COMPRESSION_LEVEL,
                                             AMEDIAFORMAT_KEY_CHANNEL_COUNT,
                                             AMEDIAFORMAT_KEY_WIDTH,
                                             AMEDIAFORMAT_KEY_HEIGHT,
                                             AMEDIAFORMAT_KEY_FRAME_RATE,
                                             AMEDIAFORMAT_KEY_COLOR_FORMAT,
                                             AMEDIAFORMAT_VIDEO_QP_P_MIN,
                                             AMEDIAFORMAT_VIDEO_QP_P_MAX,
                                             AMEDIAFORMAT_VIDEO_QP_MIN,
                                             AMEDIAFORMAT_VIDEO_QP_MAX,
                                             AMEDIAFORMAT_VIDEO_QP_I_MIN,
                                             AMEDIAFORMAT_VIDEO_QP_I_MAX,
                                             AMEDIAFORMAT_VIDEO_QP_B_MIN,
                                             AMEDIAFORMAT_VIDEO_QP_B_MAX,
                                             AMEDIAFORMAT_KEY_VIDEO_QP_AVERAGE,
                                             AMEDIAFORMAT_KEY_VIDEO_ENCODING_STATISTICS_LEVEL,
                                             AMEDIAFORMAT_KEY_VALID_SAMPLES,
                                             AMEDIAFORMAT_KEY_TRACK_INDEX,
                                             AMEDIAFORMAT_KEY_TRACK_ID,
                                             AMEDIAFORMAT_KEY_TILE_WIDTH,
                                             AMEDIAFORMAT_KEY_TILE_HEIGHT,
                                             AMEDIAFORMAT_KEY_THUMBNAIL_WIDTH,
                                             AMEDIAFORMAT_KEY_THUMBNAIL_HEIGHT,
                                             AMEDIAFORMAT_KEY_TEMPORAL_LAYER_ID,
                                             AMEDIAFORMAT_KEY_TEMPORAL_LAYER_COUNT,
                                             AMEDIAFORMAT_KEY_STRIDE,
                                             AMEDIAFORMAT_KEY_SLICE_HEIGHT,
                                             AMEDIAFORMAT_KEY_SAR_WIDTH,
                                             AMEDIAFORMAT_KEY_SAR_HEIGHT,
                                             AMEDIAFORMAT_KEY_ROTATION,
                                             AMEDIAFORMAT_KEY_PCM_BIG_ENDIAN,
                                             AMEDIAFORMAT_KEY_PROFILE,
                                             AMEDIAFORMAT_KEY_PRIORITY,
                                             AMEDIAFORMAT_KEY_PICTURE_TYPE,
                                             AMEDIAFORMAT_KEY_PCM_ENCODING,
                                             AMEDIAFORMAT_KEY_OPERATING_RATE,
                                             AMEDIAFORMAT_KEY_MPEGH_REFERENCE_CHANNEL_LAYOUT,
                                             AMEDIAFORMAT_KEY_MPEGH_PROFILE_LEVEL_INDICATION,
                                             AMEDIAFORMAT_KEY_MAX_PTS_GAP_TO_ENCODER,
                                             AMEDIAFORMAT_KEY_MAX_INPUT_SIZE,
                                             AMEDIAFORMAT_KEY_MAX_FPS_TO_ENCODER,
                                             AMEDIAFORMAT_KEY_LOW_LATENCY,
                                             AMEDIAFORMAT_KEY_LOOP,
                                             AMEDIAFORMAT_KEY_LEVEL,
                                             AMEDIAFORMAT_KEY_LATENCY,
                                             AMEDIAFORMAT_KEY_IS_SYNC_FRAME,
                                             AMEDIAFORMAT_KEY_IS_DEFAULT,
                                             AMEDIAFORMAT_KEY_INTRA_REFRESH_PERIOD,
                                             AMEDIAFORMAT_KEY_HAPTIC_CHANNEL_COUNT,
                                             AMEDIAFORMAT_KEY_GRID_ROWS,
                                             AMEDIAFORMAT_KEY_GRID_COLUMNS,
                                             AMEDIAFORMAT_KEY_FRAME_COUNT,
                                             AMEDIAFORMAT_KEY_ENCODER_PADDING,
                                             AMEDIAFORMAT_KEY_ENCODER_DELAY,
                                             AMEDIAFORMAT_KEY_DISPLAY_WIDTH,
                                             AMEDIAFORMAT_KEY_DISPLAY_HEIGHT,
                                             AMEDIAFORMAT_KEY_DISPLAY_CROP,
                                             AMEDIAFORMAT_KEY_CRYPTO_SKIP_BYTE_BLOCK,
                                             AMEDIAFORMAT_KEY_CRYPTO_MODE,
                                             AMEDIAFORMAT_KEY_CRYPTO_ENCRYPTED_BYTE_BLOCK,
                                             AMEDIAFORMAT_KEY_CRYPTO_DEFAULT_IV_SIZE,
                                             AMEDIAFORMAT_KEY_COLOR_TRANSFER,
                                             AMEDIAFORMAT_KEY_COLOR_STANDARD,
                                             AMEDIAFORMAT_KEY_COLOR_RANGE,
                                             AMEDIAFORMAT_KEY_CHANNEL_MASK,
                                             AMEDIAFORMAT_KEY_BITS_PER_SAMPLE,
                                             AMEDIAFORMAT_KEY_BITRATE_MODE,
                                             AMEDIAFORMAT_KEY_AUDIO_SESSION_ID,
                                             AMEDIAFORMAT_KEY_AUDIO_PRESENTATION_PROGRAM_ID,
                                             AMEDIAFORMAT_KEY_AUDIO_PRESENTATION_PRESENTATION_ID,
                                             AMEDIAFORMAT_KEY_AAC_SBR_MODE,
                                             AMEDIAFORMAT_KEY_AAC_PROFILE,
                                             AMEDIAFORMAT_KEY_AAC_MAX_OUTPUT_CHANNEL_COUNT,
                                             AMEDIAFORMAT_KEY_AAC_ENCODED_TARGET_LEVEL,
                                             AMEDIAFORMAT_KEY_AAC_DRC_TARGET_REFERENCE_LEVEL,
                                             AMEDIAFORMAT_KEY_AAC_DRC_HEAVY_COMPRESSION,
                                             AMEDIAFORMAT_KEY_AAC_DRC_BOOST_FACTOR,
                                             AMEDIAFORMAT_KEY_AAC_DRC_ATTENUATION_FACTOR,
                                             AMEDIAFORMAT_KEY_XMP_SIZE,
                                             AMEDIAFORMAT_KEY_XMP_OFFSET,
                                             AMEDIAFORMAT_KEY_TIME_US,
                                             AMEDIAFORMAT_KEY_THUMBNAIL_TIME,
                                             AMEDIAFORMAT_KEY_TARGET_TIME,
                                             AMEDIAFORMAT_KEY_SAMPLE_TIME_BEFORE_APPEND,
                                             AMEDIAFORMAT_KEY_SAMPLE_FILE_OFFSET,
                                             AMEDIAFORMAT_KEY_LAST_SAMPLE_INDEX_IN_CHUNK,
                                             AMEDIAFORMAT_KEY_EXIF_SIZE,
                                             AMEDIAFORMAT_KEY_EXIF_OFFSET,
                                             AMEDIAFORMAT_KEY_DURATION};

static const std::string kFormatBufferKeys[] = {
        AMEDIAFORMAT_KEY_THUMBNAIL_CSD_HEVC,
        AMEDIAFORMAT_KEY_THUMBNAIL_CSD_AV1C,
        AMEDIAFORMAT_KEY_TEXT_FORMAT_DATA,
        AMEDIAFORMAT_KEY_SEI,
        AMEDIAFORMAT_KEY_PUSH_BLANK_BUFFERS_ON_STOP,
        AMEDIAFORMAT_KEY_PSSH,
        AMEDIAFORMAT_KEY_MPEGH_COMPATIBLE_SETS,
        AMEDIAFORMAT_KEY_MPEG2_STREAM_HEADER,
        AMEDIAFORMAT_KEY_MPEG_USER_DATA,
        AMEDIAFORMAT_KEY_ICC_PROFILE,
        AMEDIAFORMAT_KEY_HDR10_PLUS_INFO,
        AMEDIAFORMAT_KEY_HDR_STATIC_INFO,
        AMEDIAFORMAT_KEY_ESDS,
        AMEDIAFORMAT_KEY_D263,
        AMEDIAFORMAT_KEY_CSD_HEVC,
        AMEDIAFORMAT_KEY_CSD_AVC,
        AMEDIAFORMAT_KEY_CSD_2,
        AMEDIAFORMAT_KEY_CSD_1,
        AMEDIAFORMAT_KEY_CSD_0,
        AMEDIAFORMAT_KEY_CSD,
        AMEDIAFORMAT_KEY_CRYPTO_PLAIN_SIZES,
        AMEDIAFORMAT_KEY_CRYPTO_KEY,
        AMEDIAFORMAT_KEY_CRYPTO_IV,
        AMEDIAFORMAT_KEY_CRYPTO_ENCRYPTED_SIZES,
        AMEDIAFORMAT_KEY_CREATE_INPUT_SURFACE_SUSPENDED,
        AMEDIAFORMAT_KEY_AUDIO_PRESENTATION_INFO,
        AMEDIAFORMAT_KEY_ALBUMART,
};

static const std::string kFormatFloatKeys[] = {AMEDIAFORMAT_KEY_I_FRAME_INTERVAL,
                                               AMEDIAFORMAT_KEY_CAPTURE_RATE};

static const std::string kFormatStringKeys[] = {AMEDIAFORMAT_KEY_YEAR,
                                                AMEDIAFORMAT_KEY_TITLE,
                                                AMEDIAFORMAT_KEY_TEMPORAL_LAYERING,
                                                AMEDIAFORMAT_KEY_SLOW_MOTION_MARKERS,
                                                AMEDIAFORMAT_KEY_REPEAT_PREVIOUS_FRAME_AFTER,
                                                AMEDIAFORMAT_KEY_MANUFACTURER,
                                                AMEDIAFORMAT_KEY_LYRICIST,
                                                AMEDIAFORMAT_KEY_LOCATION,
                                                AMEDIAFORMAT_KEY_LANGUAGE,
                                                AMEDIAFORMAT_KEY_IS_FORCED_SUBTITLE,
                                                AMEDIAFORMAT_KEY_IS_AUTOSELECT,
                                                AMEDIAFORMAT_KEY_IS_ADTS,
                                                AMEDIAFORMAT_KEY_GENRE,
                                                AMEDIAFORMAT_KEY_DISCNUMBER,
                                                AMEDIAFORMAT_KEY_DATE,
                                                AMEDIAFORMAT_KEY_COMPOSER,
                                                AMEDIAFORMAT_KEY_COMPILATION,
                                                AMEDIAFORMAT_KEY_COMPLEXITY,
                                                AMEDIAFORMAT_KEY_CDTRACKNUMBER,
                                                AMEDIAFORMAT_KEY_AUTHOR,
                                                AMEDIAFORMAT_KEY_ARTIST,
                                                AMEDIAFORMAT_KEY_ALBUMARTIST,
                                                AMEDIAFORMAT_KEY_ALBUM};

void formatSetString(AMediaFormat* format, const char* AMEDIAFORMAT_KEY, FuzzedDataProvider* fdp) {
    if (fdp->ConsumeBool()) {
        std::string keyValue = fdp->ConsumeRandomLengthString(kMaxBytes);
        AMediaFormat_setString(format, AMEDIAFORMAT_KEY, keyValue.c_str());
    }
}

void formatSetInt(AMediaFormat* format, const char* AMEDIAFORMAT_KEY, FuzzedDataProvider* fdp) {
    if (fdp->ConsumeBool()) {
        int32_t keyValue = fdp->ConsumeIntegralInRange<size_t>(kMinIntKeyValue, kMaxIntKeyValue);
        AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY, keyValue);
    }
}

void formatSetFloat(AMediaFormat* format, const char* AMEDIAFORMAT_KEY, FuzzedDataProvider* fdp) {
    if (fdp->ConsumeBool()) {
        float keyValue =
                fdp->ConsumeFloatingPointInRange<float>(kMinFloatKeyValue, kMaxFloatKeyValue);
        AMediaFormat_setFloat(format, AMEDIAFORMAT_KEY, keyValue);
    }
}

void formatSetBuffer(AMediaFormat* format, const char* AMEDIAFORMAT_KEY, FuzzedDataProvider* fdp) {
    if (fdp->ConsumeBool()) {
        std::vector<uint8_t> buffer = fdp->ConsumeBytes<uint8_t>(
                fdp->ConsumeIntegralInRange<size_t>(kMinBytes, kMaxBytes));
        AMediaFormat_setBuffer(format, AMEDIAFORMAT_KEY, buffer.data(), buffer.size());
    }
}

AMediaCodec* NdkMediaCodecFuzzerBase::createAMediaCodecByname(bool isEncoder,
                                                              bool isCodecForClient) {
    std::string name;
    if (isEncoder) {
        name = mFdp->ConsumeBool() ? mFdp->PickValueInArray(kEncoderNames)
                                   : mFdp->ConsumeRandomLengthString(kMaxBytes);
    } else {
        name = mFdp->ConsumeBool() ? mFdp->PickValueInArray(kDecoderNames)
                                   : mFdp->ConsumeRandomLengthString(kMaxBytes);
    }

    if (isCodecForClient) {
        pid_t pid = mFdp->ConsumeIntegral<pid_t>();
        uid_t uid = mFdp->ConsumeIntegral<uid_t>();
        return AMediaCodec_createCodecByNameForClient(name.c_str(), pid, uid);

    } else {
        return AMediaCodec_createCodecByName(name.c_str());
    }
}

AMediaCodec* NdkMediaCodecFuzzerBase::createAMediaCodecByType(bool isEncoder,
                                                              bool isCodecForClient) {
    std::string mimeType;
    const char* mime = nullptr;

    if (mFdp->ConsumeBool()) {
        mimeType = mFdp->ConsumeRandomLengthString(kMaxBytes);
        mime = mimeType.c_str();
    } else {
        AMediaFormat_getString(mFormat, AMEDIAFORMAT_KEY_MIME, &mime);
    }

    if (isCodecForClient) {
        pid_t pid = mFdp->ConsumeIntegral<pid_t>();
        uid_t uid = mFdp->ConsumeIntegral<uid_t>();
        return isEncoder ? AMediaCodec_createEncoderByTypeForClient(mime, pid, uid)
                         : AMediaCodec_createDecoderByTypeForClient(mime, pid, uid);
    } else {
        return isEncoder ? AMediaCodec_createEncoderByType(mime)
                         : AMediaCodec_createDecoderByType(mime);
    }
}

void NdkMediaCodecFuzzerBase::setCodecFormat() {
    std::string value;
    int32_t count = 0;
    int32_t maxFormatKeys = 0;
    AMediaFormat_clear(mFormat);

    /*set mimeType*/
    if (mFdp->ConsumeBool()) {
        value = mFdp->ConsumeRandomLengthString(kMaxBytes);
    } else {
        value = mFdp->PickValueInArray(kMimeTypes);
    }
    if (mFdp->ConsumeBool()) {
        AMediaFormat_setString(mFormat, AMEDIAFORMAT_KEY_MIME, value.c_str());
    }

    maxFormatKeys = mFdp->ConsumeIntegralInRange<int32_t>(0, std::size(kFormatStringKeys));
    for (count = 0; count < maxFormatKeys; ++count) {
        std::string formatKey = mFdp->PickValueInArray(kFormatStringKeys);
        formatSetString(mFormat, formatKey.c_str(), mFdp);
    }

    maxFormatKeys = mFdp->ConsumeIntegralInRange<int32_t>(0, std::size(kFormatIntKeys));
    for (count = 0; count < maxFormatKeys; ++count) {
        std::string formatKey = mFdp->PickValueInArray(kFormatIntKeys);
        formatSetInt(mFormat, formatKey.c_str(), mFdp);
    }

    maxFormatKeys = mFdp->ConsumeIntegralInRange<int32_t>(0, std::size(kFormatFloatKeys));
    for (count = 0; count < maxFormatKeys; ++count) {
        std::string formatKey = mFdp->PickValueInArray(kFormatFloatKeys);
        formatSetFloat(mFormat, formatKey.c_str(), mFdp);
    }

    maxFormatKeys = mFdp->ConsumeIntegralInRange<int32_t>(0, std::size(kFormatBufferKeys));
    for (count = 0; count < maxFormatKeys; ++count) {
        std::string formatKey = mFdp->PickValueInArray(kFormatBufferKeys);
        formatSetBuffer(mFormat, formatKey.c_str(), mFdp);
    }
}

AMediaCodec* NdkMediaCodecFuzzerBase::createCodec(bool isEncoder, bool isCodecForClient) {
    setCodecFormat();
    return (mFdp->ConsumeBool() ? createAMediaCodecByname(isEncoder, isCodecForClient)
                                : createAMediaCodecByType(isEncoder, isCodecForClient));
}

void NdkMediaCodecFuzzerBase::invokeCodecFormatAPI(AMediaCodec* codec) {
    AMediaFormat* codecFormat = nullptr;
    size_t codecFormatAPI = mFdp->ConsumeIntegralInRange<size_t>(kMinAPICase, kMaxCodecFormatAPIs);
    switch (codecFormatAPI) {
        case 0: {
            codecFormat = AMediaCodec_getInputFormat(codec);
            break;
        }
        case 1: {
            codecFormat = AMediaCodec_getOutputFormat(codec);
            break;
        }
        case 2:
        default: {
            AMediaCodecBufferInfo info;
            int64_t timeOutUs = mFdp->ConsumeIntegralInRange<size_t>(kMinTimeOutUs, kMaxTimeOutUs);
            ssize_t bufferIndex = 0;
            if (mFdp->ConsumeBool()) {
                bufferIndex = AMediaCodec_dequeueOutputBuffer(codec, &info, timeOutUs);
            } else {
                bufferIndex =
                        mFdp->ConsumeIntegralInRange<size_t>(kMinBufferIndex, kMaxBufferIndex);
            }
            codecFormat = AMediaCodec_getBufferFormat(codec, bufferIndex);
            break;
        }
    }
    if (codecFormat) {
        AMediaFormat_delete(codecFormat);
    }
}

void NdkMediaCodecFuzzerBase::invokeInputBufferOperationAPI(AMediaCodec* codec) {
    size_t bufferSize = 0;
    ssize_t bufferIndex = 0;
    int64_t timeOutUs = mFdp->ConsumeIntegralInRange<size_t>(kMinTimeOutUs, kMaxTimeOutUs);
    if (mFdp->ConsumeBool()) {
        bufferIndex = AMediaCodec_dequeueInputBuffer(codec, timeOutUs);
    } else {
        bufferIndex = mFdp->ConsumeIntegralInRange<size_t>(kMinBufferIndex, kMaxBufferIndex);
    }

    uint8_t* buffer = AMediaCodec_getInputBuffer(codec, bufferIndex, &bufferSize);
    if (buffer) {
        std::vector<uint8_t> bytesRead = mFdp->ConsumeBytes<uint8_t>(
                std::min(mFdp->ConsumeIntegralInRange<size_t>(kMinBytes, kMaxBytes), bufferSize));
        memcpy(buffer, bytesRead.data(), bytesRead.size());
        bufferSize = bytesRead.size();
    }

    int32_t flag = mFdp->ConsumeIntegralInRange<size_t>(AMEDIACODEC_BUFFER_FLAG_CODEC_CONFIG,
                                                        AMEDIACODEC_BUFFER_FLAG_PARTIAL_FRAME);
    if (mFdp->ConsumeBool()) {
        AMediaCodec_queueInputBuffer(codec, bufferIndex, 0 /* offset */, bufferSize, 0 /* time */,
                                     flag);
    } else {
        AMediaCodecCryptoInfo* cryptoInfo = getAMediaCodecCryptoInfo();
        AMediaCodec_queueSecureInputBuffer(codec, bufferIndex, 0 /* offset */, cryptoInfo,
                                           0 /* time */, flag);
        AMediaCodecCryptoInfo_delete(cryptoInfo);
    }
}

void NdkMediaCodecFuzzerBase::invokeOutputBufferOperationAPI(AMediaCodec* codec) {
    ssize_t bufferIndex = 0;
    int64_t timeOutUs = mFdp->ConsumeIntegralInRange<size_t>(kMinTimeOutUs, kMaxTimeOutUs);
    if (mFdp->ConsumeBool()) {
        AMediaCodecBufferInfo info;
        bufferIndex = AMediaCodec_dequeueOutputBuffer(codec, &info, timeOutUs);
    } else {
        bufferIndex = mFdp->ConsumeIntegralInRange<size_t>(kMinBufferIndex, kMaxBufferIndex);
    }

    if (mFdp->ConsumeBool()) {
        size_t bufferSize = 0;
        (void)AMediaCodec_getOutputBuffer(codec, bufferIndex, &bufferSize);
    }

    if (mFdp->ConsumeBool()) {
        AMediaCodec_releaseOutputBuffer(codec, bufferIndex, mFdp->ConsumeBool());
    } else {
        AMediaCodec_releaseOutputBufferAtTime(codec, bufferIndex, timeOutUs);
    }
}

AMediaCodecCryptoInfo* NdkMediaCodecFuzzerBase::getAMediaCodecCryptoInfo() {
    uint8_t key[kMaxCryptoKey];
    uint8_t iv[kMaxCryptoKey];
    size_t clearBytes[kMaxCryptoKey];
    size_t encryptedBytes[kMaxCryptoKey];

    for (int32_t i = 0; i < kMaxCryptoKey; ++i) {
        key[i] = mFdp->ConsumeIntegral<uint8_t>();
        iv[i] = mFdp->ConsumeIntegral<uint8_t>();
        clearBytes[i] = mFdp->ConsumeIntegral<size_t>();
        encryptedBytes[i] = mFdp->ConsumeIntegral<size_t>();
    }

    return AMediaCodecCryptoInfo_new(kMaxCryptoKey, key, iv, AMEDIACODECRYPTOINFO_MODE_CLEAR,
                                     clearBytes, encryptedBytes);
}