(Android-RTC-4)分析createPeerConnectionFactory之AudioDeviceModule

最新推荐文章于 2024-05-31 09:53:33 发布

Mr_Zzr

最新推荐文章于 2024-05-31 09:53:33 发布

阅读量1.3k

点赞数

分类专栏： Android-RTC 文章标签： android

本文链接：https://blog.csdn.net/a360940265a/article/details/119110936

版权

Android-RTC 专栏收录该内容

13 篇文章 31 订阅

订阅专栏

上图是之前 Android-RTC-1 简单分析得出来的，一张关于PeerConnectionFactory的至下而上结构图。今天继续从PeerConnectionFactory入手，承接 Android-RTC-3 的内容，分析createPeerConnectionFactory。

PeerConnectionFactory之PeerConnectionFactory.createPeerConnectionFactory。

从上图可以粗略的知道PeerConnectionFactory有三个主要模块，AudioDeviceModule / VideoEncoder/DecoderFactory / NetworkOptions，我们先来聚焦一下demo的入参情况。

// AppRTCDemo.PeerConnectionClient.java
private void createPeerConnectionFactoryInternal(PeerConnectionFactory.Options options) {
    // ... ...
    final AudioDeviceModule adm = createJavaAudioDevice();
    final boolean enableH264HighProfile =
            VIDEO_CODEC_H264_HIGH.equals(peerConnectionParameters.videoCodec);
    final VideoEncoderFactory encoderFactory;
    final VideoDecoderFactory decoderFactory;
    if (peerConnectionParameters.videoCodecHwAcceleration) {
        encoderFactory = new DefaultVideoEncoderFactory(
                rootEglBase.getEglBaseContext(), true, enableH264HighProfile);
        decoderFactory = new DefaultVideoDecoderFactory(rootEglBase.getEglBaseContext());
    } else {
        encoderFactory = new SoftwareVideoEncoderFactory();
        decoderFactory = new SoftwareVideoDecoderFactory();
    }
    factory = PeerConnectionFactory.builder()
            .setOptions(options)
            .setAudioDeviceModule(adm)
            .setVideoEncoderFactory(encoderFactory)
            .setVideoDecoderFactory(decoderFactory)
            .createPeerConnectionFactory();
    Log.d(TAG, "Peer connection factory created.");
    adm.release();
}

public static class Options {
    static final int ADAPTER_TYPE_UNKNOWN = 0;
    static final int ADAPTER_TYPE_ETHERNET = 1;
    static final int ADAPTER_TYPE_WIFI = 2;
    static final int ADAPTER_TYPE_CELLULAR = 4;
    static final int ADAPTER_TYPE_VPN = 8;
    static final int ADAPTER_TYPE_LOOPBACK = 16;
    static final int ADAPTER_TYPE_ANY = 32;
    public int networkIgnoreMask;
    public boolean disableEncryption;
    public boolean disableNetworkMonitor;

    public Options() { }
    @CalledByNative("Options")
    int getNetworkIgnoreMask() {
        return this.networkIgnoreMask;
    }
    @CalledByNative("Options")
    boolean getDisableEncryption() {
        return this.disableEncryption;
    }
    @CalledByNative("Options")
    boolean getDisableNetworkMonitor() {
        return this.disableNetworkMonitor;
    }
}

PeerConnectionFactory.Options只是简单的new了一个默认构造，重点还是要放在 AudioDeviceModule / VideoEncoderFactory / VideoDecoderFactory。

一、JavaAudioDeviceModule

