@byteplus/react-native-rtc 1.0.0 → 1.0.2

package/android/build.gradle

@@ -128,8 +128,8 @@ dependencies {
 
 //  def dep = getNativeDep()
 //  implementation "$dep"
-  implementation "com.byteplus:BytePlusRTC:3.58.1.15100"
   // implementation "com.volcengine:VolcEngineRTC:3.58.1.2700"
+  implementation "com.byteplus:BytePlusRTC:3.58.1.15100"
 
   // TTVideoEngine
   // byteplus and volcengine use different name, different version

package/android/src/main/java/com/volcengine/reactnative/vertc/vod/VertcVod.java

@@ -21,11 +21,9 @@ public class VertcVod {
   private String TAG = "VertcVod";
 
   private TTVideoEngine mVideoEngine;
-  private org.json.JSONObject mOptions;
   
   private int mVideoWidth = 1080;
   private int mVideoHeight = 1920;
-  private VodVideoEngineCallbackProxy mVodVideoEngineCallbackProxy;
   private OESTextureProcessor mOESTextureProcessor;
   private VideoAudioProcessor mVAProcessor;
   private final OESTextureProcessor.IProcessorCallback mProcessorCallback = new OESTextureProcessor.IProcessorCallback() {
@@ -51,20 +49,16 @@ public class VertcVod {
     }
   };
 
-  public int startVodPlayerCapture(RTCVideo engine, Object ttplayer, org.json.JSONObject options) {
+  public int startVodPlayerCapture(RTCVideo engine, Object arg, StreamIndex streamIndex) {
     try {
-      stopVodPlayerCapture(engine);
-
-      mVideoEngine = getTTVideoEngine(ttplayer);
+      mVideoEngine = getTTVideoEngine(arg);
       if (mVideoEngine == null) {
         throw new RuntimeException("unknown VideoEngine");
       }
-      
-      mOptions = options;
-      mVAProcessor = new VideoAudioProcessor(engine, options);
+      stopVodPlayerCapture(engine);
 
-      // process TTVideoEngine video
-      VideoEngineCallback mVideoEngineCallback = new VideoEngineCallback() {
+      mVAProcessor = new VideoAudioProcessor(engine);
+      var mVideoEngineCallback = new VideoEngineCallback() {
         @Override
         public void onRenderStart(TTVideoEngine engine) {
           final int videoWidth = engine.getVideoWidth();
@@ -81,45 +75,35 @@ public class VertcVod {
           mOESTextureProcessor.initSurfaceTexture(videoWidth, videoHeight, mProcessorCallback);
         }
       };
-      mVodVideoEngineCallbackProxy = new VodVideoEngineCallbackProxy(mVideoEngine, mVideoEngineCallback);
-      mVideoEngine.setVideoEngineCallback(mVodVideoEngineCallbackProxy.listen());
-      // process TTVideoEngine audio
+      mVideoEngine.configResolution(Resolution.High);
+      mVideoEngine.setVideoEngineCallback(mVideoEngineCallback);
       mVideoEngine.setAudioProcessor(mVAProcessor);
       mVideoEngine.setIntOption(TTVideoEngine.PLAYER_OPTION_SET_VOICE, TTVideoEngine.VOICE_DUMMY);
       mVideoEngine.setIntOption(TTVideoEngine.PLAYER_OPTION_DUMMY_AUDIO_SLEEP, 0);
 
-      // set sourceType to External
       engine.setScreenAudioSourceType(AudioSourceType.AUDIO_SOURCE_TYPE_EXTERNAL);
       engine.setVideoSourceType(StreamIndex.STREAM_INDEX_SCREEN, VideoSourceType.VIDEO_SOURCE_TYPE_EXTERNAL);
-
+//
       OESTextureProcessor textureProcessor = mOESTextureProcessor;
       if (textureProcessor != null) {
         textureProcessor.destroy();
       }
       mOESTextureProcessor = new OESTextureProcessor();
-      mOESTextureProcessor.initSurfaceTexture(mVideoWidth, mVideoHeight, mProcessorCallback);
+      mOESTextureProcessor.initSurfaceTexture(1080, 1920, mProcessorCallback);
       
       return 0;
     } catch (Exception err) {
-      Log.d(TAG, "startVodPlayerCapture fail:" + err.getMessage());
+      Log.d(TAG, "error:" + err.getMessage());
       throw new RuntimeException(err);
     }
   }
 
   public int stopVodPlayerCapture(RTCVideo engine) {
-    // reset sourceType to Internal
     engine.setVideoSourceType(StreamIndex.STREAM_INDEX_SCREEN, VideoSourceType.VIDEO_SOURCE_TYPE_INTERNAL);
-    engine.setScreenAudioSourceType(AudioSourceType.AUDIO_SOURCE_TYPE_INTERNAL);
-    mOptions = null;
-    if (mVodVideoEngineCallbackProxy != null) {
-      mVodVideoEngineCallbackProxy.reset(mVideoEngine);
-      mVodVideoEngineCallbackProxy = null;
-    }
     if (mVideoEngine != null) {
       mVideoEngine.setSurfaceHolder(null);
       mVideoEngine.setAudioProcessor(null);
       mVideoEngine.setVideoEngineCallback(null);
-      mVideoEngine = null;
     }
     if (mOESTextureProcessor != null) {
       mOESTextureProcessor.destroy();

package/android/src/main/java/com/volcengine/reactnative/vertc/vod/VideoAudioProcessor.java

@@ -20,16 +20,14 @@ import java.nio.ByteBuffer;
 import java.util.concurrent.TimeUnit;
 
 public class VideoAudioProcessor extends AudioProcessor {
-    public String TAG = "VideoAudioProcessor";
-
-    private org.json.JSONObject mOptions;
-    private final VodAudioProcessor processor;
+  public String TAG = "VideoAudioProcessor";
+  
+  private final VodAudioProcessor processor;
     private final RTCVideo mRTCEngine;
-    
-    public VideoAudioProcessor(RTCVideo engine, org.json.JSONObject options) {
+
+    public VideoAudioProcessor(RTCVideo engine) {
         processor = new VodAudioProcessor(engine);
         mRTCEngine = engine;  
-        mOptions = options;
     }
    
     public void updateScreenConfig(int width, int height) {
@@ -40,6 +38,7 @@ public class VideoAudioProcessor extends AudioProcessor {
         videoEncoderConfig.height = height;
         videoEncoderConfig.encodePreference = ScreenVideoEncoderConfig.EncoderPreference.MaintainFramerate;
         mRTCEngine.setScreenVideoEncoderConfig(videoEncoderConfig);
+//        mRTCEngine.publishScreen(RTCEngine.MediaStreamType.RTC_MEDIA_STREAM_TYPE_BOTH);
     }
 
     @Override
@@ -63,14 +62,14 @@ public class VideoAudioProcessor extends AudioProcessor {
     }
 
     public void onFrameAvailable(EGLContext eglContext, int oesTextureId, float[] transformMatrix, int width, int height) {
-     long timeStampUs = System.currentTimeMillis() * TimeUnit.MILLISECONDS.toNanos(1);
+     long nanoTime = System.currentTimeMillis() * TimeUnit.MILLISECONDS.toNanos(1);
      GLTextureVideoFrameBuilder builder = new GLTextureVideoFrameBuilder(VideoPixelFormat.TEXTURE_OES)
        .setTextureID(oesTextureId)
        .setWidth(width)
        .setHeight(height)
        .setRotation(VideoRotation.VIDEO_ROTATION_0)
        .setTextureMatrix(transformMatrix)
-       .setTimeStampUs(timeStampUs)
+       .setTimeStampUs(nanoTime)
        .setColorSpace(ColorSpace.UNKNOWN)
        .setEGLContext(eglContext);
      int ret_status = mRTCEngine.pushScreenVideoFrame(builder.build());

package/android/src/main/java/com/volcengine/reactnative/vertc/vod/VodAudioProxy.java

@@ -0,0 +1,44 @@
+// Copyright © 2022 BytePlusRTC All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package com.volcengine.reactnative.vertc.vod;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.ss.bytertc.engine.RTCVideo;
+import com.ss.bytertc.engine.data.AudioSourceType;
+import com.ss.ttm.player.TraitObject;
+import com.ss.ttvideoengine.TTVideoEngine;
+
+public class VodAudioProxy {
+  private String TAG = "VodAudioProxy";
+
+  private TTVideoEngine mVideoEngine;
+  private RTCVideo mRTCVideo;
+
+  public void initEngine(TTVideoEngine videoEngine, RTCVideo rtcEngine, ReactApplicationContext reactApplicationContext) {
+    mVideoEngine = videoEngine;
+    mRTCVideo = rtcEngine;
+    rtcEngine.setScreenAudioSourceType(AudioSourceType.AUDIO_SOURCE_TYPE_EXTERNAL);
+
+//    var mVAProcessor = new 
+//    mVideoEngine.setAudioProcessor(mVAProcessor);
+    
+//    TraitObject traitObj = new VodAudioVoiceWrapperObject(reactApplicationContext.getApplicationContext(), rtcEngine);
+//    mVideoEngine.setIntOption(TTVideoEngine.PLAYER_OPTION_SET_VOICE, TTVideoEngine.VOICE_EXTERN);
+//    mVideoEngine.setTraitObject(TraitObject.ExtVoice, traitObj);
+
+//    mVideoEngine.setIntOption(TTVideoEngine.PLAYER_OPTION_EXTERN_VOICE_OUTPUT_FORMAT, VoiceTrait.AV_PCM_FMT_S16);
+
+//    mVideoEngine.setIntOption(TTVideoEngine.PLAYER_OPTION_SET_VOICE, TTVideoEngine.VOICE_DUMMY);
+//    mVideoEngine.setIntOption(TTVideoEngine.PLAYER_OPTION_DUMMY_AUDIO_SLEEP, 0);
+  }
+  
+  public void release() {
+    if (mVideoEngine != null) {
+      mVideoEngine = null;
+    }
+    if (mRTCVideo != null) {
+      mRTCVideo = null;
+    }
+  }
+}

package/android/src/main/java/com/volcengine/reactnative/vertc/vod/VodAudioVoiceWrapperObject.java

@@ -0,0 +1,355 @@
+// Copyright © 2022 BytePlusRTC All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package com.volcengine.reactnative.vertc.vod;
+
+import android.app.Service;
+import android.content.Context;
+import android.media.AudioFormat;
+import android.media.AudioManager;
+import android.media.AudioTrack;
+import android.os.Build;
+import android.util.Log;
+
+import com.ss.bytertc.engine.RTCVideo;
+import com.ss.bytertc.engine.data.AudioChannel;
+import com.ss.bytertc.engine.data.AudioSampleRate;
+import com.ss.bytertc.engine.utils.AudioFrame;
+import com.ss.ttm.player.TraitObject;
+import com.ss.ttm.player.VoiceTrait;
+
+import java.lang.reflect.Method;
+import java.nio.ByteBuffer;
+
+public class VodAudioVoiceWrapperObject extends VoiceTrait {
+    private String TAG = "VodAudioVoiceWrapperObject";
+    private VodAudioProcessor mAudioProcessor;
+    
+    private final static int kNoSettingVolume = -1;
+    private Context mContext = null;
+    private AudioManager mAudioManager = null;
+    private AudioTrack mAudioTrack = null;
+    private Method getLatencyMethod = null;
+    private float mLeftVolume = kNoSettingVolume;
+    private int mMaxVolume = 0;
+    private volatile boolean mStoped = true;
+    private int mChannels = 0;
+    private int mSampleBytes = 2;
+    private int mSampleRate = 0;
+    private int mFrameSampleNB = 0;
+    private int mBytePerSample = 0;
+    private int mFormat = -1;
+    private boolean mIsPacked = false;
+    private int mTrackBufferSize = 0;
+    private int mSessionId = -1;
+    private int mStreamType = AudioManager.STREAM_MUSIC;
+    private int mChannelsLayout = AudioFormat.CHANNEL_INVALID;
+    private int mAudioFormat = AudioFormat.ENCODING_PCM_16BIT;
+    private RTCVideo mRTCVideo;
+    
+    public VodAudioVoiceWrapperObject() {
+        super(TraitObject.ExtVoice, VoiceTrait.Version0, 0);
+    
+    }
+    public VodAudioVoiceWrapperObject(Context context, RTCVideo rtcVideo) {
+        this();
+        mContext = context;
+        mRTCVideo = rtcVideo;   
+        mAudioProcessor = new VodAudioProcessor(rtcVideo);
+    }
+
+    public int audioOpen(AudioMediaInfo info) {
+      if (info == null) {
+        return -1;
+      }
+      
+      mAudioProcessor.audioOpen(info.mSampleRate, info.mChannels);
+      
+        mChannels = info.mChannels;
+        mSampleRate = info.mSampleRate;
+        mFrameSampleNB = info.mFrameSampleNB;
+        mBytePerSample = info.mBytePerSample;
+        mFormat = info.mFormat;
+        mIsPacked = info.mIsPacked == 1;
+//        ret = reconfigure();
+//        if (ret == -1) {
+//            return -1;
+//        }
+//        if(mLeftVolume == kNoSettingVolume) {
+//            mLeftVolume = mMaxVolume / 2;
+//        }
+//        setAudioVolume(mLeftVolume);
+//        try {
+//            getLatencyMethod =
+//                    AudioTrack.class.getMethod("getLatency", (Class<?>[]) null);
+//        } catch (NoSuchMethodException e) {
+//            // There's no guarantee this method exists. Do nothing.
+//        }
+//        mStoped = false;
+//        mAudioTrack.play();
+        Log.d(TAG, "audio open success");
+        return 0;
+    }
+
+    @Override
+    public int audioWrite(AudioFrameInfo frame) {
+//        mAudioProcessor.audioProcess(frame.mBuffers, frame.mSamples, frame.mTimestamp);
+//        return 0;
+//        int ret = -1;
+//        if (frame == null || frame.mBuffers == null) {
+//            return ret;
+//        }
+//
+//        int wSize= 0;
+//        synchronized (mAudioTrack) {
+//            if (mStoped) {
+//                return 0;
+//            }
+//            try {
+//                byte[] tmpBuffer = getAudioBuffer(frame);
+//                wSize = mAudioTrack.write(tmpBuffer, 0, tmpBuffer.length);
+//                ret = 0;
+//                AudioFrame audioFrame = buildAudioFrame(frame);
+//                this.mRTCVideo.pushScreenAudioFrame(audioFrame);
+//            } catch (Exception e) {
+//                Log.d(TAG, "write fail = " + e);
+//                e.printStackTrace();
+//                return -1;
+//            }
+//        }
+//
+//        if(wSize < 0) {
+//            Log.e(TAG, "write failed : ret: " + wSize + ", size = " + frame.mBuffers[0].array().length);
+//            return wSize;
+//        }
+//      Log.d(TAG, "audio write success");
+//        mWrittenPcmBytes += wSize;
+      AudioFrame audioFrame = buildAudioFrame(frame);
+      this.mRTCVideo.pushScreenAudioFrame(audioFrame);
+      return 0;
+    }
+
+  private AudioFrame buildAudioFrame(AudioFrameInfo info) {
+    var buffer = getAudioBuffer(info);
+    var mAudioSampleRate = getAudioSampleRate();
+    var mAudioChannel = getAudioChannel();
+    return new AudioFrame(
+      buffer,
+      info.mSamples,
+      mAudioSampleRate,
+      mAudioChannel
+    );
+  }
+
+  private AudioSampleRate getAudioSampleRate() {
+    if (mSampleRate == AudioSampleRate.AUDIO_SAMPLE_RATE_48000.value()) {
+      return AudioSampleRate.AUDIO_SAMPLE_RATE_48000;
+    }
+
+    if (mSampleRate == AudioSampleRate.AUDIO_SAMPLE_RATE_44100.value()) {
+      return AudioSampleRate.AUDIO_SAMPLE_RATE_44100;
+    }
+
+    if (mSampleRate == AudioSampleRate.AUDIO_SAMPLE_RATE_32000.value()) {
+      return AudioSampleRate.AUDIO_SAMPLE_RATE_32000;
+    }
+
+    if (mSampleRate == AudioSampleRate.AUDIO_SAMPLE_RATE_16000.value()) {
+      return AudioSampleRate.AUDIO_SAMPLE_RATE_16000;
+    }
+
+    if (mSampleRate == AudioSampleRate.AUDIO_SAMPLE_RATE_8000.value()) {
+      return AudioSampleRate.AUDIO_SAMPLE_RATE_8000;
+    }
+
+    return AudioSampleRate.AUDIO_SAMPLE_RATE_AUTO;
+  }
+
+  private AudioChannel getAudioChannel() {
+    if (mChannels == AudioChannel.AUDIO_CHANNEL_MONO.value()) {
+      return AudioChannel.AUDIO_CHANNEL_MONO;
+    }
+
+    if (mChannels == AudioChannel.AUDIO_CHANNEL_STEREO.value()) {
+      return AudioChannel.AUDIO_CHANNEL_STEREO;
+    }
+
+    return AudioChannel.AUDIO_CHANNEL_AUTO;
+  }
+    
+    private byte[] getAudioBuffer(AudioFrameInfo frame) {
+        byte[] buffer = null;
+        if (frame == null || frame.mBuffers == null) {
+            return null;
+        }
+        int bufferSize = frame.mBuffers[0].limit();
+        if (!mIsPacked) {
+            bufferSize = bufferSize * mChannels;
+        }
+        buffer = new byte[bufferSize];
+        int bytePerSample = mBytePerSample;
+        int readSize = bytePerSample * mChannels;
+        if (!mIsPacked) {
+            readSize = bytePerSample;
+        }
+        for (int i = 0;i < mChannels;i++) {
+            ByteBuffer tmpBuffer = frame.mBuffers[i];
+            if (tmpBuffer == null) {
+                break;
+            }
+            for (int j = 0; j < frame.mSamples;j++) {
+                tmpBuffer.get(buffer,j * mChannels * bytePerSample + i * bytePerSample, readSize);
+            }
+        }
+        return buffer;
+    }
+
+    @Override
+    public void audioPause() {
+        if (mAudioTrack == null) {
+            return;
+        }
+        mAudioTrack.pause();
+    }
+
+    @Override
+    public void audioResume() {
+        if (mAudioTrack == null) {
+            return;
+        }
+        mAudioTrack.play();
+    }
+
+    @Override
+    public void audioFlush() {
+        if (mAudioTrack == null) {
+            return;
+        }
+        mAudioTrack.flush();
+    }
+
+    @Override
+    public void audioClose() {
+        if (mAudioTrack == null) {
+            return;
+        }
+        mAudioTrack.pause();
+        mStoped = true;
+    }
+
+    @Override
+    public int getLatency() {
+        int latency = 0;
+        if (mAudioTrack == null) {
+            return latency;
+        }
+        if (getLatencyMethod != null) {
+            try {
+                // Compute the audio track latency, excluding the latency due to the buffer (leaving
+                // latency due to the mixer and audio hardware driver).
+                latency = (Integer) getLatencyMethod.invoke(mAudioTrack, (Object[]) null);
+            } catch (Exception e) {
+                latency = 0;
+                getLatencyMethod = null;
+            }
+        }
+        return latency;
+    }
+
+    private int reconfigure() {
+        int ret = -1;
+        if (mContext == null) {
+            return ret;
+        }
+        mAudioManager = (AudioManager)mContext.getSystemService(Service.AUDIO_SERVICE);
+        if(mAudioManager != null) {
+            mMaxVolume = mAudioManager.getStreamMaxVolume( mStreamType ); //
+        }
+        mChannelsLayout = getAudioTrackChannelConfig(mChannels);
+        if (mChannelsLayout == AudioFormat.CHANNEL_INVALID) {
+            return ret;
+        }
+        if (mSampleBytes == 1) {
+            mAudioFormat = AudioFormat.ENCODING_PCM_8BIT;
+        } else if(mSampleBytes == 2) {
+            mAudioFormat = AudioFormat.ENCODING_PCM_16BIT;
+        } else {
+            return ret;
+        }
+        int minBufSize = AudioTrack.getMinBufferSize(mSampleRate, mChannelsLayout, mAudioFormat);
+        if (minBufSize <= 0) {
+            Log.e(TAG, "getMinBufferSize failed, trace: sampleRate = " + mSampleRate + ", " +
+                    "mChannelsLayout = " + mChannelsLayout + ", mAudioFormat = " + mAudioFormat);
+            return minBufSize;
+        }
+        try {
+            if (mSessionId == -1) {
+                mAudioTrack = new AudioTrack(mStreamType, mSampleRate, mChannelsLayout, mAudioFormat, minBufSize, AudioTrack.MODE_STREAM);
+            } else {
+                mAudioTrack = new AudioTrack(mStreamType, mSampleRate, mChannelsLayout, mAudioFormat, minBufSize, AudioTrack.MODE_STREAM, mSessionId);
+            }
+        } catch (Throwable e) {
+            Log.e(TAG, "create audio track failed ,detail = " + e);
+            return ret;
+        }
+        int state = mAudioTrack.getState();
+        if (state != AudioTrack.STATE_INITIALIZED) {
+            try {
+                mAudioTrack.release();
+            } catch (Exception e) {
+                // The track has already failed to initialize, so it wouldn't be that surprising if release
+                // were to fail too. Swallow the exception.
+            } finally {
+                mAudioTrack = null;
+                Log.e(TAG, "create audiotrack but failed to initialize");
+                return AudioTrack.ERROR_INVALID_OPERATION;
+            }
+        }
+        return 0;
+    }
+
+    public void setAudioVolume(float leftVolume) {
+        try{
+            if(mMaxVolume < leftVolume) {
+                leftVolume = mMaxVolume;
+            }
+            if(mAudioManager != null) {
+                // Log.i("ttmn", "setVolume system lv"+leftVolume + "rv:"+rightVolume + "mv:"+mAudioManager.getStreamMaxVolume( AudioManager.STREAM_MUSIC ));
+                mAudioManager.setStreamVolume(mStreamType, (int)leftVolume, 0);
+            }
+            mLeftVolume = leftVolume;
+        } catch (Exception e) {
+        }
+    }
+
+    public static int getAudioTrackChannelConfig(int channelCount) {
+        switch(channelCount) {
+            case 1:
+                return 4;
+            case 2:
+                return 12;
+            case 3:
+                return 28;
+            case 4:
+                return 204;
+            case 5:
+                return 220;
+            case 6:
+                return 252;
+            case 7:
+                return 1276;
+            case 8:
+                if (Build.VERSION.SDK_INT >= 23) {
+                    return 6396;
+                } else {
+                    if (Build.VERSION.SDK_INT >= 21) {
+                        return 6396;
+                    }
+
+                    return 0;
+                }
+            default:
+                return 0;
+        }
+    }
+}

package/android/src/main/java/com/volcengine/reactnative/vertc/vod/VodMock.java

@@ -5,47 +5,36 @@ package com.volcengine.reactnative.vertc.vod;
 
 import android.os.Handler;
 import android.os.Looper;
+import android.util.Log;
 
 import com.ss.bytertc.engine.RTCVideo;
-import com.ss.bytertc.engine.data.AudioSourceType;
-import com.ss.bytertc.engine.data.StreamIndex;
 import com.ss.bytertc.engine.data.VideoPixelFormat;
 import com.ss.bytertc.engine.data.VideoRotation;
-import com.ss.bytertc.engine.data.VideoSourceType;
 import com.ss.bytertc.engine.video.VideoFrame;
 import com.ss.bytertc.engine.video.builder.CpuBufferVideoFrameBuilder;
 
 import java.nio.ByteBuffer;
 import java.util.concurrent.TimeUnit;
 
-// For Test pushScreenVideoFrame
 public class VodMock {
-  public String TAG = "VodMockTest";
+  public String TAG = "VideoAudioProcessor";
 
   private final RTCVideo mRTCEngine;
-  private final int mFps;
 
   public VodMock(RTCVideo engine) {
     mRTCEngine = engine;
-    mFps = 30;
   }
   
-  public void start() {
-    mRTCEngine.setScreenAudioSourceType(AudioSourceType.AUDIO_SOURCE_TYPE_EXTERNAL);
-    mRTCEngine.setVideoSourceType(StreamIndex.STREAM_INDEX_SCREEN, VideoSourceType.VIDEO_SOURCE_TYPE_EXTERNAL);
-    useFakeVideoFrame();
-  }
-  
-  private void useFakeVideoFrame() {
+  public void useFakeVideoFrame() {
     final Handler handler = new Handler(Looper.getMainLooper());
     var width = 998;
     var height = 554;
     Runnable runnable = new Runnable() {
       @Override
       public void run() {
-        handler.postDelayed(this, 1000 / mFps); 
+        handler.postDelayed(this, 30);  // Repeats every 5 seconds
 
-        var frame = buildInternalVideoFrame(width, height);
+        var frame = useInternalVideoFrame(width, height);
         mRTCEngine.pushScreenVideoFrame(frame);
 //        Log.d(TAG, "pushScreenVideoFrame");
       }
@@ -53,7 +42,7 @@ public class VodMock {
     handler.post(runnable);
   }
 
-  private VideoFrame buildInternalVideoFrame(int width, int height){
+  public VideoFrame useInternalVideoFrame(int width, int height){
     int chromaWidth = (width + 1) / 2;
     int chromaHeight = (height + 1) /2;
     int uvSize = chromaWidth * chromaHeight;