diff --git a/modules/video_coding/codecs/test/stats.cc b/modules/video_coding/codecs/test/stats.cc index 968d84e984..ff6ab69b20 100644 --- a/modules/video_coding/codecs/test/stats.cc +++ b/modules/video_coding/codecs/test/stats.cc @@ -30,8 +30,8 @@ std::string FrameStatistics::ToString() const { ss << "frame_number " << frame_number; ss << " decoded_width " << decoded_width; ss << " decoded_height " << decoded_height; - ss << " simulcast_svc_idx " << simulcast_svc_idx; - ss << " temporal_layer_idx " << temporal_layer_idx; + ss << " spatial_idx " << spatial_idx; + ss << " temporal_idx " << temporal_idx; ss << " inter_layer_predicted " << inter_layer_predicted; ss << " frame_type " << frame_type; ss << " length_bytes " << length_bytes; @@ -52,8 +52,8 @@ std::string VideoStatistics::ToString(std::string prefix) const { std::stringstream ss; ss << prefix << "target_bitrate_kbps: " << target_bitrate_kbps; ss << "\n" << prefix << "input_framerate_fps: " << input_framerate_fps; - ss << "\n" << prefix << "spatial_layer_idx: " << spatial_layer_idx; - ss << "\n" << prefix << "temporal_layer_idx: " << temporal_layer_idx; + ss << "\n" << prefix << "spatial_idx: " << spatial_idx; + ss << "\n" << prefix << "temporal_idx: " << temporal_idx; ss << "\n" << prefix << "width: " << width; ss << "\n" << prefix << "height: " << height; ss << "\n" << prefix << "length_bytes: " << length_bytes; @@ -124,13 +124,12 @@ std::vector Stats::SliceAndCalcLayerVideoStatistic( RTC_CHECK_GT(num_spatial_layers, 0); RTC_CHECK_GT(num_temporal_layers, 0); - for (size_t spatial_layer_idx = 0; spatial_layer_idx < num_spatial_layers; - ++spatial_layer_idx) { - for (size_t temporal_layer_idx = 0; - temporal_layer_idx < num_temporal_layers; ++temporal_layer_idx) { + for (size_t spatial_idx = 0; spatial_idx < num_spatial_layers; + ++spatial_idx) { + for (size_t temporal_idx = 0; temporal_idx < num_temporal_layers; + ++temporal_idx) { VideoStatistics layer_stat = SliceAndCalcVideoStatistic( - first_frame_num, last_frame_num, spatial_layer_idx, - temporal_layer_idx, false); + first_frame_num, last_frame_num, spatial_idx, temporal_idx, false); layer_stats.push_back(layer_stat); } } @@ -162,8 +161,8 @@ void Stats::PrintFrameStatistics() { } } -size_t Stats::Size(size_t spatial_layer_idx) { - return layer_stats_[spatial_layer_idx].size(); +size_t Stats::Size(size_t spatial_idx) { + return layer_stats_[spatial_idx].size(); } void Stats::Clear() { @@ -173,13 +172,13 @@ void Stats::Clear() { FrameStatistics Stats::AggregateFrameStatistic( size_t frame_num, - size_t spatial_layer_idx, + size_t spatial_idx, bool aggregate_independent_layers) { - FrameStatistics frame_stat = *GetFrame(frame_num, spatial_layer_idx); + FrameStatistics frame_stat = *GetFrame(frame_num, spatial_idx); bool inter_layer_predicted = frame_stat.inter_layer_predicted; - while (spatial_layer_idx-- > 0) { + while (spatial_idx-- > 0) { if (aggregate_independent_layers || inter_layer_predicted) { - FrameStatistics* base_frame_stat = GetFrame(frame_num, spatial_layer_idx); + FrameStatistics* base_frame_stat = GetFrame(frame_num, spatial_idx); frame_stat.length_bytes += base_frame_stat->length_bytes; frame_stat.target_bitrate_kbps += base_frame_stat->target_bitrate_kbps; @@ -192,8 +191,8 @@ FrameStatistics Stats::AggregateFrameStatistic( size_t Stats::CalcLayerTargetBitrateKbps(size_t first_frame_num, size_t last_frame_num, - size_t spatial_layer_idx, - size_t temporal_layer_idx, + size_t spatial_idx, + size_t temporal_idx, bool aggregate_independent_layers) { size_t target_bitrate_kbps = 0; @@ -204,9 +203,9 @@ size_t Stats::CalcLayerTargetBitrateKbps(size_t first_frame_num, for (size_t frame_num = first_frame_num; frame_num <= last_frame_num; ++frame_num) { FrameStatistics superframe = AggregateFrameStatistic( - frame_num, spatial_layer_idx, aggregate_independent_layers); + frame_num, spatial_idx, aggregate_independent_layers); - if (superframe.temporal_layer_idx <= temporal_layer_idx) { + if (superframe.temporal_idx <= temporal_idx) { target_bitrate_kbps = std::max(target_bitrate_kbps, superframe.target_bitrate_kbps); } @@ -219,8 +218,8 @@ size_t Stats::CalcLayerTargetBitrateKbps(size_t first_frame_num, VideoStatistics Stats::SliceAndCalcVideoStatistic( size_t first_frame_num, size_t last_frame_num, - size_t spatial_layer_idx, - size_t temporal_layer_idx, + size_t spatial_idx, + size_t temporal_idx, bool aggregate_independent_layers) { VideoStatistics video_stat; @@ -245,14 +244,14 @@ VideoStatistics Stats::SliceAndCalcVideoStatistic( FrameStatistics last_successfully_decoded_frame(0, 0); - const size_t target_bitrate_kbps = CalcLayerTargetBitrateKbps( - first_frame_num, last_frame_num, spatial_layer_idx, temporal_layer_idx, - aggregate_independent_layers); + const size_t target_bitrate_kbps = + CalcLayerTargetBitrateKbps(first_frame_num, last_frame_num, spatial_idx, + temporal_idx, aggregate_independent_layers); for (size_t frame_num = first_frame_num; frame_num <= last_frame_num; ++frame_num) { FrameStatistics frame_stat = AggregateFrameStatistic( - frame_num, spatial_layer_idx, aggregate_independent_layers); + frame_num, spatial_idx, aggregate_independent_layers); float time_since_first_frame_sec = 1.0f * (frame_stat.rtp_timestamp - rtp_timestamp_first_frame) / @@ -261,7 +260,7 @@ VideoStatistics Stats::SliceAndCalcVideoStatistic( 1.0f * (frame_stat.rtp_timestamp - rtp_timestamp_prev_frame) / kVideoPayloadTypeFrequency; - if (frame_stat.temporal_layer_idx > temporal_layer_idx) { + if (frame_stat.temporal_idx > temporal_idx) { continue; } @@ -340,8 +339,8 @@ VideoStatistics Stats::SliceAndCalcVideoStatistic( const size_t num_frames = last_frame_num - first_frame_num + 1; const size_t timestamp_delta = - GetFrame(first_frame_num + 1, spatial_layer_idx)->rtp_timestamp - - GetFrame(first_frame_num, spatial_layer_idx)->rtp_timestamp; + GetFrame(first_frame_num + 1, spatial_idx)->rtp_timestamp - + GetFrame(first_frame_num, spatial_idx)->rtp_timestamp; const float input_framerate_fps = 1.0 * kVideoPayloadTypeFrequency / timestamp_delta; const float duration_sec = num_frames / input_framerate_fps; @@ -349,8 +348,8 @@ VideoStatistics Stats::SliceAndCalcVideoStatistic( video_stat.target_bitrate_kbps = target_bitrate_kbps; video_stat.input_framerate_fps = input_framerate_fps; - video_stat.spatial_layer_idx = spatial_layer_idx; - video_stat.temporal_layer_idx = temporal_layer_idx; + video_stat.spatial_idx = spatial_idx; + video_stat.temporal_idx = temporal_idx; video_stat.bitrate_kbps = static_cast(8 * video_stat.length_bytes / 1000 / duration_sec); @@ -391,14 +390,14 @@ void Stats::GetNumberOfEncodedLayers(size_t first_frame_num, for (size_t frame_num = first_frame_num; frame_num <= last_frame_num; ++frame_num) { - for (size_t spatial_layer_idx = 0; spatial_layer_idx < num_spatial_layers; - ++spatial_layer_idx) { - FrameStatistics* frame_stat = GetFrame(frame_num, spatial_layer_idx); + for (size_t spatial_idx = 0; spatial_idx < num_spatial_layers; + ++spatial_idx) { + FrameStatistics* frame_stat = GetFrame(frame_num, spatial_idx); if (frame_stat->encoding_successful) { - *num_encoded_spatial_layers = std::max( - *num_encoded_spatial_layers, frame_stat->simulcast_svc_idx + 1); - *num_encoded_temporal_layers = std::max( - *num_encoded_temporal_layers, frame_stat->temporal_layer_idx + 1); + *num_encoded_spatial_layers = + std::max(*num_encoded_spatial_layers, frame_stat->spatial_idx + 1); + *num_encoded_temporal_layers = std::max(*num_encoded_temporal_layers, + frame_stat->temporal_idx + 1); } } } diff --git a/modules/video_coding/codecs/test/stats.h b/modules/video_coding/codecs/test/stats.h index d8dba8b3be..5edcfd55e7 100644 --- a/modules/video_coding/codecs/test/stats.h +++ b/modules/video_coding/codecs/test/stats.h @@ -40,8 +40,8 @@ struct FrameStatistics { webrtc::FrameType frame_type = kVideoFrameDelta; // Layering. - size_t temporal_layer_idx = 0; - size_t simulcast_svc_idx = 0; + size_t spatial_idx = 0; + size_t temporal_idx = 0; bool inter_layer_predicted = false; // H264 specific. @@ -72,8 +72,8 @@ struct VideoStatistics { size_t target_bitrate_kbps = 0; float input_framerate_fps = 0.0f; - size_t spatial_layer_idx = 0; - size_t temporal_layer_idx = 0; + size_t spatial_idx = 0; + size_t temporal_idx = 0; size_t width = 0; size_t height = 0; @@ -117,12 +117,11 @@ class Stats { ~Stats() = default; // Creates a FrameStatistics for the next frame to be processed. - FrameStatistics* AddFrame(size_t timestamp, size_t spatial_layer_idx); + FrameStatistics* AddFrame(size_t timestamp, size_t spatial_idx); // Returns the FrameStatistics corresponding to |frame_number| or |timestamp|. - FrameStatistics* GetFrame(size_t frame_number, size_t spatial_layer_idx); - FrameStatistics* GetFrameWithTimestamp(size_t timestamp, - size_t spatial_layer_idx); + FrameStatistics* GetFrame(size_t frame_number, size_t spatial_idx); + FrameStatistics* GetFrameWithTimestamp(size_t timestamp, size_t spatial_idx); std::vector SliceAndCalcLayerVideoStatistic( size_t first_frame_num, @@ -133,25 +132,25 @@ class Stats { void PrintFrameStatistics(); - size_t Size(size_t spatial_layer_idx); + size_t Size(size_t spatial_idx); void Clear(); private: FrameStatistics AggregateFrameStatistic(size_t frame_num, - size_t spatial_layer_idx, + size_t spatial_idx, bool aggregate_independent_layers); size_t CalcLayerTargetBitrateKbps(size_t first_frame_num, size_t last_frame_num, - size_t spatial_layer_idx, - size_t temporal_layer_idx, + size_t spatial_idx, + size_t temporal_idx, bool aggregate_independent_layers); VideoStatistics SliceAndCalcVideoStatistic(size_t first_frame_num, size_t last_frame_num, - size_t spatial_layer_idx, - size_t temporal_layer_idx, + size_t spatial_idx, + size_t temporal_idx, bool aggregate_independent_layers); void GetNumberOfEncodedLayers(size_t first_frame_num, diff --git a/modules/video_coding/codecs/test/videoprocessor.cc b/modules/video_coding/codecs/test/videoprocessor.cc index 4758f752a0..36e35665dc 100644 --- a/modules/video_coding/codecs/test/videoprocessor.cc +++ b/modules/video_coding/codecs/test/videoprocessor.cc @@ -56,17 +56,17 @@ size_t GetMaxNaluSizeBytes(const EncodedImage& encoded_frame, } void GetLayerIndices(const CodecSpecificInfo& codec_specific, - size_t* simulcast_svc_idx, + size_t* spatial_idx, size_t* temporal_idx) { if (codec_specific.codecType == kVideoCodecVP8) { - *simulcast_svc_idx = codec_specific.codecSpecific.VP8.simulcastIdx; + *spatial_idx = codec_specific.codecSpecific.VP8.simulcastIdx; *temporal_idx = codec_specific.codecSpecific.VP8.temporalIdx; } else if (codec_specific.codecType == kVideoCodecVP9) { - *simulcast_svc_idx = codec_specific.codecSpecific.VP9.spatial_idx; + *spatial_idx = codec_specific.codecSpecific.VP9.spatial_idx; *temporal_idx = codec_specific.codecSpecific.VP9.temporal_idx; } - if (*simulcast_svc_idx == kNoSpatialIdx) { - *simulcast_svc_idx = 0; + if (*spatial_idx == kNoSpatialIdx) { + *spatial_idx = 0; } if (*temporal_idx == kNoTemporalIdx) { *temporal_idx = 0; @@ -205,19 +205,15 @@ VideoProcessor::VideoProcessor(webrtc::VideoEncoder* encoder, config_.max_payload_size_bytes), WEBRTC_VIDEO_CODEC_OK); - for (size_t simulcast_svc_idx = 0; - simulcast_svc_idx < num_simulcast_or_spatial_layers_; - ++simulcast_svc_idx) { + for (size_t i = 0; i < num_simulcast_or_spatial_layers_; ++i) { decode_callback_.push_back( - rtc::MakeUnique( - this, simulcast_svc_idx)); - RTC_CHECK_EQ(decoders_->at(simulcast_svc_idx) - ->InitDecode(&config_.codec_settings, - static_cast(config_.NumberOfCores())), - WEBRTC_VIDEO_CODEC_OK); - RTC_CHECK_EQ(decoders_->at(simulcast_svc_idx) - ->RegisterDecodeCompleteCallback( - decode_callback_.at(simulcast_svc_idx).get()), + rtc::MakeUnique(this, i)); + RTC_CHECK_EQ( + decoders_->at(i)->InitDecode(&config_.codec_settings, + static_cast(config_.NumberOfCores())), + WEBRTC_VIDEO_CODEC_OK); + RTC_CHECK_EQ(decoders_->at(i)->RegisterDecodeCompleteCallback( + decode_callback_.at(i).get()), WEBRTC_VIDEO_CODEC_OK); } } @@ -238,10 +234,8 @@ VideoProcessor::~VideoProcessor() { RTC_CHECK_LE(input_frames_.size(), kMaxBufferedInputFrames); // Deal with manual memory management of EncodedImage's. - for (size_t simulcast_svc_idx = 0; - simulcast_svc_idx < num_simulcast_or_spatial_layers_; - ++simulcast_svc_idx) { - uint8_t* buffer = merged_encoded_frames_.at(simulcast_svc_idx)._buffer; + for (size_t i = 0; i < num_simulcast_or_spatial_layers_; ++i) { + uint8_t* buffer = merged_encoded_frames_.at(i)._buffer; if (buffer) { delete[] buffer; } @@ -270,20 +264,15 @@ void VideoProcessor::ProcessFrame() { post_encode_time_ns_ = 0; // Create frame statistics object for all simulcast/spatial layers. - for (size_t simulcast_svc_idx = 0; - simulcast_svc_idx < num_simulcast_or_spatial_layers_; - ++simulcast_svc_idx) { - stats_->AddFrame(timestamp, simulcast_svc_idx); + for (size_t i = 0; i < num_simulcast_or_spatial_layers_; ++i) { + stats_->AddFrame(timestamp, i); } // For the highest measurement accuracy of the encode time, the start/stop // time recordings should wrap the Encode call as tightly as possible. const int64_t encode_start_ns = rtc::TimeNanos(); - for (size_t simulcast_svc_idx = 0; - simulcast_svc_idx < num_simulcast_or_spatial_layers_; - ++simulcast_svc_idx) { - FrameStatistics* frame_stat = - stats_->GetFrame(frame_number, simulcast_svc_idx); + for (size_t i = 0; i < num_simulcast_or_spatial_layers_; ++i) { + FrameStatistics* frame_stat = stats_->GetFrame(frame_number, i); frame_stat->encode_start_ns = encode_start_ns; } @@ -292,11 +281,8 @@ void VideoProcessor::ProcessFrame() { config_.FrameTypeForFrame(frame_number); const int encode_return_code = encoder_->Encode(input_frame, nullptr, &frame_types); - for (size_t simulcast_svc_idx = 0; - simulcast_svc_idx < num_simulcast_or_spatial_layers_; - ++simulcast_svc_idx) { - FrameStatistics* frame_stat = - stats_->GetFrame(frame_number, simulcast_svc_idx); + for (size_t i = 0; i < num_simulcast_or_spatial_layers_; ++i) { + FrameStatistics* frame_stat = stats_->GetFrame(frame_number, i); frame_stat->encode_return_code = encode_return_code; } } @@ -327,45 +313,45 @@ void VideoProcessor::FrameEncoded( } // Layer metadata. - size_t simulcast_svc_idx = 0; + size_t spatial_idx = 0; size_t temporal_idx = 0; - GetLayerIndices(codec_specific, &simulcast_svc_idx, &temporal_idx); + GetLayerIndices(codec_specific, &spatial_idx, &temporal_idx); - FrameStatistics* frame_stat = stats_->GetFrameWithTimestamp( - encoded_image._timeStamp, simulcast_svc_idx); + FrameStatistics* frame_stat = + stats_->GetFrameWithTimestamp(encoded_image._timeStamp, spatial_idx); const size_t frame_number = frame_stat->frame_number; // Ensure that the encode order is monotonically increasing, within this // simulcast/spatial layer. - RTC_CHECK(first_encoded_frame_[simulcast_svc_idx] || - last_encoded_frame_num_[simulcast_svc_idx] < frame_number); + RTC_CHECK(first_encoded_frame_[spatial_idx] || + last_encoded_frame_num_[spatial_idx] < frame_number); // Ensure SVC spatial layers are delivered in ascending order. - if (!first_encoded_frame_[simulcast_svc_idx] && + if (!first_encoded_frame_[spatial_idx] && config_.NumberOfSpatialLayers() > 1) { - for (size_t i = 0; i < simulcast_svc_idx; ++i) { + for (size_t i = 0; i < spatial_idx; ++i) { RTC_CHECK_LE(last_encoded_frame_num_[i], frame_number); } - for (size_t i = simulcast_svc_idx + 1; i < num_simulcast_or_spatial_layers_; + for (size_t i = spatial_idx + 1; i < num_simulcast_or_spatial_layers_; ++i) { RTC_CHECK_GT(frame_number, last_encoded_frame_num_[i]); } } - first_encoded_frame_[simulcast_svc_idx] = false; - last_encoded_frame_num_[simulcast_svc_idx] = frame_number; + first_encoded_frame_[spatial_idx] = false; + last_encoded_frame_num_[spatial_idx] = frame_number; // Update frame statistics. frame_stat->encoding_successful = true; frame_stat->encode_time_us = GetElapsedTimeMicroseconds( frame_stat->encode_start_ns, encode_stop_ns - post_encode_time_ns_); - frame_stat->target_bitrate_kbps = (bitrate_allocation_.GetTemporalLayerSum( - simulcast_svc_idx, temporal_idx) + - 500) / - 1000; + frame_stat->target_bitrate_kbps = + (bitrate_allocation_.GetTemporalLayerSum(spatial_idx, temporal_idx) + + 500) / + 1000; frame_stat->length_bytes = encoded_image._length; frame_stat->frame_type = encoded_image._frameType; - frame_stat->temporal_layer_idx = temporal_idx; - frame_stat->simulcast_svc_idx = simulcast_svc_idx; + frame_stat->temporal_idx = temporal_idx; + frame_stat->spatial_idx = spatial_idx; frame_stat->max_nalu_size_bytes = GetMaxNaluSizeBytes(encoded_image, config_); frame_stat->qp = encoded_image.qp_; @@ -384,31 +370,29 @@ void VideoProcessor::FrameEncoded( if (config_.decode || encoded_frame_writers_) { if (num_spatial_layers > 1) { encoded_image_for_decode = BuildAndStoreSuperframe( - encoded_image, codec_type, frame_number, simulcast_svc_idx, + encoded_image, codec_type, frame_number, spatial_idx, frame_stat->inter_layer_predicted); } } if (config_.decode) { - DecodeFrame(*encoded_image_for_decode, simulcast_svc_idx); + DecodeFrame(*encoded_image_for_decode, spatial_idx); if (end_of_superframe && inter_layer_prediction) { // If inter-layer prediction is enabled and upper layer was dropped then // base layer should be passed to upper layer decoder. Otherwise decoder // won't be able to decode next superframe. const EncodedImage* base_image = nullptr; - for (size_t spatial_idx = 0; spatial_idx < num_spatial_layers; - ++spatial_idx) { - const bool layer_dropped = - last_decoded_frame_num_[spatial_idx] < frame_number; + for (size_t i = 0; i < num_spatial_layers; ++i) { + const bool layer_dropped = last_decoded_frame_num_[i] < frame_number; // Ensure current layer was decoded. - RTC_CHECK(layer_dropped == false || spatial_idx != simulcast_svc_idx); + RTC_CHECK(layer_dropped == false || i != spatial_idx); if (!layer_dropped) { - base_image = &merged_encoded_frames_[spatial_idx]; + base_image = &merged_encoded_frames_[i]; } else if (base_image) { - DecodeFrame(*base_image, spatial_idx); + DecodeFrame(*base_image, i); } } } @@ -417,7 +401,7 @@ void VideoProcessor::FrameEncoded( } if (encoded_frame_writers_) { - RTC_CHECK(encoded_frame_writers_->at(simulcast_svc_idx) + RTC_CHECK(encoded_frame_writers_->at(spatial_idx) ->WriteFrame(*encoded_image_for_decode, config_.codec_settings.codecType)); } @@ -430,23 +414,23 @@ void VideoProcessor::FrameEncoded( } void VideoProcessor::FrameDecoded(const VideoFrame& decoded_frame, - size_t simulcast_svc_idx) { + size_t spatial_idx) { RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_); // For the highest measurement accuracy of the decode time, the start/stop // time recordings should wrap the Decode call as tightly as possible. const int64_t decode_stop_ns = rtc::TimeNanos(); - FrameStatistics* frame_stat = stats_->GetFrameWithTimestamp( - decoded_frame.timestamp(), simulcast_svc_idx); + FrameStatistics* frame_stat = + stats_->GetFrameWithTimestamp(decoded_frame.timestamp(), spatial_idx); const size_t frame_number = frame_stat->frame_number; // Ensure that the decode order is monotonically increasing, within this // simulcast/spatial layer. - RTC_CHECK(first_decoded_frame_[simulcast_svc_idx] || - last_decoded_frame_num_[simulcast_svc_idx] < frame_number); - first_decoded_frame_[simulcast_svc_idx] = false; - last_decoded_frame_num_[simulcast_svc_idx] = frame_number; + RTC_CHECK(first_decoded_frame_[spatial_idx] || + last_decoded_frame_num_[spatial_idx] < frame_number); + first_decoded_frame_[spatial_idx] = false; + last_decoded_frame_num_[spatial_idx] = frame_number; // Update frame statistics. frame_stat->decoding_successful = true; @@ -483,28 +467,28 @@ void VideoProcessor::FrameDecoded(const VideoFrame& decoded_frame, ExtractI420BufferWithSize(decoded_frame, config_.codec_settings.width, config_.codec_settings.height, &tmp_i420_buffer_); RTC_CHECK_EQ(tmp_i420_buffer_.size(), - decoded_frame_writers_->at(simulcast_svc_idx)->FrameLength()); - RTC_CHECK(decoded_frame_writers_->at(simulcast_svc_idx) + decoded_frame_writers_->at(spatial_idx)->FrameLength()); + RTC_CHECK(decoded_frame_writers_->at(spatial_idx) ->WriteFrame(tmp_i420_buffer_.data())); } } void VideoProcessor::DecodeFrame(const EncodedImage& encoded_image, - size_t simulcast_svc_idx) { + size_t spatial_idx) { RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_); - FrameStatistics* frame_stat = stats_->GetFrameWithTimestamp( - encoded_image._timeStamp, simulcast_svc_idx); + FrameStatistics* frame_stat = + stats_->GetFrameWithTimestamp(encoded_image._timeStamp, spatial_idx); frame_stat->decode_start_ns = rtc::TimeNanos(); frame_stat->decode_return_code = - decoders_->at(simulcast_svc_idx)->Decode(encoded_image, false, nullptr); + decoders_->at(spatial_idx)->Decode(encoded_image, false, nullptr); } const webrtc::EncodedImage* VideoProcessor::BuildAndStoreSuperframe( const EncodedImage& encoded_image, const VideoCodecType codec, size_t frame_number, - size_t simulcast_svc_idx, + size_t spatial_idx, bool inter_layer_predicted) { // Should only be called for SVC. RTC_CHECK_GT(config_.NumberOfSpatialLayers(), 1); @@ -515,7 +499,7 @@ const webrtc::EncodedImage* VideoProcessor::BuildAndStoreSuperframe( // Each SVC layer is decoded with dedicated decoder. Find the nearest // non-dropped base frame and merge it and current frame into superframe. if (inter_layer_predicted) { - for (int base_idx = static_cast(simulcast_svc_idx) - 1; base_idx >= 0; + for (int base_idx = static_cast(spatial_idx) - 1; base_idx >= 0; --base_idx) { EncodedImage lower_layer = merged_encoded_frames_.at(base_idx); if (lower_layer._timeStamp == encoded_image._timeStamp) { @@ -545,13 +529,13 @@ const webrtc::EncodedImage* VideoProcessor::BuildAndStoreSuperframe( copied_image._size = buffer_size_bytes; // Replace previous EncodedImage for this spatial layer. - uint8_t* old_buffer = merged_encoded_frames_.at(simulcast_svc_idx)._buffer; + uint8_t* old_buffer = merged_encoded_frames_.at(spatial_idx)._buffer; if (old_buffer) { delete[] old_buffer; } - merged_encoded_frames_.at(simulcast_svc_idx) = copied_image; + merged_encoded_frames_.at(spatial_idx) = copied_image; - return &merged_encoded_frames_.at(simulcast_svc_idx); + return &merged_encoded_frames_.at(spatial_idx); } } // namespace test diff --git a/modules/video_coding/codecs/test/videoprocessor_integrationtest_libvpx.cc b/modules/video_coding/codecs/test/videoprocessor_integrationtest_libvpx.cc index cfe5efe319..5eb7df7c7d 100644 --- a/modules/video_coding/codecs/test/videoprocessor_integrationtest_libvpx.cc +++ b/modules/video_coding/codecs/test/videoprocessor_integrationtest_libvpx.cc @@ -53,20 +53,23 @@ class VideoProcessorIntegrationTestLibvpx void PrintRdPerf(std::map> rd_stats) { printf("--> Summary\n"); - printf("%11s %5s %6s %13s %13s %5s %7s %7s %7s %13s %13s\n", "uplink_kbps", - "width", "height", "downlink_kbps", "framerate_fps", "psnr", - "psnr_y", "psnr_u", "psnr_v", "enc_speed_fps", "dec_speed_fps"); + printf("%11s %5s %6s %11s %12s %11s %13s %13s %5s %7s %7s %7s %13s %13s\n", + "uplink_kbps", "width", "height", "spatial_idx", "temporal_idx", + "target_kbps", "downlink_kbps", "framerate_fps", "psnr", "psnr_y", + "psnr_u", "psnr_v", "enc_speed_fps", "dec_speed_fps"); for (const auto& rd_stat : rd_stats) { const size_t bitrate_kbps = rd_stat.first; for (const auto& layer_stat : rd_stat.second) { printf( - "%11zu %5zu %6zu %13zu %13.2f %5.2f %7.2f %7.2f %7.2f %13.2f " - "%13.2f\n", + "%11zu %5zu %6zu %11zu %12zu %11zu %13zu %13.2f %5.2f %7.2f %7.2f " + "%7.2f" + "%13.2f %13.2f\n", bitrate_kbps, layer_stat.width, layer_stat.height, - layer_stat.bitrate_kbps, layer_stat.framerate_fps, - layer_stat.avg_psnr, layer_stat.avg_psnr_y, layer_stat.avg_psnr_u, - layer_stat.avg_psnr_v, layer_stat.enc_speed_fps, - layer_stat.dec_speed_fps); + layer_stat.spatial_idx, layer_stat.temporal_idx, + layer_stat.target_bitrate_kbps, layer_stat.bitrate_kbps, + layer_stat.framerate_fps, layer_stat.avg_psnr, + layer_stat.avg_psnr_y, layer_stat.avg_psnr_u, layer_stat.avg_psnr_v, + layer_stat.enc_speed_fps, layer_stat.dec_speed_fps); } } }