// AppWebRTC-demo中的PeerConnectionClient.java
AudioDeviceModule createJavaAudioDevice() {
    if (!peerConnectionParameters.useOpenSLES) {
        Log.w(TAG, "External OpenSLES ADM not implemented yet.");
        // TODO: Add support for external OpenSLES ADM.
    }
    // Set audio record error callbacks.
    JavaAudioDeviceModule.AudioRecordErrorCallback audioRecordErrorCallback;
	// Set audio track error callbacks.
    JavaAudioDeviceModule.AudioTrackErrorCallback audioTrackErrorCallback;
    // Set audio record state callbacks.
    JavaAudioDeviceModule.AudioRecordStateCallback audioRecordStateCallback;
    // Set audio track state callbacks.
    JavaAudioDeviceModule.AudioTrackStateCallback audioTrackStateCallback;
    // 篇幅关系就不把代码贴全了。
    return JavaAudioDeviceModule.builder(appContext)
            .setSamplesReadyCallback(saveRecordedAudioToFile)
            .setUseHardwareAcousticEchoCanceler(!peerConnectionParameters.disableBuiltInAEC)
            .setUseHardwareNoiseSuppressor(!peerConnectionParameters.disableBuiltInNS)
            .setAudioRecordErrorCallback(audioRecordErrorCallback)
            .setAudioTrackErrorCallback(audioTrackErrorCallback)
            .setAudioRecordStateCallback(audioRecordStateCallback)
            .setAudioTrackStateCallback(audioTrackStateCallback)
            .createAudioDeviceModule();
}
// org.webrtc.audio.JavaAudioDeviceModule.java
public static class Builder {
    private final Context context;
    private final AudioManager audioManager;
    private int inputSampleRate = WebRtcAudioManager.getSampleRate(audioManager);
    private int outputSampleRate = WebRtcAudioManager.getSampleRate(audioManager);
    private int audioSource = WebRtcAudioRecord.DEFAULT_AUDIO_SOURCE;
    private int audioFormat = WebRtcAudioRecord.DEFAULT_AUDIO_FORMAT;
    private AudioTrackErrorCallback audioTrackErrorCallback;
    private AudioRecordErrorCallback audioRecordErrorCallback;
    private SamplesReadyCallback samplesReadyCallback;
    private AudioTrackStateCallback audioTrackStateCallback;
    private AudioRecordStateCallback audioRecordStateCallback;
    private boolean useHardwareAcousticEchoCanceler = isBuiltInAcousticEchoCancelerSupported();
    private boolean useHardwareNoiseSuppressor = isBuiltInNoiseSuppressorSupported();
    private boolean useStereoInput;
    private boolean useStereoOutput;

    public AudioDeviceModule createAudioDeviceModule() {
        if (useHardwareNoiseSuppressor) {
            Logging.d(TAG, "HW NS will be used.");
        } else {
            if (isBuiltInNoiseSuppressorSupported()) {
                Logging.d(TAG, "Overriding default behavior; now using WebRTC NS!");
            }
            Logging.d(TAG, "HW NS will not be used.");
        }
        if (useHardwareAcousticEchoCanceler) {
            Logging.d(TAG, "HW AEC will be used.");
        } else {
            if (isBuiltInAcousticEchoCancelerSupported()) {
                Logging.d(TAG, "Overriding default behavior; now using WebRTC AEC!");
            }
            Logging.d(TAG, "HW AEC will not be used.");
        }
        final WebRtcAudioRecord audioInput = new WebRtcAudioRecord(context, audioManager, audioSource, audioFormat, audioRecordErrorCallback, audioRecordStateCallback, samplesReadyCallback, useHardwareAcousticEchoCanceler, useHardwareNoiseSuppressor);
        final WebRtcAudioTrack audioOutput = new WebRtcAudioTrack(context, audioManager, audioTrackErrorCallback, audioTrackStateCallback);
        return new JavaAudioDeviceModule(context, audioManager, audioInput, audioOutput, inputSampleRate, outputSampleRate, useStereoInput, useStereoOutput);
    }
}

1、首先从AudioDeviceModule入手，分析java层代码。音频模块涉及回音消除和降噪，android原生系统已经抽象实现了相关功能模块，但是质量效果的优劣取决于硬件设备。可以往下跟踪 isBuiltInAcousticEchoCancelerSupported / isBuiltInNoiseSuppressorSupported两个静态方法，专门规避了AOSP中的软实现回音消除/降噪功能。尽可能的使用硬件的回音消除和降噪的功能。

// 专们特指定 AEC特性 的UUID，相当于识别码
public static final UUID EFFECT_TYPE_AEC = UUID   
            .fromString("7b491460-8d4d-11e0-bd61-0002a5d5c51b");
// UUIDs for Software Audio Effects that we want to avoid using.
// AOSP中软实现的回音消除模块的UUID，避免使用软实现。
private static final UUID AOSP_ACOUSTIC_ECHO_CANCELER =
            UUID.fromString("bb392ec0-8d4d-11e0-a896-0002a5d5c51b");
