@byteplus/react-native-rtc 1.1.1-rc.3 → 1.1.1-rc.5

package/android/build.gradle

@@ -83,7 +83,7 @@ android {
     minSdkVersion getExtOrIntegerDefault("minSdkVersion")
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
 
-    consumerProguardFiles 'proguard-rules.pro' 
+    consumerProguardFiles 'proguard-rules.pro'
   }
 
   buildTypes {
@@ -108,15 +108,15 @@ if (enableUnionForRTCWithLive) {
   android.sourceSets.main.java.srcDirs += 'src/live/java'
   dependencies {
     implementation project(':byteplus_react-native-live-push')
-    implementation "com.bytedanceapi:ttsdk-player_$license_type:1.46.300.2"
+    implementation "com.bytedanceapi:ttsdk-player_$license_type:1.46.300.3-test1"
   }
 }
 
 if (enableUnionForRTCWithVod) {
   android.sourceSets.main.java.srcDirs += 'src/vod/java'
-  // 
+  //
   // Might cause rtc api some error, just alpha version.
-  // 
+  //
   apiVolcEngineVersion = '1.5.0'
   dependencies {
     implementation "com.bytedanceapi:ttsdk-player_$license_type:1.46.300.2"
@@ -133,4 +133,4 @@ dependencies {
 
   // Use the RTC SDK dependency determined by getNativeDep() which can be overridden by customer's app build.gradle.
   implementation isBp ? "com.byteplus:BytePlusRTC:$rtcVersionToUse" : "com.volcengine:VolcEngineRTC:$rtcVersionToUse"
-}
+}

package/android/proguard-rules.pro

@@ -1,4 +1,4 @@
-# Add project specific ProGuard rules here.
+ # Add project specific ProGuard rules here.
 # By default, the flags in this file are appended to flags specified
 # in /usr/local/Cellar/android-sdk/24.3.3/tools/proguard/proguard-android.txt
 # You can edit the include path and order by changing the proguardFiles

package/android/src/live/java/com/volcengine/reactnative/vertc/live/VertcLive.java

@@ -5,6 +5,7 @@ package com.volcengine.reactnative.vertc.live;
 
 import android.util.Log;
 
+import com.pandora.common.applog.AppLogWrapper;
 import com.ss.avframework.live.VeLivePusherDef;
 import com.ss.avframework.live.VeLiveVideoFrame;
 import com.ss.avframework.opengl.RendererCommon;
@@ -18,6 +19,10 @@ import com.ss.bytertc.engine.data.VideoSourceType;
 import java.util.concurrent.TimeUnit;
 import com.ss.bytertc.engine.video.builder.GLTextureVideoFrameBuilder;
 import com.volcengine.velive.rn.push.VeLivePushHelper;
+import com.ss.avframework.live.filter.video.effect.CVEffectManager;
+
+import org.json.JSONException;
+import org.json.JSONObject;
 
 import javax.annotation.Nonnull;
 
@@ -29,6 +34,30 @@ public class VertcLive {
   private org.json.JSONObject mOptions;
   private RTCVideo mEngine;
 
+  // 新增：VeLivePusherStatistics转字符串辅助方法
+  private String statisticsToString(VeLivePusherDef.VeLivePusherStatistics stats) {
+    if (stats == null) return "null";
+    return new StringBuilder()
+            .append("VeLivePusherStatistics{")
+            .append("url='").append(stats.url).append('\'')
+            .append(", encodeWidth=").append(stats.encodeWidth)
+            .append(", encodeHeight=").append(stats.encodeHeight)
+            .append(", captureWidth=").append(stats.captureWidth)
+            .append(", captureHeight=").append(stats.captureHeight)
+            .append(", captureFps=").append(stats.captureFps)
+            .append(", encodeFps=").append(stats.encodeFps)
+            .append(", transportFps=").append(stats.transportFps)
+            .append(", fps=").append(stats.fps)
+            .append(", videoBitrate=").append(stats.videoBitrate)
+            .append(", minVideoBitrate=").append(stats.minVideoBitrate)
+            .append(", maxVideoBitrate=").append(stats.maxVideoBitrate)
+            .append(", encodeVideoBitrate=").append(stats.encodeVideoBitrate)
+            .append(", transportVideoBitrate=").append(stats.transportVideoBitrate)
+            .append(", encodeAudioBitrate=").append(stats.encodeAudioBitrate)
+            .append(", codec=").append(stats.codec)
+            .append('}').toString();
+  }
+
   /**
    * @brief Start to capture live stream.
    */
@@ -43,7 +72,30 @@ public class VertcLive {
       if (mLivePusher == null) {
         throw new RuntimeException("[Unknown LivePusher] can't find pusher instance by view id.");
       }
-      
+
+      mLivePusher.setStatisticsObserver(new VeLivePusherDef.VeLivePusherStatisticsObserver() {
+        @Override
+        public void onStatistics(VeLivePusherDef.VeLivePusherStatistics statistics) {
+          String staticLog = statisticsToString(statistics);
+          JSONObject json = new JSONObject();
+            try {
+                JSONObject jsonObject = new JSONObject();
+                jsonObject.put("staticLog",staticLog);
+                json.put("event_key", "livcore_statistics").put("message", jsonObject.toString()).put("effectcost", CVEffectManager.cvCostdurationMs+"ms");
+                Log.d("flexttv>>>>> ", json.toString());
+            } catch (JSONException e) {
+                throw new RuntimeException(e);
+            }
+          AppLogWrapper.onEventV3("live_client_monitor_log",json);
+        }
+
+        @Override
+        public void onLogMonitor(JSONObject logInfo) {
+          VeLivePusherDef.VeLivePusherStatisticsObserver.super.onLogMonitor(logInfo);
+        }
+      }, 2);
+
+
       // set video source as external
       engine.setVideoSourceType(getStreamIndex(), VideoSourceType.VIDEO_SOURCE_TYPE_EXTERNAL);
       // set video frame listener
@@ -53,12 +105,29 @@ public class VertcLive {
         public VeLivePusherDef.VeLiveVideoFrameSource getObservedVideoFrameSource() {
           return new VeLivePusherDef.VeLiveVideoFrameSource(VeLivePusherDef.VeLiveVideoFrameSource.VeLiveVideoFrameSourcePreEncode);
         }
-
+        private static final long INTERVAL_MS = 1000; // 计算间隔为1秒
+        private long lastTime = 0;
+        private int frameCount = 0;
         @Override
         public void onPreEncodeVideoFrame(VeLiveVideoFrame frame) {
           int ret_status = -1;
           StreamIndex streamIndex = getStreamIndex();
 
+          long currentTime = System.currentTimeMillis();
+          frameCount++;
+
+          if (lastTime == 0) {
+            lastTime = currentTime;
+          }
+
+          if (currentTime - lastTime >= INTERVAL_MS) {
+            int fps = frameCount;
+            Log.d("flexttv>>>>> FrameRateCalculator", "当前帧率: " + fps + " FPS");
+            frameCount = 0;
+            lastTime = currentTime;
+          }
+
+
           float[] mMVPMatrix = RendererCommon.convertMatrixFromAndroidGraphicsMatrix(frame.getTextureMatrix());
           GLTextureVideoFrameBuilder builder = new GLTextureVideoFrameBuilder(
             frame.isOesTextureFrame() ? VideoPixelFormat.TEXTURE_OES : VideoPixelFormat.TEXTURE_2D
@@ -70,7 +139,7 @@ public class VertcLive {
             .setTextureMatrix(mMVPMatrix)
             .setEGLContext(VeLivePusher.getEGLContext())
             .setTimeStampUs(System.currentTimeMillis() * TimeUnit.MILLISECONDS.toNanos(1));
-          
+
           if (streamIndex == StreamIndex.STREAM_INDEX_MAIN) {
             ret_status = engine.pushExternalVideoFrame(builder.build());
           }
@@ -85,7 +154,7 @@ public class VertcLive {
         }
       };
       mLivePusher.addVideoFrameListener(mListener);
-      
+
       return 0;
     } catch (Exception err) {
       Log.d(TAG, "startLiveVideoCapture failed:" + err.getMessage());
@@ -122,17 +191,17 @@ public class VertcLive {
     }
   }
 
-  
+
   // Get VeLivePusher from Object
   private VeLivePusher getVeLivePusher(String pusherViewId) {
-    
+
     if (VeLivePushHelper.getPusher(pusherViewId) != null) {
       return VeLivePushHelper.getPusher(pusherViewId);
     }
-    
+
     return null;
   }
-  
+
   // Get StreamIndex from options
   private StreamIndex getStreamIndex() {
     Number index = mOptions.optInt("streamIndex", StreamIndex.STREAM_INDEX_MAIN.value());

package/ios/core/VertcHelper.h

@@ -7,7 +7,7 @@
 
 #import "RTCHeader.h"
 
-
+NS_ASSUME_NONNULL_BEGIN
 @interface VertcHelper : NSObject
 
 + (instancetype) getInstance;
@@ -19,5 +19,11 @@
                     error:(NSInteger)errorCode;
 
 - (int) invokeStartPushSingleStreamToCDN:(ByteRTCVideo *)rtc taskId:(NSString *_Nonnull)taskID singleStream:(ByteRTCPushSingleStreamParam *_Nonnull)singleStream;
-
-@end
+- (void)schedualTimerWithIdentifier:(NSString *)name
+                           interval:(NSTimeInterval)interval
+                              queue:(dispatch_queue_t)queue
+                            repeats:(BOOL)repeats
+                             action:(dispatch_block_t)action;
+- (void)cancelTimerWithName:(NSString *)name;
+@end
+NS_ASSUME_NONNULL_END

package/ios/core/VertcHelper.m

@@ -9,7 +9,10 @@
 #import "RTCHeader.h"
 #import <VertcHelper.h>
 
-
+@interface VertcHelper ()
+@property (nonatomic, strong) NSMutableDictionary *timerList;
+@property (nonatomic, strong) NSRecursiveLock *lock;
+@end
 #pragma mark - Helper
 @implementation VertcHelper
 
@@ -22,6 +25,14 @@
     return instance;
 }
 
+- (instancetype)init {
+    if (self = [super init]) {
+        self.timerList = [NSMutableDictionary dictionary];
+        self.lock = [[NSRecursiveLock alloc] init];
+    }
+    return self;
+}
+
 + (bool)isUnionLiveModeEnable {
     #ifdef ENABLE_UNION_FOR_RTC_WITH_LIVE
     return true;
@@ -46,4 +57,59 @@
     return res;
 }
 
+- (void)schedualTimerWithIdentifier:(NSString *)name
+                           interval:(NSTimeInterval)interval
+                              queue:(dispatch_queue_t)queue
+                            repeats:(BOOL)repeats
+                             action:(dispatch_block_t)action {
+    if (!name || name.length == 0 || !action) {
+        return;
+    }
+    [_lock lock];
+    if (!queue) {
+        queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+    }
+    
+    dispatch_source_t timer = [self.timerList objectForKey:name];
+    if (!timer) {
+        timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
+        dispatch_resume(timer);
+        [self.timerList setValue:timer forKey:name];
+    }
+    
+    dispatch_source_set_timer(timer, dispatch_time(DISPATCH_TIME_NOW, interval * NSEC_PER_SEC), interval * NSEC_PER_SEC, 0.01 * NSEC_PER_SEC);
+    __weak __typeof(self)weakSelf = self;
+    dispatch_source_set_event_handler(timer, ^{
+        action();
+        __strong __typeof(weakSelf)self = weakSelf;
+        if (!repeats) {
+            [self cancelTimerWithName:name];
+        }
+    });
+    [_lock unlock];
+}
+
+- (void)cancelTimerWithName:(NSString *)name {
+    [_lock lock];
+    if (name == nil) {
+        [_lock unlock];
+        return;
+    }
+    dispatch_source_t timer = [self.timerList objectForKey:name];
+    if (timer) {
+        [self.timerList removeObjectForKey:name];
+        dispatch_source_cancel(timer);
+    }
+    [_lock unlock];
+}
+
+- (void)cancelAllTimers {
+    [_lock lock];
+    for (dispatch_source_t timer in self.timerList) {
+        dispatch_source_cancel(timer);
+    }
+    [self.timerList removeAllObjects];
+    [_lock unlock];
+}
 @end
+

package/ios/live/VertcLive.m

@@ -6,16 +6,24 @@
 #import <TTSDKFramework/TTSDKFramework.h>
 #import <TTSDKFramework/VeLivePusherDef.h>
 #import "VeLivePushHelper.h"
+#import "VertcHelper.h"
 
-
+@interface VeLiveFpsTracker : NSObject
+- (void)start;
+- (void)stop;
+- (void)updateCaptureVieoWidth:(int)width height:(int)height;
+- (void)updatePreEncodeVieoWidth:(int)width height:(int)height;
+- (void)updateCaptureFrame:(NSInteger)frameCount;
+- (void)updatePreEncodeFrame:(NSInteger)frameCount;
+- (void)updateAfterRTCFrame:(NSInteger)frameCount;
+@end
 
 @interface VertcLive ()
-
 @property (nonatomic, strong) NSDictionary *options;
 @property (nonatomic, strong) ByteRTCVideo *rtcEngine;
 @property (nonatomic, strong) VeLivePusher *livePusher;
 @property (nonatomic, strong) id<VeLiveVideoFrameListener> videoFrameListener;
-
+@property (nonatomic, strong) VeLiveFpsTracker *fpsTracker;
 @end
 
 @implementation VertcLive
@@ -27,6 +35,8 @@
     self.livePusher = nil;
     self.rtcEngine = nil;
     self.options = nil;
+    [self.fpsTracker stop];
+    self.fpsTracker = nil;
 }
 
 - (int)startLiveVideoCapture:(ByteRTCVideo *)rtc viewId:(NSString *)viewId options:(NSDictionary *)options {
@@ -35,6 +45,11 @@
     if (pusher == nil) {
         @throw [NSException exceptionWithName:@"unknown videoEngine" reason:@"can't get pusher" userInfo:@{}];
     }
+    if (self.fpsTracker != nil) {
+        [self.fpsTracker stop];
+    } else {
+        self.fpsTracker = [[VeLiveFpsTracker alloc] init];
+    }
     self.rtcEngine = rtc;
     self.options = options;
     self.livePusher = pusher;
@@ -42,15 +57,16 @@
     NSInteger streamIndexValue = [options[@"streamIndex"] integerValue] ?: 0;
     ByteRTCStreamIndex streamIndex = (streamIndexValue == 1) ? ByteRTCStreamIndexScreen : ByteRTCStreamIndexMain;
     [rtc setVideoSourceType:ByteRTCVideoSourceTypeExternal WithStreamIndex:streamIndex];
-
+    
+    [self.fpsTracker start];
     int addRes = [self.livePusher addVideoFrameListener:self];
     NSLog(@"addVideoFrameListener result: %d", addRes);
-
     return 0;
 }
 
 - (int)stopLiveVideoCapture {
     if (self.rtcEngine == nil || self.livePusher == nil) {
+        [self.fpsTracker stop];
         return 0;
     }
     if (self.livePusher && self.videoFrameListener) {
@@ -66,11 +82,12 @@
     self.options = nil;
     self.rtcEngine = nil;
     self.livePusher = nil;
+    [self.fpsTracker stop];
     return 0;
 }
 
 - (VeLiveVideoFrameSource)getObservedVideoFrameSource {
-    return VeLiveVideoFrameSourcePreEncode;
+    return VeLiveVideoFrameSourceCapture | VeLiveVideoFrameSourcePreEncode;
 }
 
 - (ByteRTCVideoPixelFormat)convertToRtcPixelFormat:(VeLivePixelFormat)format {
@@ -85,11 +102,16 @@
     return ByteRTCVideoPixelFormatUnknown;
 }
 
+- (void)onCaptureVideoFrame:(VeLiveVideoFrame *)frame {
+    [self.fpsTracker updateCaptureFrame:1];
+    [self.fpsTracker updateCaptureVieoWidth:frame.width height:frame.height];
+}
+
 - (void)onPreEncodeVideoFrame:(VeLiveVideoFrame *)frame {
-    
+    [self.fpsTracker updatePreEncodeFrame:1];
+    [self.fpsTracker updatePreEncodeVieoWidth:frame.width height:frame.height];
     NSInteger streamIndexValue = [self.options[@"streamIndex"] integerValue] ?: 0;
     ByteRTCStreamIndex streamIndex = (streamIndexValue == 1) ? ByteRTCStreamIndexScreen : ByteRTCStreamIndexMain;
-    
     int res = 0;
     if (streamIndex == ByteRTCStreamIndexMain) {
         ByteRTCVideoPixelFormat pixelFormat = [self convertToRtcPixelFormat:frame.pixelFormat];
@@ -112,9 +134,12 @@
         }
         
         res = [self.rtcEngine pushExternalVideoFrame: videoFrame];
+        
+        [self.fpsTracker updateAfterRTCFrame:1];
     }
     if (streamIndex == ByteRTCStreamIndexScreen) {
         res = [self.rtcEngine pushScreenVideoFrame:frame.pixelBuffer time:frame.pts rotation:frame.rotation];
+        [self.fpsTracker updateAfterRTCFrame:1];
     }
     if (res != 0 && res != -202) {
         NSLog(@"bytertc push video frame fail return '%d'", res);
@@ -122,3 +147,134 @@
 }
 
 @end
+
+@protocol VeLiveTrackerProtocol <NSObject>
++ (void)sendPusherEventWith:(NSString *)eventKey api:(nullable NSString *)api value:(nullable id)value result:(nullable id)result;
+@end
+
+@interface VeLiveFpsTracker ()
+@property (nonatomic, strong) Class <VeLiveTrackerProtocol> trackerCls;
+@property (nonatomic, assign) NSTimeInterval lastTimestamp;
+@property (nonatomic, assign) NSInteger captureFrameCount;
+@property (nonatomic, assign) NSInteger preEncodeFrameCount;
+@property (nonatomic, assign) NSInteger afterRtcFrameCount;
+@property (nonatomic, strong) dispatch_queue_t queue;
+@property (nonatomic, copy) NSString *timerName;
+@property (nonatomic, assign) CGSize captureSize;
+@property (nonatomic, assign) CGSize preEncodeSize;
+@end
+
+@implementation VeLiveFpsTracker
+- (instancetype)init {
+    if (self = [super init]) {
+        _timerName = @"VeLiveFpsTracker";
+        _trackerCls = NSClassFromString(@"VeLiveTracker");
+        _queue = dispatch_queue_create("VeLiveFpsTracker-Queue", DISPATCH_QUEUE_SERIAL);
+    }
+    return self;
+}
+
+- (void)start {
+    [self clearFrameRecordAsync:NSDate.date.timeIntervalSince1970 * 1000];
+    __weak __typeof(self)weakSelf = self;
+    [[VertcHelper getInstance] schedualTimerWithIdentifier:self.timerName
+                                                  interval:2
+                                                     queue:self.queue
+                                                   repeats:YES
+                                                    action:^{
+        __strong __typeof(weakSelf)self = weakSelf;
+        [self reportIfNeed];
+    }];
+}
+
+- (void)stop {
+    [[VertcHelper getInstance] cancelTimerWithName:_timerName];
+    [self clearFrameRecordAsync:0];
+}
+
+- (void)clearFrameRecordAsync:(NSTimeInterval)timestamp {
+    __weak __typeof(self)weakSelf = self;
+    dispatch_async(self.queue, ^{
+        __strong __typeof(weakSelf)self = weakSelf;
+        [self clearFrameRecord:timestamp];
+    });
+}
+
+- (void)clearFrameRecord:(NSTimeInterval)timestamp {
+    self.lastTimestamp = timestamp;
+    self.captureFrameCount = 0;
+    self.preEncodeFrameCount = 0;
+    self.afterRtcFrameCount = 0;
+    self.captureSize = CGSizeZero;
+    self.preEncodeSize = CGSizeZero;
+}
+
+- (void)updateCaptureFrame:(NSInteger)frameCount {
+    __weak __typeof(self)weakSelf = self;
+    dispatch_async(self.queue, ^{
+        __strong __typeof(weakSelf)self = weakSelf;
+        self.captureFrameCount += frameCount;
+    });
+}
+
+- (void)updatePreEncodeFrame:(NSInteger)frameCount {
+    __weak __typeof(self)weakSelf = self;
+    dispatch_async(self.queue, ^{
+        __strong __typeof(weakSelf)self = weakSelf;
+        self.preEncodeFrameCount += frameCount;
+    });
+}
+
+- (void)updateAfterRTCFrame:(NSInteger)frameCount {
+    __weak __typeof(self)weakSelf = self;
+    dispatch_async(self.queue, ^{
+        __strong __typeof(weakSelf)self = weakSelf;
+        self.afterRtcFrameCount += frameCount;
+    });
+}
+
+- (void)updateCaptureVieoWidth:(int)width height:(int)height {
+    __weak __typeof(self)weakSelf = self;
+    dispatch_async(self.queue, ^{
+        __strong __typeof(weakSelf)self = weakSelf;
+        self.captureSize = CGSizeMake((CGFloat)width, (CGFloat)height);
+    });
+}
+
+- (void)updatePreEncodeVieoWidth:(int)width height:(int)height {
+    __weak __typeof(self)weakSelf = self;
+    dispatch_async(self.queue, ^{
+        __strong __typeof(weakSelf)self = weakSelf;
+        self.preEncodeSize = CGSizeMake((CGFloat)width, (CGFloat)height);
+    });
+}
+
+- (void)reportIfNeed {
+    NSTimeInterval currentTime = NSDate.date.timeIntervalSince1970 * 1000;
+    NSTimeInterval duration = MAX(1, currentTime - self.lastTimestamp);
+    
+    int captureFps = (int)((self.captureFrameCount * 1000.0) / duration);
+    int preEncodeFps = (int)((self.preEncodeFrameCount * 1000.0) / duration);
+    int afterRtcFps = (int)((self.afterRtcFrameCount * 1000.0) / duration);
+    
+    [self reportEvent:@"livcore_statistics_fps" value:@{
+        @"captureFps" : @(captureFps),
+        @"preEncodeFps" : @(preEncodeFps),
+        @"afterRtcFps" : @(afterRtcFps),
+        @"captureSize" : NSStringFromCGSize(self.captureSize),
+        @"preEncodeSize" : NSStringFromCGSize(self.preEncodeSize),
+    }];
+    [self clearFrameRecord:currentTime];
+}
+
+- (void)reportEvent:(NSString *)key value:(NSDictionary *)value {
+    if (self.trackerCls != nil
+        && [self.trackerCls respondsToSelector:@selector(sendPusherEventWith:api:value:result:)]) {
+        [self.trackerCls sendPusherEventWith:key api:@"" value:value result:@""];
+    }
+#if DEBUG
+    NSLog(@"report: %@ %@", key, value);
+#endif
+}
+
+@end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byteplus/react-native-rtc",
-  "version": "1.1.1-rc.3",
+  "version": "1.1.1-rc.5",
   "peerDependencies": {
     "react": "*",
     "react-native": "*"

package/react-native-rtc.podspec

@@ -33,8 +33,8 @@ Pod::Spec.new do |s|
     'ENABLE_UNION_FOR_RTC_WITH_LIVE' => '$(ENABLE_UNION_FOR_RTC_WITH_LIVE)',
     'ENABLE_UNION_FOR_RTC_WITH_VOD' => '$(ENABLE_UNION_FOR_RTC_WITH_VOD)',
     'UNION_FOR_RTC_WITH_LIVE_VERSION' => '$(UNION_FOR_RTC_WITH_LIVE_VERSION)',
-    'UNION_FOR_RTC_WITH_VOD_VERSION' => '$(UNION_FOR_RTC_WITH_VOD_VERSION)'
-    'VOLC_API_ENGINE_VERSION_FOR_RTC' => '$(VOLC_API_ENGINE_VERSION_FOR_RTC)' 
+    'UNION_FOR_RTC_WITH_VOD_VERSION' => '$(UNION_FOR_RTC_WITH_VOD_VERSION)',
+    'VOLC_API_ENGINE_VERSION_FOR_RTC' => '$(VOLC_API_ENGINE_VERSION_FOR_RTC)'
   }
 
   s.default_subspec = 'Core'