With the rapid development of the live streaming industry, users' demand for "appearance enhancement" in real-time videos is increasing day by day, and the beauty function has become one of the core competitiveness of live streaming platforms. However, developing a self-built beauty algorithm faces challenges such as high technical thresholds, long development cycles, and difficulty in ensuring effects. Third-party video beauty SDKs, with their mature technical solutions, rich functional modules, and low integration costs, have become the first choice for most developers. This article will break down the entire process of developing a real-time live streaming beauty platform using a third-party SDK, from requirement clarification to launch and iteration, helping developers efficiently build a stable, natural, and smooth beauty experience.

Step 1: Clarify Requirements – Define Beauty Functions and Technical Indicators

Basic Functional Requirements

Technical Indicator Requirements

• Real-time performance: Mobile live streaming must ensure a frame rate ≥ 25fps (the minimum standard for smooth human eye perception) and a delay ≤ 100ms (to avoid desynchronization between beauty effects and movements);
• Compatibility: Cover mainstream devices (iOS 11+, Android 8.0+, compatible with models from brands such as Huawei, Xiaomi, and OPPO);
• Stability: No crashes or freezes during 2 hours of continuous live streaming, and CPU usage ≤ 30% (to prevent device overheating).

User Experience Requirements

Step 2: Selection – How to Choose a Suitable Third-Party Video Beauty SDK

Core Evaluation Dimensions

• Function Completeness: Prioritize SDKs that cover the requirement list. For example, if "real-time body shaping" is needed, confirm whether the SDK supports body key point recognition and real-time deformation algorithms; if "3D stickers" are required, check whether it provides AR tracking technology.
• Performance: Focus on frame rate stability and resource usage on mobile devices. Request vendors to provide a test Demo and conduct actual tests on target devices (such as mid-to-low-end Android models): after enabling full beauty effects + special effects, check if the frame rate is ≥ 25fps, CPU usage ≤ 40%, and if the GPU avoids over-rendering (to prevent overheating).
• Compatibility Coverage: Confirm the SDK’s adaptation to mainstream devices, especially the fragmentation issue of Android models (such as adaptation differences between Huawei Kirin chips and Qualcomm Snapdragon chips) and the minimum iOS system version support requirement.
• Integration Cost: Evaluate the clarity of documents (whether API descriptions, integration tutorials, and FAQ are provided), the completeness of the Demo (whether it includes a complete live streaming + beauty process), and the response speed of technical support (whether one-on-one docking and timely problem-solving are available).
• Cost Model: Choose the authorization method based on the platform scale. For example, start-up platforms can choose "payment by device activation volume," while mature platforms can consider "customized solutions + annual authorization" to avoid cost out-of-control due to traffic growth.

Requirement Matching Suggestions

• If the platform is positioned as "lightweight live streaming," select a basic function SDK (e.g., only including skin smoothing, whitening, and stickers);
• If positioned as "professional makeup live streaming," integrate an SDK that supports "virtual makeup testing + real-time makeup effects";
• If targeting overseas markets, confirm whether the SDK supports multilingual documents and overseas server deployment.

Step 3: Development Preparation – Environment Setup and SDK Integration

Development Environment Preparation

• Toolchain: For mobile development, install Xcode (iOS) and Android Studio (Android); for the server side, prepare live streaming push/pull SDKs (e.g., supporting RTMP/RTSP protocols);
• Test Devices: Prepare test phones covering high, mid, and low-end models (e.g., iOS should include iPhone 8 and above, Android should include entry-level and flagship models from mainstream brands such as Huawei, Xiaomi, and vivo) to avoid compatibility issues caused by differences in device performance;
• Permission Configuration: Sort out necessary permissions in advance, such as camera, microphone, and storage (for loading local special effect resources), and add permission application logic in the code (e.g., dynamic permission application for Android, info.plist configuration for iOS).

SDK Integration Steps (Taking Mobile Terminals as Examples)

• iOS Integration: Download the SDK package (usually including .framework static libraries and resource files), import the SDK into the Xcode project, add dependent libraries (such as Accelerate.framework and Metal.framework; some SDKs rely on GPU acceleration) in Build Phases, and declare permission descriptions in Info.plist (e.g., "Need access to the camera to start live streaming");
• Android Integration: Download the SDK’s aar package or jar package, place resource files in the assets directory, add dependencies in build.gradle (e.g., implementation project(':xxx_sdk')), and declare permissions in AndroidManifest.xml (e.g., <uses-permission android:name="android.permission.CAMERA" />);
• Initialization Configuration: Call the SDK’s initialization interface, pass in the authorization key (needs to be applied for from the vendor) and device information (such as device model, system version); some SDKs require configuring log levels (for debugging convenience) and cache paths (for temporarily storing special effect resources).

Integration Notes