public static boolean isAcousticEchoCancelerSupported() {
    if (Build.VERSION.SDK_INT < 18)
            return false;
    return isEffectTypeAvailable(AudioEffect.EFFECT_TYPE_AEC, AOSP_ACOUSTIC_ECHO_CANCELER);
}
// Returns true if an effect of the specified type is available. Functionally
// equivalent to (NoiseSuppressor|AutomaticGainControl|...).isAvailable(), but
// faster as it avoids the expensive OS call to enumerate effects.
private static boolean isEffectTypeAvailable(UUID effectType, UUID blackListedUuid) {
    Descriptor[] effects = AudioEffect.queryEffects();
    if (effects == null) {
        return false;
    }
    for (Descriptor d : effects) {
        if (d.type.equals(effectType)) {
            return !d.uuid.equals(blackListedUuid);
        }
    }
    return false;
}

2、回头继续看createAudioDeviceModule当中的audioInput（WebRtcAudioRecord）和 audioOutput（WebRtcAudioTrack）

看看WebRtcAudioRecord模块，结构图如上所示，大体上也是Android原生API——AudioRecord的封装。但是此模块的接口很多都打了自定义标签@CalledByNative，都是从native层调用的。具体逻辑还是要往下深入AudioDeviceModle才能一并展开。

同理，WebRtcAudioTrack也是对Android原生API——AudioTrack的封装。关键函数已经标记。

    private final Context context;
    private final AudioManager audioManager;
    private final WebRtcAudioRecord audioInput;
    private final WebRtcAudioTrack audioOutput;
    private final int inputSampleRate;
    private final int outputSampleRate;
    private final boolean useStereoInput;
    private final boolean useStereoOutput;

    private final Object nativeLock = new Object();
    private long nativeAudioDeviceModule;

    private JavaAudioDeviceModule(Context context, AudioManager audioManager,
                                  WebRtcAudioRecord audioInput, WebRtcAudioTrack audioOutput, int inputSampleRate,
                                  int outputSampleRate, boolean useStereoInput, boolean useStereoOutput) {
        this.context = context;
        this.audioManager = audioManager;
        this.audioInput = audioInput;
        this.audioOutput = audioOutput;
        this.inputSampleRate = inputSampleRate;
        this.outputSampleRate = outputSampleRate;
        this.useStereoInput = useStereoInput;
        this.useStereoOutput = useStereoOutput;
    }

最后我们回到JavaAudioDeviceModule.builder.createAudioDeviceModule，可以清晰明了的看到JavaAudioDeviceModule的成员变量，基本上都是Android系统关于音频相关的原生API，nativeAudioDeviceModule用于保存native层的对象地址值，相当于c++的对象指针。这种写法间接的把java对象和cpp对象建立起关联，在很多Android native开源项目是非常常见的。

二、jni层的AudioDeviceModule

分析完Java业务层的代码，顺着脉络深入native层分析。先回滚至Java层入口函数

//org.webrtc.PeerConnectionFactory.Builder
public PeerConnectionFactory createPeerConnectionFactory() {
    PeerConnectionFactory.checkInitializeHasBeenCalled();
    if (this.audioDeviceModule == null) {
        this.audioDeviceModule = JavaAudioDeviceModule.builder(ContextUtils.getApplicationContext()).createAudioDeviceModule();
    }
    return PeerConnectionFactory.nativeCreatePeerConnectionFactory(
    ContextUtils.getApplicationContext(), 
    this.options, 
    this.audioDeviceModule.getNativeAudioDeviceModulePointer(), 
    this.audioEncoderFactoryFactory.createNativeAudioEncoderFactory(), 
    this.audioDecoderFactoryFactory.createNativeAudioDecoderFactory(), 
    this.videoEncoderFactory,
    this.videoDecoderFactory,
    this.audioProcessingFactory == null ? 0L : this.audioProcessingFactory.createNative(),
    this.fecControllerFactoryFactory == null ? 0L : this.fecControllerFactoryFactory.createNative(),
    this.networkControllerFactoryFactory == null ? 0L : this.networkControllerFactoryFactory.createNativeNetworkControllerFactory(),
    this.networkStatePredictorFactoryFactory == null ? 0L : this.networkStatePredictorFactoryFactory.createNativeNetworkStatePredictorFactory(),
    this.neteqFactoryFactory == null ? 0L : this.neteqFactoryFactory.createNativeNetEqFactory()
);
}

