Merge changes I90406c48,I1389b6ce into main
* changes:
Add thread safe annotation in audio flinger effects
EffectChain setVolume with EffectChainmutex held
diff --git a/media/codec2/Android.mk b/media/codec2/Android.mk
deleted file mode 100644
index 82d739f..0000000
--- a/media/codec2/Android.mk
+++ /dev/null
@@ -1,48 +0,0 @@
-# =============================================================================
-# DOCUMENTATION GENERATION
-# =============================================================================
-C2_ROOT := $(call my-dir)
-
-C2_DOCS_ROOT := $(OUT_DIR)/target/common/docs/codec2
-
-C2_OUT_TEMP := $(PRODUCT_OUT)/gen/ETC/Codec2-docs_intermediates
-
-C2_DOXY := $(or $(shell command -v doxygen),\
- $(shell command -v /Applications/Doxygen.app/Contents/Resources/doxygen))
-
-.PHONY: check-doxygen
-check-doxygen:
-ifndef C2_DOXY
- $(error 'doxygen is not available')
-endif
-
-$(C2_OUT_TEMP)/doxy-api.config: $(C2_ROOT)/docs/doxygen.config
- # only document include directory, no internal sections
- sed 's/\(^INPUT *=.*\)/\1include\//; \
- s/\(^INTERNAL_DOCS *= *\).*/\1NO/; \
- s/\(^ENABLED_SECTIONS *=.*\)INTERNAL\(.*\).*/\1\2/; \
- s:\(^OUTPUT_DIRECTORY *= \)out:\1'$(OUT_DIR)':;' \
- $(C2_ROOT)/docs/doxygen.config > $@
-
-$(C2_OUT_TEMP)/doxy-internal.config: $(C2_ROOT)/docs/doxygen.config
- sed 's:\(^OUTPUT_DIRECTORY *= \)out\(.*\)api:\1'$(OUT_DIR)'\2internal:;' \
- $(C2_ROOT)/docs/doxygen.config > $@
-
-.PHONY: docs-api
-docs-api: $(C2_OUT_TEMP)/doxy-api.config check-doxygen
- echo API docs are building in $(C2_DOCS_ROOT)/api
- rm -rf $(C2_DOCS_ROOT)/api
- mkdir -p $(C2_DOCS_ROOT)/api
- $(C2_DOXY) $(C2_OUT_TEMP)/doxy-api.config
-
-.PHONY: docs-internal
-docs-internal: $(C2_OUT_TEMP)/doxy-internal.config check-doxygen
- echo Internal docs are building in $(C2_DOCS_ROOT)/internal
- rm -rf $(C2_DOCS_ROOT)/internal
- mkdir -p $(C2_DOCS_ROOT)/internal
- $(C2_DOXY) $(C2_OUT_TEMP)/doxy-internal.config
-
-.PHONY: docs-all
-docs-all: docs-api docs-internal
-
-include $(call all-makefiles-under,$(call my-dir))
diff --git a/media/codec2/docs/doxygen.config b/media/codec2/docs/doxygen.config
index 5c3bea3..ab8b53b 100644
--- a/media/codec2/docs/doxygen.config
+++ b/media/codec2/docs/doxygen.config
@@ -162,7 +162,7 @@
# will be relative from the directory where doxygen is started.
# This tag requires that the tag FULL_PATH_NAMES is set to YES.
-STRIP_FROM_PATH = frameworks/av/media/libstagefright/codec2
+STRIP_FROM_PATH = frameworks/av/media/codec2
# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
# path mentioned in the documentation of a class, which tells the reader which
@@ -781,7 +781,7 @@
# spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
# Note: If this tag is empty the current directory is searched.
-INPUT = frameworks/av/media/libstagefright/codec2/
+INPUT = frameworks/av/media/codec2/
# This tag can be used to specify the character encoding of the source files
# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
@@ -897,7 +897,7 @@
# need to set EXTENSION_MAPPING for the extension otherwise the files are not
# properly processed by doxygen.
-INPUT_FILTER = frameworks/av/media/libstagefright/codec2/docs/doxyfilter.sh
+INPUT_FILTER = frameworks/av/media/codec2/docs/doxyfilter.sh
# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
# basis. Doxygen will compare the file name with each pattern and apply the
diff --git a/media/codec2/doxygen.sh b/media/codec2/doxygen.sh
new file mode 100755
index 0000000..ca5aeed
--- /dev/null
+++ b/media/codec2/doxygen.sh
@@ -0,0 +1,87 @@
+#!/bin/bash
+# Copyright (C) 2024 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.
+
+# =============================================================================
+# DOCUMENTATION GENERATION
+# =============================================================================
+
+if [ -z "$ANDROID_BUILD_TOP" ]; then
+ echo "error: Android build is not set up. Run this command after lunch." >&2
+ exit 2
+fi
+
+OUT_DIR=$ANDROID_BUILD_TOP/out
+
+# Codec 2.0 source and target paths
+C2_ROOT=$(dirname "$0")
+C2_DOCS_ROOT=$OUT_DIR/target/common/docs/codec2
+C2_OUT_TEMP=$ANDROID_PRODUCT_OUT/gen/ETC/Codec2-docs_intermediates
+
+# Doxygen path
+DOXY=$(which doxygen)
+DOXY_MAC="/Applications/Doxygen.app/Contents/Resources/doxygen"
+if [ -z "$DOXY" -a -x "$DOXY_MAC" ]; then
+ DOXY=$DOXY_MAC
+fi
+
+if [ -z "$DOXY" ]; then
+ echo "error: doxygen is not available" >&2
+ exit 2
+fi
+
+# Create doxygen config
+# ---------------------
+gen_doxy() {
+ local variant=$1
+ local variant_lc=$(echo $variant | tr A-Z a-z)
+ mkdir -p $C2_OUT_TEMP
+ if [ "$variant_lc" == "api" ]; then
+ # only document include directory, no internal sections
+ sed 's/\(^INPUT *=.*\)/\1core\/include\//;
+ s/\(^INTERNAL_DOCS *= *\).*/\1NO/;
+ s/\(^ENABLED_SECTIONS *=.*\)INTERNAL\(.*\).*/\1\2/;
+ s:\(^OUTPUT_DIRECTORY *= \)out\(.*\)api:\1'$OUT_DIR'\2'$variant_lc':;' \
+ $C2_ROOT/docs/doxygen.config > $C2_OUT_TEMP/doxy-$variant_lc.config
+
+ ls -la $C2_OUT_TEMP/doxy-$variant_lc.config
+ else
+ sed 's:\(^OUTPUT_DIRECTORY *= \)out\(.*\)api:\1'$OUT_DIR'\2'$variant_lc':;' \
+ $C2_ROOT/docs/doxygen.config > $C2_OUT_TEMP/doxy-$variant_lc.config
+ fi
+
+ echo $variant docs are building in $C2_DOCS_ROOT/$variant_lc
+ rm -rf $C2_DOCS_ROOT/$variant_lc
+ mkdir -p $C2_DOCS_ROOT/$variant_lc
+ pushd $ANDROID_BUILD_TOP
+ $DOXY $C2_OUT_TEMP/doxy-$variant_lc.config
+ popd
+}
+
+usage() {
+ echo "usage: $(basename "$0") [target]"
+ echo " where target can be one of:"
+ echo " all: build both API and internal docs (default)"
+ echo " api: build API docs only"
+ echo " internal: build internal docs which include implementation details"
+}
+
+TARGET=${1:-all}
+case "$TARGET" in
+ api) gen_doxy API;;
+ internal) gen_doxy Internal;;
+ all) gen_doxy API; gen_doxy Internal;;
+ -h) usage; exit 0;;
+ *) echo "unknown target '$TARGET'" >&2; usage; exit 2;;
+esac
diff --git a/media/codec2/hal/aidl/Component.cpp b/media/codec2/hal/aidl/Component.cpp
index bdc560f..8da9861 100644
--- a/media/codec2/hal/aidl/Component.cpp
+++ b/media/codec2/hal/aidl/Component.cpp
@@ -51,8 +51,10 @@
struct Component::Listener : public C2Component::Listener {
Listener(const std::shared_ptr<Component>& component) :
- mComponent(component),
- mListener(component->mListener) {
+ mComponent(component),
+ mListener(component->mListener) {
+ CHECK(component);
+ CHECK(component->mListener);
}
virtual void onError_nb(
@@ -420,6 +422,8 @@
mInit = res;
}
+ // b/321902635, mListener should not be null.
+ CHECK(mListener);
mDeathRecipient = ::ndk::ScopedAIBinder_DeathRecipient(
AIBinder_DeathRecipient_new(OnBinderDied));
mDeathContext = new DeathContext{ref<Component>()};
diff --git a/media/codec2/hal/aidl/ComponentStore.cpp b/media/codec2/hal/aidl/ComponentStore.cpp
index f0a1490..3f687b5 100644
--- a/media/codec2/hal/aidl/ComponentStore.cpp
+++ b/media/codec2/hal/aidl/ComponentStore.cpp
@@ -210,6 +210,8 @@
c2_status_t status =
mStore->createComponent(name, &c2component);
+ ALOGD("createComponent(): listener(%d)", bool(listener));
+
if (status == C2_OK) {
#ifndef __ANDROID_APEX__
c2component = GetFilterWrapper()->maybeWrapComponent(c2component);
@@ -218,7 +220,8 @@
std::shared_ptr<Component> comp =
SharedRefBase::make<Component>(c2component, listener, ref<ComponentStore>(), pool);
*component = comp;
- if (!component) {
+ if (!component || !comp) {
+ ALOGE("createComponent(): component cannot be returned");
status = C2_CORRUPTED;
} else {
reportComponentBirth(comp.get());
diff --git a/media/libmediaplayerservice/fuzzer/Android.bp b/media/libmediaplayerservice/fuzzer/Android.bp
index b511372..9332e40 100644
--- a/media/libmediaplayerservice/fuzzer/Android.bp
+++ b/media/libmediaplayerservice/fuzzer/Android.bp
@@ -110,6 +110,17 @@
"libresourcemanagerservice",
"libmediametricsservice",
"mediametricsservice-aidl-cpp",
+ "libcameraservice",
+ "android.hardware.camera.common@1.0",
+ "android.hardware.camera.provider@2.4",
+ "android.hardware.camera.provider@2.5",
+ "android.hardware.camera.provider@2.6",
+ "android.hardware.camera.provider@2.7",
+ "android.hardware.camera.provider-V3-ndk",
+ "android.hardware.camera.device@1.0",
+ "android.hardware.camera.device@3.2",
+ "android.hardware.camera.device@3.4",
+ "libaudiohal@7.0",
],
header_libs: [
"libaudiohal_headers",
diff --git a/media/libmediaplayerservice/fuzzer/mediarecorder_fuzzer.cpp b/media/libmediaplayerservice/fuzzer/mediarecorder_fuzzer.cpp
index fdac1a1..2518c21 100644
--- a/media/libmediaplayerservice/fuzzer/mediarecorder_fuzzer.cpp
+++ b/media/libmediaplayerservice/fuzzer/mediarecorder_fuzzer.cpp
@@ -15,22 +15,22 @@
*
*/
-#include <media/stagefright/foundation/AString.h>
-#include "fuzzer/FuzzedDataProvider.h"
-
#include <AudioFlinger.h>
#include <MediaPlayerService.h>
#include <ResourceManagerService.h>
-#include <fakeservicemanager/FakeServiceManager.h>
#include <StagefrightRecorder.h>
#include <camera/Camera.h>
#include <camera/android/hardware/ICamera.h>
+#include <fakeservicemanager/FakeServiceManager.h>
#include <gui/IGraphicBufferProducer.h>
#include <gui/Surface.h>
#include <gui/SurfaceComposerClient.h>
#include <media/stagefright/PersistentSurface.h>
+#include <media/stagefright/foundation/AString.h>
#include <mediametricsservice/MediaMetricsService.h>
#include <thread>
+#include "CameraService.h"
+#include "fuzzer/FuzzedDataProvider.h"
using namespace std;
using namespace android;
@@ -46,32 +46,27 @@
AUDIO_SOURCE_VOICE_RECOGNITION, AUDIO_SOURCE_VOICE_COMMUNICATION,
AUDIO_SOURCE_REMOTE_SUBMIX, AUDIO_SOURCE_UNPROCESSED,
AUDIO_SOURCE_VOICE_PERFORMANCE, AUDIO_SOURCE_ECHO_REFERENCE,
- AUDIO_SOURCE_FM_TUNER, AUDIO_SOURCE_HOTWORD};
+ AUDIO_SOURCE_FM_TUNER, AUDIO_SOURCE_HOTWORD,
+ AUDIO_SOURCE_ULTRASOUND};
+
+constexpr output_format kOutputFormat[] = {
+ OUTPUT_FORMAT_DEFAULT, OUTPUT_FORMAT_THREE_GPP,
+ OUTPUT_FORMAT_MPEG_4, OUTPUT_FORMAT_AUDIO_ONLY_START,
+ OUTPUT_FORMAT_RAW_AMR, OUTPUT_FORMAT_AMR_NB,
+ OUTPUT_FORMAT_AMR_WB, OUTPUT_FORMAT_AAC_ADTS,
+ OUTPUT_FORMAT_AUDIO_ONLY_END, OUTPUT_FORMAT_RTP_AVP,
+ OUTPUT_FORMAT_MPEG2TS, OUTPUT_FORMAT_WEBM,
+ OUTPUT_FORMAT_HEIF, OUTPUT_FORMAT_OGG,
+ OUTPUT_FORMAT_LIST_END};
+
+constexpr video_encoder kVideoEncoder[] = {
+ VIDEO_ENCODER_DEFAULT, VIDEO_ENCODER_H263, VIDEO_ENCODER_H264,
+ VIDEO_ENCODER_MPEG_4_SP, VIDEO_ENCODER_VP8, VIDEO_ENCODER_HEVC,
+ VIDEO_ENCODER_DOLBY_VISION, VIDEO_ENCODER_AV1, VIDEO_ENCODER_LIST_END};
constexpr audio_microphone_direction_t kSupportedMicrophoneDirections[] = {
MIC_DIRECTION_UNSPECIFIED, MIC_DIRECTION_FRONT, MIC_DIRECTION_BACK, MIC_DIRECTION_EXTERNAL};
-struct RecordingConfig {
- output_format outputFormat;
- audio_encoder audioEncoder;
- video_encoder videoEncoder;
-};
-
-const struct RecordingConfig kRecordingConfigList[] = {
- {OUTPUT_FORMAT_AMR_NB, AUDIO_ENCODER_AMR_NB, VIDEO_ENCODER_DEFAULT},
- {OUTPUT_FORMAT_AMR_WB, AUDIO_ENCODER_AMR_WB, VIDEO_ENCODER_DEFAULT},
- {OUTPUT_FORMAT_AAC_ADTS, AUDIO_ENCODER_AAC, VIDEO_ENCODER_DEFAULT},
- {OUTPUT_FORMAT_AAC_ADTS, AUDIO_ENCODER_HE_AAC, VIDEO_ENCODER_DEFAULT},
- {OUTPUT_FORMAT_AAC_ADTS, AUDIO_ENCODER_AAC_ELD, VIDEO_ENCODER_DEFAULT},
- {OUTPUT_FORMAT_OGG, AUDIO_ENCODER_OPUS, VIDEO_ENCODER_DEFAULT},
- {OUTPUT_FORMAT_RTP_AVP, AUDIO_ENCODER_DEFAULT, VIDEO_ENCODER_DEFAULT},
- {OUTPUT_FORMAT_MPEG2TS, AUDIO_ENCODER_AAC, VIDEO_ENCODER_H264},
- {OUTPUT_FORMAT_WEBM, AUDIO_ENCODER_VORBIS, VIDEO_ENCODER_VP8},
- {OUTPUT_FORMAT_THREE_GPP, AUDIO_ENCODER_DEFAULT, VIDEO_ENCODER_MPEG_4_SP},
- {OUTPUT_FORMAT_MPEG_4, AUDIO_ENCODER_AAC, VIDEO_ENCODER_H264},
- {OUTPUT_FORMAT_MPEG_4, AUDIO_ENCODER_DEFAULT, VIDEO_ENCODER_MPEG_4_SP},
- {OUTPUT_FORMAT_MPEG_4, AUDIO_ENCODER_DEFAULT, VIDEO_ENCODER_HEVC}};
-
const string kParametersList[] = {"max-duration",
"max-filesize",
"interleave-duration-us",
@@ -104,14 +99,16 @@
"rtp-param-ext-cvo-degrees",
"video-param-request-i-frame",
"rtp-param-set-socket-dscp",
- "rtp-param-set-socket-network"};
+ "rtp-param-set-socket-network",
+ "rtp-param-set-socket-ecn",
+ "rtp-param-remote-ip",
+ "rtp-param-set-socket-network",
+ "log-session-id"};
-constexpr int32_t kMaxSleepTimeInMs = 100;
-constexpr int32_t kMinSleepTimeInMs = 0;
constexpr int32_t kMinVideoSize = 2;
constexpr int32_t kMaxVideoSize = 8192;
-constexpr int32_t kNumRecordMin = 1;
-constexpr int32_t kNumRecordMax = 10;
+const char kOutputFile[] = "OutputFile";
+const char kNextOutputFile[] = "NextOutputFile";
class TestAudioDeviceCallback : public AudioSystem::AudioDeviceCallback {
public:
@@ -194,8 +191,7 @@
int32_t max;
mStfRecorder->getMaxAmplitude(&max);
- int32_t deviceId = mFdp.ConsumeIntegral<int32_t>();
- mStfRecorder->setInputDevice(deviceId);
+ int32_t deviceId;
mStfRecorder->getRoutedDeviceId(&deviceId);
vector<android::media::MicrophoneInfoFw> activeMicrophones{};
@@ -213,101 +209,189 @@
sp<IGraphicBufferProducer> buffer = mStfRecorder->querySurfaceMediaSource();
}
-void MediaRecorderClientFuzzer::dumpInfo() {
- int32_t dumpFd = memfd_create("DumpFile", MFD_ALLOW_SEALING);
- Vector<String16> args;
- args.push_back(String16(mFdp.ConsumeRandomLengthString().c_str()));
- mStfRecorder->dump(dumpFd, args);
- close(dumpFd);
-}
-
-void MediaRecorderClientFuzzer::setConfig() {
- mStfRecorder->setOutputFile(mMediaRecorderOutputFd);
- mStfRecorder->setAudioSource(mFdp.PickValueInArray(kSupportedAudioSources));
- mStfRecorder->setVideoSource(mFdp.PickValueInArray(kSupportedVideoSources));
- mStfRecorder->setPreferredMicrophoneDirection(
- mFdp.PickValueInArray(kSupportedMicrophoneDirections));
- mStfRecorder->setPrivacySensitive(mFdp.ConsumeBool());
- bool isPrivacySensitive;
- mStfRecorder->isPrivacySensitive(&isPrivacySensitive);
- mStfRecorder->setVideoSize(mFdp.ConsumeIntegralInRange<int32_t>(kMinVideoSize, kMaxVideoSize),
- mFdp.ConsumeIntegralInRange<int32_t>(kMinVideoSize, kMaxVideoSize));
- mStfRecorder->setVideoFrameRate(mFdp.ConsumeIntegral<int32_t>());
- mStfRecorder->enableAudioDeviceCallback(mFdp.ConsumeBool());
- mStfRecorder->setPreferredMicrophoneFieldDimension(mFdp.ConsumeFloatingPoint<float>());
- mStfRecorder->setClientName(String16(mFdp.ConsumeRandomLengthString().c_str()));
-
- int32_t Idx = mFdp.ConsumeIntegralInRange<int32_t>(0, size(kRecordingConfigList) - 1);
- mStfRecorder->setOutputFormat(kRecordingConfigList[Idx].outputFormat);
- mStfRecorder->setAudioEncoder(kRecordingConfigList[Idx].audioEncoder);
- mStfRecorder->setVideoEncoder(kRecordingConfigList[Idx].videoEncoder);
-
- int32_t nextOutputFd = memfd_create("NextOutputFile", MFD_ALLOW_SEALING);
- mStfRecorder->setNextOutputFile(nextOutputFd);
- close(nextOutputFd);
-
- for (Idx = 0; Idx < size(kParametersList); ++Idx) {
- if (mFdp.ConsumeBool()) {
- int32_t value = mFdp.ConsumeIntegral<int32_t>();
- mStfRecorder->setParameters(
- String8((kParametersList[Idx] + "=" + to_string(value)).c_str()));
- }
+template <typename FuncWrapper>
+void callMediaAPI(FuncWrapper funcWrapper, FuzzedDataProvider* fdp) {
+ if (fdp->ConsumeBool()) {
+ funcWrapper();
}
}
-MediaRecorderClientFuzzer::MediaRecorderClientFuzzer(const uint8_t *data, size_t size)
- : mFdp(data, size), mMediaRecorderOutputFd(memfd_create("OutputFile", MFD_ALLOW_SEALING)) {
+void MediaRecorderClientFuzzer::setConfig() {
+ callMediaAPI(
+ [this]() {
+ mSurfaceControl = mComposerClient.createSurface(
+ String8(mFdp.ConsumeRandomLengthString().c_str()) /* name */,
+ mFdp.ConsumeIntegral<uint32_t>() /* width */,
+ mFdp.ConsumeIntegral<uint32_t>() /* height */,
+ mFdp.ConsumeIntegral<int32_t>() /* pixel-format */,
+ mFdp.ConsumeIntegral<int32_t>() /* flags */);
+ if (mSurfaceControl) {
+ mSurface = mSurfaceControl->getSurface();
+ mStfRecorder->setPreviewSurface(mSurface->getIGraphicBufferProducer());
+ }
+ },
+ &mFdp);
+
+ callMediaAPI([this]() { mStfRecorder->setInputDevice(mFdp.ConsumeIntegral<int32_t>()); },
+ &mFdp);
+
+ callMediaAPI(
+ [this]() {
+ sp<TestMediaRecorderClient> listener = sp<TestMediaRecorderClient>::make();
+ mStfRecorder->setListener(listener);
+ },
+ &mFdp);
+
+ callMediaAPI(
+ [this]() {
+ sp<TestCamera> testCamera = sp<TestCamera>::make();
+ sp<Camera> camera = Camera::create(testCamera);
+ mStfRecorder->setCamera(camera->remote(), camera->getRecordingProxy());
+ },
+ &mFdp);
+
+ callMediaAPI(
+ [this]() {
+ sp<PersistentSurface> persistentSurface = sp<PersistentSurface>::make();
+ mStfRecorder->setInputSurface(persistentSurface);
+ },
+ &mFdp);
+
+ callMediaAPI(
+ [this]() {
+ sp<TestAudioDeviceCallback> callback = sp<TestAudioDeviceCallback>::make();
+ mStfRecorder->setAudioDeviceCallback(callback);
+ mStfRecorder->setOutputFile(mMediaRecorderOutputFd);
+ },
+ &mFdp);
+
+ callMediaAPI(
+ [this]() {
+ mStfRecorder->setAudioSource(mFdp.PickValueInArray(kSupportedAudioSources));
+ },
+ &mFdp);
+
+ callMediaAPI(
+ [this]() {
+ mStfRecorder->setVideoSource(mFdp.PickValueInArray(kSupportedVideoSources));
+ },
+ &mFdp);
+
+ callMediaAPI(
+ [this]() {
+ mStfRecorder->setPreferredMicrophoneDirection(
+ mFdp.PickValueInArray(kSupportedMicrophoneDirections));
+ },
+ &mFdp);
+
+ callMediaAPI([this]() { mStfRecorder->setPrivacySensitive(mFdp.ConsumeBool()); }, &mFdp);
+
+ callMediaAPI(
+ [this]() {
+ bool isPrivacySensitive;
+ mStfRecorder->isPrivacySensitive(&isPrivacySensitive);
+ },
+ &mFdp);
+
+ callMediaAPI(
+ [this]() {
+ mStfRecorder->setVideoSize(mFdp.ConsumeIntegralInRange<int32_t>(
+ kMinVideoSize, kMaxVideoSize) /* width */,
+ mFdp.ConsumeIntegralInRange<int32_t>(
+ kMinVideoSize, kMaxVideoSize) /* height */);
+ },
+ &mFdp);
+
+ callMediaAPI([this]() { mStfRecorder->setVideoFrameRate(mFdp.ConsumeIntegral<int32_t>()); },
+ &mFdp);
+
+ callMediaAPI([this]() { mStfRecorder->enableAudioDeviceCallback(mFdp.ConsumeBool()); }, &mFdp);
+
+ callMediaAPI(
+ [this]() {
+ mStfRecorder->setPreferredMicrophoneFieldDimension(
+ mFdp.ConsumeFloatingPoint<float>());
+ },
+ &mFdp);
+
+ callMediaAPI(
+ [this]() {
+ mStfRecorder->setClientName(String16(mFdp.ConsumeRandomLengthString().c_str()));
+ },
+ &mFdp);
+
+ callMediaAPI(
+ [this]() {
+ output_format OutputFormat = mFdp.PickValueInArray(kOutputFormat);
+ audio_encoder AudioEncoderFormat =
+ (audio_encoder)mFdp.ConsumeIntegralInRange<int32_t>(AUDIO_ENCODER_DEFAULT,
+ AUDIO_ENCODER_LIST_END);
+ video_encoder VideoEncoderFormat = mFdp.PickValueInArray(kVideoEncoder);
+ if (OutputFormat == OUTPUT_FORMAT_AMR_NB) {
+ AudioEncoderFormat =
+ mFdp.ConsumeBool() ? AUDIO_ENCODER_DEFAULT : AUDIO_ENCODER_AMR_NB;
+ } else if (OutputFormat == OUTPUT_FORMAT_AMR_WB) {
+ AudioEncoderFormat = AUDIO_ENCODER_AMR_WB;
+ } else if (OutputFormat == OUTPUT_FORMAT_AAC_ADIF ||
+ OutputFormat == OUTPUT_FORMAT_AAC_ADTS ||
+ OutputFormat == OUTPUT_FORMAT_MPEG2TS) {
+ AudioEncoderFormat = (audio_encoder)mFdp.ConsumeIntegralInRange<int32_t>(
+ AUDIO_ENCODER_AAC, AUDIO_ENCODER_AAC_ELD);
+ if (OutputFormat == OUTPUT_FORMAT_MPEG2TS) {
+ VideoEncoderFormat = VIDEO_ENCODER_H264;
+ }
+ }
+ mStfRecorder->setOutputFormat(OutputFormat);
+ mStfRecorder->setAudioEncoder(AudioEncoderFormat);
+ mStfRecorder->setVideoEncoder(VideoEncoderFormat);
+ },
+ &mFdp);
+
+ callMediaAPI(
+ [this]() {
+ int32_t nextOutputFd = memfd_create(kNextOutputFile, MFD_ALLOW_SEALING);
+ mStfRecorder->setNextOutputFile(nextOutputFd);
+ close(nextOutputFd);
+ },
+ &mFdp);
+
+ callMediaAPI(
+ [this]() {
+ for (int32_t idx = 0; idx < size(kParametersList); ++idx) {
+ if (mFdp.ConsumeBool()) {
+ int32_t value = mFdp.ConsumeIntegral<int32_t>();
+ mStfRecorder->setParameters(
+ String8((kParametersList[idx] + "=" + to_string(value)).c_str()));
+ }
+ }
+ },
+ &mFdp);
+}
+
+MediaRecorderClientFuzzer::MediaRecorderClientFuzzer(const uint8_t* data, size_t size)
+ : mFdp(data, size), mMediaRecorderOutputFd(memfd_create(kOutputFile, MFD_ALLOW_SEALING)) {
AttributionSourceState attributionSource;
attributionSource.packageName = mFdp.ConsumeRandomLengthString().c_str();
attributionSource.token = sp<BBinder>::make();
mStfRecorder = make_unique<StagefrightRecorder>(attributionSource);
-
- mSurfaceControl = mComposerClient.createSurface(
- String8(mFdp.ConsumeRandomLengthString().c_str()), mFdp.ConsumeIntegral<uint32_t>(),
- mFdp.ConsumeIntegral<uint32_t>(), mFdp.ConsumeIntegral<int32_t>(),
- mFdp.ConsumeIntegral<int32_t>());
- if (mSurfaceControl) {
- mSurface = mSurfaceControl->getSurface();
- mStfRecorder->setPreviewSurface(mSurface->getIGraphicBufferProducer());
- }
-
- sp<TestMediaRecorderClient> listener = sp<TestMediaRecorderClient>::make();
- mStfRecorder->setListener(listener);
-
- sp<TestCamera> testCamera = sp<TestCamera>::make();
- sp<Camera> camera = Camera::create(testCamera);
- mStfRecorder->setCamera(camera->remote(), camera->getRecordingProxy());
-
- sp<PersistentSurface> persistentSurface = sp<PersistentSurface>::make();
- mStfRecorder->setInputSurface(persistentSurface);
-
- sp<TestAudioDeviceCallback> callback = sp<TestAudioDeviceCallback>::make();
- mStfRecorder->setAudioDeviceCallback(callback);
}
void MediaRecorderClientFuzzer::process() {
- setConfig();
-
mStfRecorder->init();
mStfRecorder->prepare();
- size_t numRecord = mFdp.ConsumeIntegralInRange<size_t>(kNumRecordMin, kNumRecordMax);
- for (size_t Idx = 0; Idx < numRecord; ++Idx) {
- mStfRecorder->start();
- this_thread::sleep_for(chrono::milliseconds(
- mFdp.ConsumeIntegralInRange<int32_t>(kMinSleepTimeInMs, kMaxSleepTimeInMs)));
- mStfRecorder->pause();
- this_thread::sleep_for(chrono::milliseconds(
- mFdp.ConsumeIntegralInRange<int32_t>(kMinSleepTimeInMs, kMaxSleepTimeInMs)));
- mStfRecorder->resume();
- this_thread::sleep_for(chrono::milliseconds(
- mFdp.ConsumeIntegralInRange<int32_t>(kMinSleepTimeInMs, kMaxSleepTimeInMs)));
- mStfRecorder->stop();
+ while (mFdp.remaining_bytes()) {
+ auto invokeMediaPLayerApi = mFdp.PickValueInArray<const std::function<void()>>({
+ [&]() { setConfig(); },
+ [&]() { mStfRecorder->start(); },
+ [&]() { mStfRecorder->pause(); },
+ [&]() { mStfRecorder->resume(); },
+ [&]() { mStfRecorder->stop(); },
+ [&]() { getConfig(); },
+ [&]() { mStfRecorder->close(); },
+ [&]() { mStfRecorder->reset(); },
+ });
+ invokeMediaPLayerApi();
}
- dumpInfo();
- getConfig();
-
- mStfRecorder->close();
- mStfRecorder->reset();
}
extern "C" int LLVMFuzzerInitialize(int /* *argc */, char /* ***argv */) {
@@ -320,6 +404,7 @@
MediaPlayerService::instantiate();
AudioFlinger::instantiate();
ResourceManagerService::instantiate();
+ CameraService::instantiate();
fakeServiceManager->addService(String16(MediaMetricsService::kServiceName),
new MediaMetricsService());
return 0;