diff -Nrup -U 8 a/media/webrtc/trunk/webrtc/modules/video_coding/codecs/vp9/vp9_impl.cc b/media/webrtc/trunk/webrtc/modules/video_coding/codecs/vp9/vp9_impl.cc --- a/media/webrtc/trunk/webrtc/modules/video_coding/codecs/vp9/vp9_impl.cc 2020-02-18 02:37:58.000000000 +0300 +++ b/media/webrtc/trunk/webrtc/modules/video_coding/codecs/vp9/vp9_impl.cc 2020-03-02 00:34:19.000000000 +0300 @@ -79,17 +79,19 @@ VP9EncoderImpl::VP9EncoderImpl() num_temporal_layers_(0), num_spatial_layers_(0), num_cores_(0), is_flexible_mode_(false), frames_encoded_(0), // Use two spatial when screensharing with flexible mode. spatial_layer_(new ScreenshareLayersVP9(2)) { memset(&codec_, 0, sizeof(codec_)); +#ifdef LIBVPX_SVC memset(&svc_params_, 0, sizeof(vpx_svc_extra_cfg_t)); +#endif uint32_t seed = rtc::Time32(); srand(seed); } VP9EncoderImpl::~VP9EncoderImpl() { Release(); } @@ -115,55 +117,66 @@ int VP9EncoderImpl::Release() { } inited_ = false; return WEBRTC_VIDEO_CODEC_OK; } bool VP9EncoderImpl::ExplicitlyConfiguredSpatialLayers() const { // We check target_bitrate_bps of the 0th layer to see if the spatial layers // (i.e. bitrates) were explicitly configured. +#ifdef LIBVPX_SVC return num_spatial_layers_ > 1 && codec_.spatialLayers[0].target_bitrate_bps > 0; +#else + return false; +#endif } bool VP9EncoderImpl::SetSvcRates() { uint8_t i = 0; if (ExplicitlyConfiguredSpatialLayers()) { +#ifdef LIBVPX_SVC if (num_temporal_layers_ > 1) { LOG(LS_ERROR) << "Multiple temporal layers when manually specifying " "spatial layers not implemented yet!"; return false; } int total_bitrate_bps = 0; for (i = 0; i < num_spatial_layers_; ++i) total_bitrate_bps += codec_.spatialLayers[i].target_bitrate_bps; // If total bitrate differs now from what has been specified at the // beginning, update the bitrates in the same ratio as before. for (i = 0; i < num_spatial_layers_; ++i) { config_->ss_target_bitrate[i] = config_->layer_target_bitrate[i] = static_cast(static_cast(config_->rc_target_bitrate) * codec_.spatialLayers[i].target_bitrate_bps / total_bitrate_bps); } +#endif } else { float rate_ratio[VPX_MAX_LAYERS] = {0}; float total = 0; +#ifdef LIBVPX_SVC for (i = 0; i < num_spatial_layers_; ++i) { if (svc_params_.scaling_factor_num[i] <= 0 || svc_params_.scaling_factor_den[i] <= 0) { LOG(LS_ERROR) << "Scaling factors not specified!"; return false; } rate_ratio[i] = static_cast(svc_params_.scaling_factor_num[i]) / svc_params_.scaling_factor_den[i]; total += rate_ratio[i]; } +#else + rate_ratio[0] = 1; + total = 1; +#endif for (i = 0; i < num_spatial_layers_; ++i) { config_->ss_target_bitrate[i] = static_cast( config_->rc_target_bitrate * rate_ratio[i] / total); if (num_temporal_layers_ == 1) { config_->layer_target_bitrate[i] = config_->ss_target_bitrate[i]; } else if (num_temporal_layers_ == 2) { config_->layer_target_bitrate[i * num_temporal_layers_] = @@ -390,16 +403,17 @@ int VP9EncoderImpl::NumberOfThreads(int return 2; } else { // 1 thread less than VGA. return 1; } } int VP9EncoderImpl::InitAndSetControlSettings(const VideoCodec* inst) { +#ifdef LIBVPX_SVC // Set QP-min/max per spatial and temporal layer. int tot_num_layers = num_spatial_layers_ * num_temporal_layers_; for (int i = 0; i < tot_num_layers; ++i) { svc_params_.max_quantizers[i] = config_->rc_max_quantizer; svc_params_.min_quantizers[i] = config_->rc_min_quantizer; } config_->ss_number_layers = num_spatial_layers_; if (ExplicitlyConfiguredSpatialLayers()) { @@ -413,37 +427,41 @@ int VP9EncoderImpl::InitAndSetControlSet for (int i = num_spatial_layers_ - 1; i >= 0; --i) { // 1:2 scaling in each dimension. svc_params_.scaling_factor_num[i] = scaling_factor_num; svc_params_.scaling_factor_den[i] = 256; if (codec_.mode != kScreensharing) scaling_factor_num /= 2; } } +#endif if (!SetSvcRates()) { return WEBRTC_VIDEO_CODEC_ERR_PARAMETER; } if (vpx_codec_enc_init(encoder_, vpx_codec_vp9_cx(), config_, 0)) { return WEBRTC_VIDEO_CODEC_UNINITIALIZED; } vpx_codec_control(encoder_, VP8E_SET_CPUUSED, cpu_speed_); vpx_codec_control(encoder_, VP8E_SET_MAX_INTRA_BITRATE_PCT, rc_max_intra_target_); vpx_codec_control(encoder_, VP9E_SET_AQ_MODE, inst->VP9().adaptiveQpMode ? 3 : 0); +#ifdef LIBVPX_SVC vpx_codec_control( encoder_, VP9E_SET_SVC, (num_temporal_layers_ > 1 || num_spatial_layers_ > 1) ? 1 : 0); if (num_temporal_layers_ > 1 || num_spatial_layers_ > 1) { vpx_codec_control(encoder_, VP9E_SET_SVC_PARAMETERS, &svc_params_); } +#endif + // Register callback for getting each spatial layer. vpx_codec_priv_output_cx_pkt_cb_pair_t cbp = { VP9EncoderImpl::EncoderOutputCodedPacketCallback, reinterpret_cast(this)}; vpx_codec_control(encoder_, VP9E_REGISTER_CX_CALLBACK, reinterpret_cast(&cbp)); // Control function to set the number of column tiles in encoding a frame, in @@ -527,16 +545,17 @@ int VP9EncoderImpl::Encode(const VideoFr vpx_enc_frame_flags_t flags = 0; bool send_keyframe = (frame_type == kVideoFrameKey); if (send_keyframe) { // Key frame request from caller. flags = VPX_EFLAG_FORCE_KF; } +#ifdef LIBVPX_SVC if (is_flexible_mode_) { SuperFrameRefSettings settings; // These structs are copied when calling vpx_codec_control, // therefore it is ok for them to go out of scope. vpx_svc_ref_frame_config enc_layer_conf; vpx_svc_layer_id layer_id; @@ -548,16 +567,17 @@ int VP9EncoderImpl::Encode(const VideoFr send_keyframe); } enc_layer_conf = GenerateRefsAndFlags(settings); layer_id.temporal_layer_id = 0; layer_id.spatial_layer_id = settings.start_layer; vpx_codec_control(encoder_, VP9E_SET_SVC_LAYER_ID, &layer_id); vpx_codec_control(encoder_, VP9E_SET_SVC_REF_FRAME_CONFIG, &enc_layer_conf); } +#endif assert(codec_.maxFramerate > 0); uint32_t duration = 90000 / codec_.maxFramerate; if (vpx_codec_encode(encoder_, raw_, timestamp_, duration, flags, VPX_DL_REALTIME)) { return WEBRTC_VIDEO_CODEC_ERROR; } timestamp_ += duration; @@ -686,29 +706,31 @@ void VP9EncoderImpl::PopulateCodecSpecif vp9_info->p_diff[i] = p_diff_[layer_id.spatial_layer_id][i]; } } else { vp9_info->gof_idx = static_cast(frames_since_kf_ % gof_.num_frames_in_gof); vp9_info->temporal_up_switch = gof_.temporal_up_switch[vp9_info->gof_idx]; } +#ifdef LIBVPX_SVC if (vp9_info->ss_data_available) { vp9_info->spatial_layer_resolution_present = true; for (size_t i = 0; i < vp9_info->num_spatial_layers; ++i) { vp9_info->width[i] = codec_.width * svc_params_.scaling_factor_num[i] / svc_params_.scaling_factor_den[i]; vp9_info->height[i] = codec_.height * svc_params_.scaling_factor_num[i] / svc_params_.scaling_factor_den[i]; } - if (!vp9_info->flexible_mode) { - vp9_info->gof.CopyGofInfoVP9(gof_); - } + } +#endif + if (!vp9_info->flexible_mode) { + vp9_info->gof.CopyGofInfoVP9(gof_); } } int VP9EncoderImpl::GetEncodedLayerFrame(const vpx_codec_cx_pkt* pkt) { RTC_DCHECK_EQ(pkt->kind, VPX_CODEC_CX_FRAME_PKT); if (pkt->data.frame.sz > encoded_image_._size) { delete[] encoded_image_._buffer; @@ -756,16 +778,17 @@ int VP9EncoderImpl::GetEncodedLayerFrame vpx_codec_control(encoder_, VP8E_GET_LAST_QUANTIZER, &qp); encoded_image_.qp_ = qp; encoded_complete_callback_->OnEncodedImage(encoded_image_, &codec_specific, &frag_info); } return WEBRTC_VIDEO_CODEC_OK; } +#ifdef LIBVPX_SVC vpx_svc_ref_frame_config VP9EncoderImpl::GenerateRefsAndFlags( const SuperFrameRefSettings& settings) { static const vpx_enc_frame_flags_t kAllFlags = VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_GF; vpx_svc_ref_frame_config sf_conf = {}; if (settings.is_keyframe) { // Used later on to make sure we don't make any invalid references. @@ -857,16 +880,17 @@ vpx_svc_ref_frame_config VP9EncoderImpl: buffer_updated_at_frame_[updated_buffer] = frames_encoded_; sf_conf.frame_flags[layer_idx] = layer_flags; } } } ++frames_encoded_; return sf_conf; } +#endif int VP9EncoderImpl::SetChannelParameters(uint32_t packet_loss, int64_t rtt) { return WEBRTC_VIDEO_CODEC_OK; } int VP9EncoderImpl::RegisterEncodeCompleteCallback( EncodedImageCallback* callback) { encoded_complete_callback_ = callback; diff -Nrup -U 8 a/media/webrtc/trunk/webrtc/modules/video_coding/codecs/vp9/vp9_impl.h b/media/webrtc/trunk/webrtc/modules/video_coding/codecs/vp9/vp9_impl.h --- a/media/webrtc/trunk/webrtc/modules/video_coding/codecs/vp9/vp9_impl.h 2020-02-18 02:37:58.000000000 +0300 +++ b/media/webrtc/trunk/webrtc/modules/video_coding/codecs/vp9/vp9_impl.h 2020-03-02 00:32:05.000000000 +0300 @@ -77,24 +77,26 @@ class VP9EncoderImpl : public VP9Encoder void PopulateCodecSpecific(CodecSpecificInfo* codec_specific, const vpx_codec_cx_pkt& pkt, uint32_t timestamp); bool ExplicitlyConfiguredSpatialLayers() const; bool SetSvcRates(); +#ifdef LIBVPX_SVC // Used for flexible mode to set the flags and buffer references used // by the encoder. Also calculates the references used by the RTP // packetizer. // // Has to be called for every frame (keyframes included) to update the // state used to calculate references. vpx_svc_ref_frame_config GenerateRefsAndFlags( const SuperFrameRefSettings& settings); +#endif virtual int GetEncodedLayerFrame(const vpx_codec_cx_pkt* pkt); // Callback function for outputting packets per spatial layer. static void EncoderOutputCodedPacketCallback(vpx_codec_cx_pkt* pkt, void* user_data); // Determine maximum target for Intra frames @@ -111,17 +113,19 @@ class VP9EncoderImpl : public VP9Encoder bool inited_; int64_t timestamp_; uint16_t picture_id_; int cpu_speed_; uint32_t rc_max_intra_target_; vpx_codec_ctx_t* encoder_; vpx_codec_enc_cfg_t* config_; vpx_image_t* raw_; +#ifdef LIBVPX_SVC vpx_svc_extra_cfg_t svc_params_; +#endif const VideoFrame* input_image_; GofInfoVP9 gof_; // Contains each frame's temporal information for // non-flexible mode. uint8_t tl0_pic_idx_; // Only used in non-flexible mode. size_t frames_since_kf_; uint8_t num_temporal_layers_; uint8_t num_spatial_layers_; uint8_t num_cores_;