以上是PeerConnectionFactory的createPeerConnectionFactory 创建工厂实体类的函数，这个入口函数以后会多次碰见，毕竟它承载了太多东西了；这里先着重分析AudioDeviceModule，即分析JavaAudioDeviceModule.getNativeAudioDeviceModulePointer。

//org.webrtc.audio.JavaAudioDeviceModule
public long getNativeAudioDeviceModulePointer() {
    synchronized(this.nativeLock) {
        if (this.nativeAudioDeviceModule == 0L) {
            this.nativeAudioDeviceModule = nativeCreateAudioDeviceModule(
                                            this.context, this.audioManager, 
                                            this.audioInput, this.audioOutput, 
                                            this.inputSampleRate, this.outputSampleRate, 
                                            this.useStereoInput, this.useStereoOutput);
        }
        return this.nativeAudioDeviceModule;
    }
}
// out\arm64-v8a\gen\sdk\android\generated_java_audio_jni\JavaAudioDeviceModule_jni.h
JNI_GENERATOR_EXPORT jlong
    Java_org_webrtc_audio_JavaAudioDeviceModule_nativeCreateAudioDeviceModule(
    JNIEnv* env,
    jclass jcaller,
    jobject context,
    jobject audioManager,
    jobject audioInput,
    jobject audioOutput,
    jint inputSampleRate,
    jint outputSampleRate,
    jboolean useStereoInput,
    jboolean useStereoOutput) {
  return JNI_JavaAudioDeviceModule_CreateAudioDeviceModule(env,
base::android::JavaParamRef<jobject>(env, context),
base::android::JavaParamRef<jobject>(env, audioManager),
base::android::JavaParamRef<jobject>(env, audioInput),
base::android::JavaParamRef<jobject>(env, audioOutput), 
inputSampleRate, outputSampleRate,
useStereoInput, useStereoOutput);
}
// sdk\android\src\jni\audio_device\java_audio_device_module.cc
static jlong JNI_JavaAudioDeviceModule_CreateAudioDeviceModule(
    JNIEnv* env,
    const JavaParamRef<jobject>& j_context,
    const JavaParamRef<jobject>& j_audio_manager,
    const JavaParamRef<jobject>& j_webrtc_audio_record,
    const JavaParamRef<jobject>& j_webrtc_audio_track,
    int input_sample_rate,
    int output_sample_rate,
    jboolean j_use_stereo_input,
    jboolean j_use_stereo_output) {
  AudioParameters input_parameters;
  AudioParameters output_parameters;
  GetAudioParameters(env, j_context, j_audio_manager, input_sample_rate,
                     output_sample_rate, j_use_stereo_input,
                     j_use_stereo_output, &input_parameters,
                     &output_parameters);
  auto audio_input = std::make_unique<AudioRecordJni>(
      env, input_parameters, kHighLatencyModeDelayEstimateInMilliseconds,
      j_webrtc_audio_record);
  auto audio_output = std::make_unique<AudioTrackJni>(env, output_parameters,
                                                      j_webrtc_audio_track);
  return jlongFromPointer(CreateAudioDeviceModuleFromInputAndOutput(
                              AudioDeviceModule::kAndroidJavaAudio,
                              j_use_stereo_input, j_use_stereo_output,
                              kHighLatencyModeDelayEstimateInMilliseconds,
                              std::move(audio_input), std::move(audio_output))
                              .release());
}

看着以上的调用链，层层封装，有点复杂。但不要方抓重点，两个AudioParameters对象input_parameters和output_parameters；两个智能指针对象AudioRecordJni（audio_input）和AudioTrackJni（audio_output），然后继续分析两个重点方法 GetAudioParameters / CreateAudioDeviceModuleFromInputAndOutput

