| /* |
| * 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); |
| } |