Step 4: Core Function Development – Beauty Effect Implementation and Parameter Tuning

Basic Beauty Function Development

• Initialize the Beauty Engine: When starting live streaming, call the SDK’s "create beauty engine" interface, passing in the video stream format (e.g., NV21/YUV420) and resolution (must be consistent with the push stream resolution to avoid image stretching);
• Enable Basic Beauty: Use APIs to set skin smoothing intensity (e.g., range 0-100, default 50), skin whitening degree (e.g., color temperature adjustment -100~100), and face slimming/eye enlargement parameters (e.g., intensity 0-80, to avoid "distortion" caused by excessive deformation). For example, Android can call setBeautyParam(BeautyType.SKIN_SMOOTH, 60) to enable moderate skin smoothing;
• Load Special Effect Resources: Special effects such as dynamic stickers and filters need to load resource packages (usually in .zip format, including model files and texture images) from local or the cloud. Pay attention to the size of resource packages (it is recommended that a single sticker does not exceed 5MB to avoid slow loading) and handle exceptions of resource loading failure (e.g., display default stickers or prompt "Resource loading in progress").

Key Points of Parameter Tuning

• Naturalness of Effects: Avoid loss of user facial details due to "excessive beauty." Use the "beauty style" interface provided by the SDK (e.g., "natural," "exquisite," "fresh") for quick adaptation, or manually adjust parameters (e.g., skin smoothing intensity ≤ 60, face slimming intensity ≤ 50);
• Performance Balance: Reduce the complexity of special effects for low-end devices (e.g., disable AR stickers and only retain basic skin smoothing); for high-end devices, enable "HD beauty + dynamic filters" and allow users to manually switch via the SDK’s "performance mode" interface (e.g., "power-saving mode," "HD mode");
• Real-Time Guarantee: Beauty processing must be completed before push streaming (i.e., the "local preview - beauty processing - encoding and push streaming" process) to avoid additional delays. If the SDK supports "hardware acceleration" (e.g., Metal for iOS, OpenGL ES for Android), enable this function to improve processing efficiency.

Step 5: Joint Debugging and Testing – Ensure Stable Functions and Smooth Experience

Core Testing Dimensions

• Functional Testing: Verify whether each beauty function works normally, such as whether the skin smoothing slider adjustment provides real-time feedback, whether stickers synchronize with facial movements, and whether filter switching is smooth without freezes;
• Performance Testing: Focus on monitoring frame rate (≥25fps for mobile terminals, ≥30fps for PC terminals), CPU/GPU usage (CPU usage ≤40% for Android terminals to avoid frequency reduction due to overheating), and memory leaks (whether memory growth exceeds 100MB during 1 hour of continuous live streaming);
• Compatibility Testing: Verify consistent function performance across all test devices (e.g., whether stickers are misaligned or filters are discolored on low-end devices) and coverage of system versions (iOS should test iOS 12 and above, Android should test Android 8.0 and above);
• Weak Network Testing: Simulate network fluctuation scenarios (e.g., 10% packet loss rate, 500kbps bandwidth), observe whether beauty effects freeze and whether the push stream image is delayed (delay ≤300ms to avoid "beauty effects lagging behind user expressions");
• User Experience Testing: Invite real users to experience and evaluate whether the beauty effects are natural (e.g., "Does it look like the user themselves?" "Is there a plastic look?") and whether operations are convenient (e.g., whether sticker switching is smooth, whether parameter adjustment is intuitive).

Priority of Issue Fixing

Step 6: Launch and Iteration – Continuously Optimize the Beauty Experience

Key Data Monitoring

• Function Usage Rate: Count the usage frequency of each beauty function (e.g., 80% usage rate for "skin smoothing," 30% for "body shaping"), and prioritize optimization of high-usage functions;
• User Feedback: Collect feedback through customer service systems and comment sections (e.g., "Hope to add a cool fair skin filter," "Face slimming effect is too fake"), and regularly sort out common needs;
• Performance Indicators: Monitor the frame rate compliance rate of online devices (e.g., whether the proportion of devices with ≥25fps is ≥90%) and crash rate (must be ≤0.1%) to identify optimization directions for low-performance devices.

Iteration Strategy Suggestions

• Resource Updates: Launch popular special effects regularly (e.g., holiday stickers, film IP co-branded filters) to maintain the platform’s freshness;
• Effect Optimization: Adjust default parameters based on user feedback (e.g., reduce the skin smoothing intensity of "natural beauty" from 50 to 40) or add new "beauty templates" (e.g., "natural makeup," "influencer makeup");
• Technical Upgrades: Keep up with version updates of SDK vendors, promptly integrate new functions (e.g., "AI intelligent beauty," "background blurring"), or develop customized differentiated functions (e.g., "virtual background replacement").

Conclusion