// sdk\android\src\jni\audio_device\audio_device_module.cc
void GetAudioParameters(JNIEnv* env,
                        const JavaRef<jobject>& j_context,
                        const JavaRef<jobject>& j_audio_manager,
                        int input_sample_rate,
                        int output_sample_rate,
                        bool use_stereo_input,
                        bool use_stereo_output,
                        AudioParameters* input_parameters,
                        AudioParameters* output_parameters) {
  const int output_channels = use_stereo_output ? 2 : 1;
  const int input_channels = use_stereo_input ? 2 : 1;
  const size_t output_buffer_size = Java_WebRtcAudioManager_getOutputBufferSize(
      env, j_context, j_audio_manager, output_sample_rate, output_channels);
  const size_t input_buffer_size = Java_WebRtcAudioManager_getInputBufferSize(
      env, j_context, j_audio_manager, input_sample_rate, input_channels);
  output_parameters->reset(output_sample_rate,
                           static_cast<size_t>(output_channels),
                           static_cast<size_t>(output_buffer_size));
  input_parameters->reset(input_sample_rate,
                          static_cast<size_t>(input_channels),
                          static_cast<size_t>(input_buffer_size));
  RTC_CHECK(input_parameters->is_valid());
  RTC_CHECK(output_parameters->is_valid());
}
// org.webrtc.audio.WebRtcAudioManager.java
@CalledByNative
static int getOutputBufferSize(
        Context context, AudioManager audioManager, int sampleRate, int numberOfOutputChannels) {
    return isLowLatencyOutputSupported(context)
            ? getLowLatencyFramesPerBuffer(audioManager)
            : getMinOutputFrameSize(sampleRate, numberOfOutputChannels);
}
private static boolean isLowLatencyOutputSupported(Context context) {
    return context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_AUDIO_LOW_LATENCY);
}
private static int getLowLatencyFramesPerBuffer(AudioManager audioManager) {
    if (Build.VERSION.SDK_INT < 17) {
        return DEFAULT_FRAME_PER_BUFFER;
    }
    String framesPerBuffer =
            audioManager.getProperty(AudioManager.PROPERTY_OUTPUT_FRAMES_PER_BUFFER);
    return framesPerBuffer == null ? DEFAULT_FRAME_PER_BUFFER : Integer.parseInt(framesPerBuffer);
}
private static int getMinOutputFrameSize(int sampleRateInHz, int numChannels) {
    final int bytesPerFrame = numChannels * (BITS_PER_SAMPLE / 8);
    final int channelConfig =
            (numChannels == 1 ? AudioFormat.CHANNEL_OUT_MONO : AudioFormat.CHANNEL_OUT_STEREO);
    return AudioTrack.getMinBufferSize(
            sampleRateInHz, channelConfig, AudioFormat.ENCODING_PCM_16BIT)
            / bytesPerFrame;
}

可以看到GetAudioParameters 也是反调用Java层的WebRtcAudioManager的两个系统方法。到这简单总结一下关于音频：采样率(sample rate)、采样位数(bit per sample)、通道数(channel number)、比特率or码率的关系。

1、采样率是指每秒采样多少次。
2、采样位数是指每次数字采样的数据，用多少位数来保存，常见有8位或是16位。
3、通道常见单声道音频，立体声道，若是单声道，那么每次采样一个通道，若是立体声道，那么每次采样两个不同声道
4、比特率 = 采样率 * 采样位数 * 通道数（buffersize = 比特率 / 8）（纯理论）
5、实际情况系统都会进行一定的空间压缩优化。对于Android系统，可以使用系统API，AudioRecord.getMinBufferSize 和 AudioTrack.getMinBufferSize得出最小支持的size。

接下来分析CreateAudioDeviceModuleFromInputAndOutput。很简单，就是返回一个AndroidAudioDeviceModule对象的指针。

// sdk\android\src\jni\audio_device\audio_device_module.cc
rtc::scoped_refptr<AudioDeviceModule> CreateAudioDeviceModuleFromInputAndOutput(
    AudioDeviceModule::AudioLayer audio_layer,
    bool is_stereo_playout_supported,
    bool is_stereo_record_supported,
    uint16_t playout_delay_ms,
    std::unique_ptr<AudioInput> audio_input,
    std::unique_ptr<AudioOutput> audio_output) {
  RTC_DLOG(INFO) << __FUNCTION__;
  return rtc::make_ref_counted<AndroidAudioDeviceModule>(
      audio_layer, is_stereo_playout_supported, is_stereo_record_supported,
      playout_delay_ms, std::move(audio_input), std::move(audio_output));
}

到这里准备展开Native层的AudioDeviceModule——AndroidAudioDeviceModule，在此之前总结以上的分析内容。可以用以下这一张图简单概括。

AudioRecordJni对标WebRtcAudioRecord，AudioTrackJni对标WebRtcAudioTrack，nativeAudioDeviceModule保存着AndroidAudioDeviceModule对象指针的地址值。

三、AndroidAudioDeviceModule

犹豫篇幅和代码复杂度的关系，这一节不打算刨根问底的贴代码。先用一张图简单概述AndroidAudioDeviceModule的内部状态。

到这里能清晰的看清楚整个AudioDeviceModule的构成，接着再简单的分析AudioRecordJni——WebRtcAudioRecord的部分关键代码。AudioTrackJni——WebRtcAudioTrack暂时放一放，因为没有分析到传输模块，还没有外部音频数据的流入。

// sdk\android\src\jni\audio_device\audio_record_jni.cc
int32_t AudioRecordJni::InitRecording() {
  RTC_DCHECK(thread_checker_.IsCurrent());
  if (initialized_) {
    // Already initialized.
    return 0;
  }

  int frames_per_buffer = Java_WebRtcAudioRecord_initRecording(
      env_, j_audio_record_, audio_parameters_.sample_rate(),
      static_cast<int>(audio_parameters_.channels()));
  if (frames_per_buffer < 0) {
    direct_buffer_address_ = nullptr;
    return -1;
  }
  frames_per_buffer_ = static_cast<size_t>(frames_per_buffer);

  const size_t bytes_per_frame = audio_parameters_.channels() * sizeof(int16_t);

  initialized_ = true;
  return 0;
}
// org.webrtc.audio.WebRtcAudioRecord.java
@CalledByNative
private int initRecording(int sampleRate, int channels) {
    if (audioRecord != null) {
        return -1;
    }
    final int bytesPerFrame = channels * getBytesPerSample(audioFormat);
    final int framesPerBuffer = sampleRate / BUFFERS_PER_SECOND;
    byteBuffer = ByteBuffer.allocateDirect(bytesPerFrame * framesPerBuffer);
    if (!(byteBuffer.hasArray())) {
        return -1;
    }
    emptyBytes = new byte[byteBuffer.capacity()];
	
    // 比起每次回调传递ByteBuffer（需要调用笨重的GetDirectBufferAddress方法）
	// 我们可以简单的传递一次缓存地址到内部native层。
    nativeCacheDirectBufferAddress(nativeAudioRecord, byteBuffer);
	
    final int channelConfig = channelCountToConfiguration(channels);
    // 请注意，此size大小不能保证在负载下顺利录制。
    int minBufferSize = AudioRecord.getMinBufferSize(sampleRate, channelConfig, audioFormat);
    if (minBufferSize == AudioRecord.ERROR || minBufferSize == AudioRecord.ERROR_BAD_VALUE) {
        return -1;
    }
	// 使用 大于所需最小值的缓冲区空间，确保在负载下顺利录制。
	// 经验证，它不会增加实际记录延迟。
	// BUFFER_SIZE_FACTOR = 2
    int bufferSizeInBytes = Math.max(BUFFER_SIZE_FACTOR * minBufferSize, byteBuffer.capacity());
    try {
        if (Build.VERSION.SDK_INT >= 23) {
            this.audioRecord = createAudioRecordOnMOrHigher(this.audioSource, sampleRate, channelConfig, this.audioFormat, bufferSizeInBytes);
            if (this.preferredDevice != null) {
                this.setPreferredDevice(this.preferredDevice);
            }
        } else {
            this.audioRecord = createAudioRecordOnLowerThanM(this.audioSource, sampleRate, channelConfig, this.audioFormat, bufferSizeInBytes);
        }
    } catch (IllegalArgumentException e) {
        releaseAudioResources();
        return -1;
    }

    if (this.audioRecord != null && this.audioRecord.getState() == 1) {
        this.effects.enable(this.audioRecord.getAudioSessionId());
		// 启用硬件降噪，回音消除的特性。
        this.logMainParameters();
        this.logMainParametersExtended();
        return framesPerBuffer;
    } else {
        this.releaseAudioResources();
        return -1;
    }
}

以初始化 initRecording 为例。代码流程如上，其他方法也是这样一一对应。可能有同学会问，那什么才真正的调用init / start / stop之类的功能函数呢？不要急，因为现在还停留在初始化的构造阶段，往后分析功能的时候就能知道了。