admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert "Move rtp-specific config out of EncoderSettings."

Browse Source 
This reverts commit bc900cb1d1810fcf678fe41cf1e3966daa39c88c.

Reason for revert: Broke downstream projects.

Original change's description:
> Move rtp-specific config out of EncoderSettings.
> 
> In VideoSendStream::Config, move payload_name and payload_type from
> EncoderSettings to Rtp.
> 
> EncoderSettings now contains configuration for VideoStreamEncoder only,
> and should perhaps be renamed in a follow up cl. It's no longer
> passed as an argument to VideoCodecInitializer::SetupCodec.
> 
> The latter then needs a different way to know the codec type,
> which is provided by a new codec_type member in VideoEncoderConfig.
> 
> Bug: webrtc:8830
> Change-Id: Ifcc691aef1ee6a95e43c0452c5e630d92a511cd6
> Reviewed-on: https://webrtc-review.googlesource.com/62062
> Commit-Queue: Niels Moller <nisse@webrtc.org>
> Reviewed-by: Magnus Jedvert <magjed@webrtc.org>
> Reviewed-by: Stefan Holmer <stefan@webrtc.org>
> Reviewed-by: Rasmus Brandt <brandtr@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#22532}

TBR=brandtr@webrtc.org,magjed@webrtc.org,nisse@webrtc.org,stefan@webrtc.org

Change-Id: I01f06c1fcf21eb2cd40dca7d4f268614200ee490
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: webrtc:8830
Reviewed-on: https://webrtc-review.googlesource.com/63720
Reviewed-by: Niels Moller <nisse@webrtc.org>
Commit-Queue: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#22537}
This commit is contained in:
Niels Moller 2018-03-21 13:53:41 +00:00 committed by Commit Bot
parent 247e0b4713
commit 92be1caf4f
33 changed files with 143 additions and 160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
call/bitrate_estimator_tests.cc
View File

@ -118,9 +118,10 @@ class BitrateEstimatorTest : public test::CallTest {
video_send_config_.rtp.ssrcs.push_back(kVideoSendSsrcs[0]);
// Encoders will be set separately per stream.
video_send_config_.encoder_settings.encoder = nullptr;
video_send_config_.rtp.payload_name = "FAKE";
video_send_config_.rtp.payload_type = kFakeVideoSendPayloadType;
test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config_);
video_send_config_.encoder_settings.payload_name = "FAKE";
video_send_config_.encoder_settings.payload_type =
kFakeVideoSendPayloadType;
test::FillEncoderConfiguration(1, &video_encoder_config_);
receive_config_ = VideoReceiveStream::Config(receive_transport_.get());
// receive_config_.decoders will be set by every stream separately.
@ -181,8 +182,10 @@ class BitrateEstimatorTest : public test::CallTest {
VideoReceiveStream::Decoder decoder;
decoder.decoder = &fake_decoder_;
decoder.payload_type = test_->video_send_config_.rtp.payload_type;
decoder.payload_name = test_->video_send_config_.rtp.payload_name;
decoder.payload_type =
test_->video_send_config_.encoder_settings.payload_type;
decoder.payload_name =
test_->video_send_config_.encoder_settings.payload_name;
test_->receive_config_.decoders.clear();
test_->receive_config_.decoders.push_back(decoder);
test_->receive_config_.rtp.remote_ssrc =

4
call/call.cc
View File

@ -133,8 +133,8 @@ std::unique_ptr<rtclog::StreamConfig> CreateRtcLogStreamConfig(
rtclog_config->rtcp_mode = config.rtp.rtcp_mode;
rtclog_config->rtp_extensions = config.rtp.extensions;
rtclog_config->codecs.emplace_back(config.rtp.payload_name,
config.rtp.payload_type,
rtclog_config->codecs.emplace_back(config.encoder_settings.payload_name,
config.encoder_settings.payload_type,
config.rtp.rtx.payload_type);
return rtclog_config;
}

2
call/rampup_tests.cc
View File

@ -219,7 +219,7 @@ void RampUpTester::ModifyVideoConfigs(
recv_config.rtp.rtx_ssrc = video_rtx_ssrcs_[i];
recv_config.rtp
.rtx_associated_payload_types[send_config->rtp.rtx.payload_type] =
send_config->rtp.payload_type;
send_config->encoder_settings.payload_type;
}
++i;
}

7
call/video_config.cc
View File

@ -46,8 +46,7 @@ std::string VideoStream::ToString() const {
}
VideoEncoderConfig::VideoEncoderConfig()
: codec_type(kVideoCodecUnknown),
content_type(ContentType::kRealtimeVideo),
: content_type(ContentType::kRealtimeVideo),
encoder_specific_settings(nullptr),
min_transmit_bitrate_bps(0),
max_bitrate_bps(0),
@ -60,9 +59,7 @@ VideoEncoderConfig::~VideoEncoderConfig() = default;
std::string VideoEncoderConfig::ToString() const {
std::stringstream ss;
ss << "{codec_type: ";
ss << CodecTypeToPayloadString(codec_type);
ss << ", content_type: ";
ss << "{content_type: ";
switch (content_type) {
case ContentType::kRealtimeVideo:
ss << "kRealtimeVideo";

1
call/video_config.h
View File

@ -126,7 +126,6 @@ class VideoEncoderConfig {
~VideoEncoderConfig();
std::string ToString() const;
VideoCodecType codec_type;
rtc::scoped_refptr<VideoStreamFactoryInterface> video_stream_factory;
std::vector<SpatialLayer> spatial_layers;
ContentType content_type;

6
call/video_send_stream.cc
View File

@ -86,7 +86,9 @@ std::string VideoSendStream::Config::ToString() const {
std::string VideoSendStream::Config::EncoderSettings::ToString() const {
std::stringstream ss;
ss << "{encoder: " << (encoder ? "(VideoEncoder)" : "nullptr");
ss << "{payload_name: " << payload_name;
ss << ", payload_type: " << payload_type;
ss << ", encoder: " << (encoder ? "(VideoEncoder)" : "nullptr");
ss << '}';
return ss.str();
}
@ -122,8 +124,6 @@ std::string VideoSendStream::Config::Rtp::ToString() const {
ss << ", nack: {rtp_history_ms: " << nack.rtp_history_ms << '}';
ss << ", ulpfec: " << ulpfec.ToString();
ss << ", payload_name: " << payload_name;
ss << ", payload_type: " << payload_type;
ss << ", flexfec: {payload_type: " << flexfec.payload_type;
ss << ", ssrc: " << flexfec.ssrc;

20
call/video_send_stream.h
View File

@ -112,9 +112,17 @@ class VideoSendStream {
struct EncoderSettings {
EncoderSettings() = default;
explicit EncoderSettings(VideoEncoder* encoder) : encoder(encoder) {}
EncoderSettings(std::string payload_name,
int payload_type,
VideoEncoder* encoder)
: payload_name(std::move(payload_name)),
payload_type(payload_type),
encoder(encoder) {}
std::string ToString() const;
std::string payload_name;
int payload_type = -1;
// TODO(sophiechang): Delete this field when no one is using internal
// sources anymore.
bool internal_source = false;
@ -151,16 +159,6 @@ class VideoSendStream {
// RTP header extensions to use for this send stream.
std::vector<RtpExtension> extensions;
// TODO(nisse): For now, these are fixed, but we'd like to support
// changing codec without recreating the VideoSendStream. Then these
// fields must be removed, and association between payload type and codec
// must move above the per-stream level. Ownership could be with
// RtpTransportControllerSend, with a reference from PayloadRouter, where
// the latter would be responsible for mapping the codec type of encoded
// images to the right payload type.
std::string payload_name;
int payload_type = -1;
// See NackConfig for description.
NackConfig nack;

6
media/engine/fakewebrtccall.cc
View File

@ -229,19 +229,19 @@ void FakeVideoSendStream::ReconfigureVideoEncoder(
if (config.encoder_specific_settings != NULL) {
const unsigned char num_temporal_layers = static_cast<unsigned char>(
video_streams_.back().num_temporal_layers.value_or(1));
if (config_.rtp.payload_name == "VP8") {
if (config_.encoder_settings.payload_name == "VP8") {
config.encoder_specific_settings->FillVideoCodecVp8(&vpx_settings_.vp8);
if (!video_streams_.empty()) {
vpx_settings_.vp8.numberOfTemporalLayers = num_temporal_layers;
}
} else if (config_.rtp.payload_name == "VP9") {
} else if (config_.encoder_settings.payload_name == "VP9") {
config.encoder_specific_settings->FillVideoCodecVp9(&vpx_settings_.vp9);
if (!video_streams_.empty()) {
vpx_settings_.vp9.numberOfTemporalLayers = num_temporal_layers;
}
} else {
ADD_FAILURE() << "Unsupported encoder payload: "
<< config_.rtp.payload_name;
<< config_.encoder_settings.payload_name;
}
}
codec_settings_set_ = config.encoder_specific_settings != NULL;

6
media/engine/webrtcvideoengine.cc
View File

@ -1734,8 +1734,8 @@ void WebRtcVideoChannel::WebRtcVideoSendStream::SetCodec(
parameters_.config.encoder_settings.internal_source =
info.has_internal_source;
parameters_.config.rtp.payload_name = codec_settings.codec.name;
parameters_.config.rtp.payload_type = codec_settings.codec.id;
parameters_.config.encoder_settings.payload_name = codec_settings.codec.name;
parameters_.config.encoder_settings.payload_type = codec_settings.codec.id;
parameters_.config.rtp.ulpfec = codec_settings.ulpfec;
parameters_.config.rtp.flexfec.payload_type =
codec_settings.flexfec_payload_type;
@ -1887,8 +1887,6 @@ WebRtcVideoChannel::WebRtcVideoSendStream::CreateVideoEncoderConfig(
const VideoCodec& codec) const {
RTC_DCHECK_RUN_ON(&thread_checker_);
webrtc::VideoEncoderConfig encoder_config;
encoder_config.codec_type = webrtc::PayloadStringToCodecType(codec.name);
bool is_screencast = parameters_.options.is_screencast.value_or(false);
if (is_screencast) {
encoder_config.min_transmit_bitrate_bps =

2
media/engine/webrtcvideoengine_unittest.cc
View File

@ -133,7 +133,7 @@ rtc::scoped_refptr<webrtc::VideoFrameBuffer> CreateBlackFrameBuffer(
void VerifySendStreamHasRtxTypes(const webrtc::VideoSendStream::Config& config,
const std::map<int, int>& rtx_types) {
std::map<int, int>::const_iterator it;
it = rtx_types.find(config.rtp.payload_type);
it = rtx_types.find(config.encoder_settings.payload_type);
EXPECT_TRUE(it != rtx_types.end() &&
it->second == config.rtp.rtx.payload_type);

5
modules/video_coding/include/video_codec_initializer.h
View File

@ -15,7 +15,7 @@
#include <string>
#include <vector>
#include "call/video_config.h"
#include "call/video_send_stream.h"
namespace webrtc {
@ -33,6 +33,7 @@ class VideoCodecInitializer {
// GetBitrateAllocator is called implicitly from here, no need to call again.
static bool SetupCodec(
const VideoEncoderConfig& config,
const VideoSendStream::Config::EncoderSettings settings,
const std::vector<VideoStream>& streams,
bool nack_enabled,
VideoCodec* codec,
@ -48,6 +49,8 @@ class VideoCodecInitializer {
static VideoCodec VideoEncoderConfigToVideoCodec(
const VideoEncoderConfig& config,
const std::vector<VideoStream>& streams,
const std::string& payload_name,
int payload_type,
bool nack_enabled);
};

24
modules/video_coding/video_codec_initializer.cc
View File

@ -26,15 +26,18 @@ namespace webrtc {
bool VideoCodecInitializer::SetupCodec(
const VideoEncoderConfig& config,
const VideoSendStream::Config::EncoderSettings settings,
const std::vector<VideoStream>& streams,
bool nack_enabled,
VideoCodec* codec,
std::unique_ptr<VideoBitrateAllocator>* bitrate_allocator) {
if (config.codec_type == kVideoCodecMultiplex) {
VideoEncoderConfig associated_config = config.Copy();
associated_config.codec_type = kVideoCodecVP9;
if (!SetupCodec(associated_config, streams, nack_enabled, codec,
bitrate_allocator)) {
if (PayloadStringToCodecType(settings.payload_name) == kVideoCodecMultiplex) {
VideoSendStream::Config::EncoderSettings associated_codec_settings =
settings;
associated_codec_settings.payload_name =
CodecTypeToPayloadString(kVideoCodecVP9);
if (!SetupCodec(config, associated_codec_settings, streams, nack_enabled,
codec, bitrate_allocator)) {
RTC_LOG(LS_ERROR) << "Failed to create stereo encoder configuration.";
return false;
}
@ -43,7 +46,8 @@ bool VideoCodecInitializer::SetupCodec(
}
*codec =
VideoEncoderConfigToVideoCodec(config, streams, nack_enabled);
VideoEncoderConfigToVideoCodec(config, streams, settings.payload_name,
settings.payload_type, nack_enabled);
*bitrate_allocator = CreateBitrateAllocator(*codec);
return true;
@ -69,6 +73,8 @@ VideoCodecInitializer::CreateBitrateAllocator(const VideoCodec& codec) {
VideoCodec VideoCodecInitializer::VideoEncoderConfigToVideoCodec(
const VideoEncoderConfig& config,
const std::vector<VideoStream>& streams,
const std::string& payload_name,
int payload_type,
bool nack_enabled) {
static const int kEncoderMinBitrateKbps = 30;
RTC_DCHECK(!streams.empty());
@ -76,7 +82,7 @@ VideoCodec VideoCodecInitializer::VideoEncoderConfigToVideoCodec(
VideoCodec video_codec;
memset(&video_codec, 0, sizeof(video_codec));
video_codec.codecType = config.codec_type;
video_codec.codecType = PayloadStringToCodecType(payload_name);
switch (config.content_type) {
case VideoEncoderConfig::ContentType::kRealtimeVideo:
@ -149,9 +155,7 @@ VideoCodec VideoCodecInitializer::VideoEncoderConfigToVideoCodec(
break;
}
// TODO(nisse): The plType field should be deleted. Luckily, our
// callers don't need it.
video_codec.plType = 0;
video_codec.plType = payload_type;
video_codec.numberOfSimulcastStreams =
static_cast<unsigned char>(streams.size());
video_codec.minBitrate = streams[0].min_bitrate_bps / 1000;

11
modules/video_coding/video_codec_initializer_unittest.cc
View File

@ -19,6 +19,8 @@
namespace webrtc {
namespace {
static const char* kVp8PayloadName = "VP8";
static const int kVp8PayloadType = 100;
static const int kDefaultWidth = 1280;
static const int kDefaultHeight = 720;
static const int kDefaultFrameRate = 30;
@ -47,8 +49,6 @@ class VideoCodecInitializerTest : public ::testing::Test {
int num_temporal_streams,
bool screenshare) {
config_ = VideoEncoderConfig();
config_.codec_type = type;
if (screenshare) {
config_.min_transmit_bitrate_bps = kDefaultMinTransmitBitrateBps;
config_.content_type = VideoEncoderConfig::ContentType::kScreen;
@ -60,6 +60,8 @@ class VideoCodecInitializerTest : public ::testing::Test {
vp8_settings.numberOfTemporalLayers = num_temporal_streams;
config_.encoder_specific_settings = new rtc::RefCountedObject<
webrtc::VideoEncoderConfig::Vp8EncoderSpecificSettings>(vp8_settings);
settings_.payload_name = kVp8PayloadName;
settings_.payload_type = kVp8PayloadType;
} else if (type == VideoCodecType::kVideoCodecMultiplex) {
} else {
ADD_FAILURE() << "Unexpected codec type: " << type;
@ -70,8 +72,8 @@ class VideoCodecInitializerTest : public ::testing::Test {
codec_out_ = VideoCodec();
bitrate_allocator_out_.reset();
temporal_layers_.clear();
if (!VideoCodecInitializer::SetupCodec(config_, streams_, nack_enabled_,
&codec_out_,
if (!VideoCodecInitializer::SetupCodec(config_, settings_, streams_,
nack_enabled_, &codec_out_,
&bitrate_allocator_out_)) {
return false;
}
@ -115,6 +117,7 @@ class VideoCodecInitializerTest : public ::testing::Test {
// Input settings.
VideoEncoderConfig config_;
VideoSendStream::Config::EncoderSettings settings_;
std::vector<VideoStream> streams_;
bool nack_enabled_;

9
test/call_test.cc
View File

@ -194,15 +194,14 @@ void CallTest::CreateVideoSendConfig(VideoSendStream::Config* video_config,
RTC_DCHECK_LE(num_video_streams + num_used_ssrcs, kNumSsrcs);
*video_config = VideoSendStream::Config(send_transport);
video_config->encoder_settings.encoder = &fake_encoder_;
video_config->rtp.payload_name = "FAKE";
video_config->rtp.payload_type = kFakeVideoSendPayloadType;
video_config->encoder_settings.payload_name = "FAKE";
video_config->encoder_settings.payload_type = kFakeVideoSendPayloadType;
video_config->rtp.extensions.push_back(
RtpExtension(RtpExtension::kTransportSequenceNumberUri,
kTransportSequenceNumberExtensionId));
video_config->rtp.extensions.push_back(RtpExtension(
RtpExtension::kVideoContentTypeUri, kVideoContentTypeExtensionId));
FillEncoderConfiguration(kVideoCodecVP8, num_video_streams,
&video_encoder_config_);
FillEncoderConfiguration(num_video_streams, &video_encoder_config_);
for (size_t i = 0; i < num_video_streams; ++i)
video_config->rtp.ssrcs.push_back(kVideoSendSsrcs[num_used_ssrcs + i]);
@ -258,7 +257,7 @@ CallTest::CreateMatchingVideoReceiveConfigs(
video_config.renderer = &fake_renderer_;
for (size_t i = 0; i < video_send_config.rtp.ssrcs.size(); ++i) {
VideoReceiveStream::Decoder decoder =
test::CreateMatchingDecoder(video_send_config);
test::CreateMatchingDecoder(video_send_config.encoder_settings);
allocated_decoders_.push_back(
std::unique_ptr<VideoDecoder>(decoder.decoder));
video_config.decoders.clear();

25
test/encoder_settings.cc
View File

@ -78,12 +78,10 @@ std::vector<VideoStream> DefaultVideoStreamFactory::CreateEncoderStreams(
return CreateVideoStreams(width, height, encoder_config);
}
void FillEncoderConfiguration(VideoCodecType codec_type,
size_t num_streams,
void FillEncoderConfiguration(size_t num_streams,
VideoEncoderConfig* configuration) {
RTC_DCHECK_LE(num_streams, DefaultVideoStreamFactory::kMaxNumberOfStreams);
configuration->codec_type = codec_type;
configuration->number_of_streams = num_streams;
configuration->video_stream_factory =
new rtc::RefCountedObject<DefaultVideoStreamFactory>();
@ -96,17 +94,17 @@ void FillEncoderConfiguration(VideoCodecType codec_type,
}
VideoReceiveStream::Decoder CreateMatchingDecoder(
int payload_type, const std::string& payload_name) {
const VideoSendStream::Config::EncoderSettings& encoder_settings) {
VideoReceiveStream::Decoder decoder;
decoder.payload_type = payload_type;
decoder.payload_name = payload_name;
if (payload_name == "H264") {
decoder.payload_type = encoder_settings.payload_type;
decoder.payload_name = encoder_settings.payload_name;
if (encoder_settings.payload_name == "H264") {
decoder.decoder = H264Decoder::Create().release();
} else if (payload_name == "VP8") {
} else if (encoder_settings.payload_name == "VP8") {
decoder.decoder = VP8Decoder::Create().release();
} else if (payload_name == "VP9") {
} else if (encoder_settings.payload_name == "VP9") {
decoder.decoder = VP9Decoder::Create().release();
} else if (payload_name == "multiplex") {
} else if (encoder_settings.payload_name == "multiplex") {
decoder.decoder = new MultiplexDecoderAdapter(
new InternalDecoderFactory(), SdpVideoFormat(cricket::kVp9CodecName));
} else {
@ -114,12 +112,5 @@ VideoReceiveStream::Decoder CreateMatchingDecoder(
}
return decoder;
}
VideoReceiveStream::Decoder CreateMatchingDecoder(
const VideoSendStream::Config& config) {
return CreateMatchingDecoder(config.rtp.payload_type,
config.rtp.payload_name);
}
} // namespace test
} // namespace webrtc

7
test/encoder_settings.h
View File

@ -45,14 +45,11 @@ std::vector<VideoStream> CreateVideoStreams(
int height,
const webrtc::VideoEncoderConfig& encoder_config);
void FillEncoderConfiguration(VideoCodecType codec_type, size_t num_streams,
void FillEncoderConfiguration(size_t num_streams,
VideoEncoderConfig* configuration);
VideoReceiveStream::Decoder CreateMatchingDecoder(
int payload_type, const std::string& payload_name);
VideoReceiveStream::Decoder CreateMatchingDecoder(
const VideoSendStream::Config& config);
const VideoSendStream::Config::EncoderSettings& encoder_settings);
} // namespace test
} // namespace webrtc

14
video/encoder_rtcp_feedback_unittest.cc
View File

@ -24,13 +24,13 @@ namespace webrtc {
class MockVideoStreamEncoder : public VideoStreamEncoder {
public:
explicit MockVideoStreamEncoder(SendStatisticsProxy* send_stats_proxy)
: VideoStreamEncoder(
1,
send_stats_proxy,
VideoSendStream::Config::EncoderSettings(nullptr),
nullptr,
rtc::MakeUnique<OveruseFrameDetector>(CpuOveruseOptions(),
nullptr)) {}
: VideoStreamEncoder(1,
send_stats_proxy,
VideoSendStream::Config::EncoderSettings("fake", 0,
nullptr),
nullptr,
rtc::MakeUnique<OveruseFrameDetector>(
CpuOveruseOptions(), nullptr)) {}
~MockVideoStreamEncoder() { Stop(); }
MOCK_METHOD0(SendKeyFrame, void());

10
video/end_to_end_tests/codec_tests.cc
View File

@ -68,17 +68,17 @@ class CodecObserver : public test::EndToEndTest,
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
encoder_config->codec_type = PayloadStringToCodecType(payload_name_);
send_config->encoder_settings.encoder = encoder_.get();
send_config->rtp.payload_name = payload_name_;
send_config->rtp.payload_type = test::CallTest::kVideoSendPayloadType;
send_config->encoder_settings.payload_name = payload_name_;
send_config->encoder_settings.payload_type =
test::CallTest::kVideoSendPayloadType;
(*receive_configs)[0].renderer = this;
(*receive_configs)[0].decoders.resize(1);
(*receive_configs)[0].decoders[0].payload_type =
send_config->rtp.payload_type;
send_config->encoder_settings.payload_type;
(*receive_configs)[0].decoders[0].payload_name =
send_config->rtp.payload_name;
send_config->encoder_settings.payload_name;
(*receive_configs)[0].decoders[0].decoder = decoder_.get();
}

6
video/end_to_end_tests/extended_reports_tests.cc
View File

@ -132,12 +132,12 @@ class RtcpXrObserver : public test::EndToEndTest {
new rtc::RefCountedObject<ZeroTargetVideoStreamFactory>();
// Configure VP8 to be able to use simulcast.
send_config->rtp.payload_name = "VP8";
send_config->encoder_settings.payload_name = "VP8";
(*receive_configs)[0].decoders.resize(1);
(*receive_configs)[0].decoders[0].payload_type =
send_config->rtp.payload_type;
send_config->encoder_settings.payload_type;
(*receive_configs)[0].decoders[0].payload_name =
send_config->rtp.payload_name;
send_config->encoder_settings.payload_name;
}
if (enable_target_bitrate_) {
// TargetBitrate only signaled for screensharing.

14
video/end_to_end_tests/fec_tests.cc
View File

@ -103,10 +103,10 @@ TEST_P(FecEndToEndTest, ReceivesUlpfec) {
// Use VP8 instead of FAKE, since the latter does not have PictureID
// in the packetization headers.
send_config->encoder_settings.encoder = encoder_.get();
send_config->rtp.payload_name = "VP8";
send_config->rtp.payload_type = kVideoSendPayloadType;
send_config->encoder_settings.payload_name = "VP8";
send_config->encoder_settings.payload_type = kVideoSendPayloadType;
VideoReceiveStream::Decoder decoder =
test::CreateMatchingDecoder(*send_config);
test::CreateMatchingDecoder(send_config->encoder_settings);
decoder_.reset(decoder.decoder);
(*receive_configs)[0].decoders.clear();
(*receive_configs)[0].decoders.push_back(decoder);
@ -452,8 +452,8 @@ TEST_P(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) {
send_config->rtp.ulpfec.ulpfec_payload_type = kUlpfecPayloadType;
// Set codec to VP8, otherwise NACK/FEC hybrid will be disabled.
send_config->encoder_settings.encoder = encoder_.get();
send_config->rtp.payload_name = "VP8";
send_config->rtp.payload_type = kFakeVideoSendPayloadType;
send_config->encoder_settings.payload_name = "VP8";
send_config->encoder_settings.payload_type = kFakeVideoSendPayloadType;
(*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
(*receive_configs)[0].rtp.red_payload_type = kRedPayloadType;
@ -461,9 +461,9 @@ TEST_P(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) {
(*receive_configs)[0].decoders.resize(1);
(*receive_configs)[0].decoders[0].payload_type =
send_config->rtp.payload_type;
send_config->encoder_settings.payload_type;
(*receive_configs)[0].decoders[0].payload_name =
send_config->rtp.payload_name;
send_config->encoder_settings.payload_name;
(*receive_configs)[0].decoders[0].decoder = decoder_.get();
}

2
video/end_to_end_tests/histogram_tests.cc
View File

@ -89,7 +89,7 @@ void HistogramTest::VerifyHistogramStats(bool use_rtx,
send_config->rtp.ulpfec.ulpfec_payload_type = kUlpfecPayloadType;
send_config->rtp.ulpfec.red_payload_type = kRedPayloadType;
send_config->encoder_settings.encoder = vp8_encoder_.get();
send_config->rtp.payload_name = "VP8";
send_config->encoder_settings.payload_name = "VP8";
(*receive_configs)[0].decoders[0].payload_name = "VP8";
(*receive_configs)[0].rtp.red_payload_type = kRedPayloadType;
(*receive_configs)[0].rtp.ulpfec_payload_type = kUlpfecPayloadType;

6
video/end_to_end_tests/log_tests.cc
View File

@ -77,14 +77,14 @@ TEST_F(LogEndToEndTest, LogsEncodedFramesWhenRequested) {
decoder_ = VP8Decoder::Create();
send_config->post_encode_callback = this;
send_config->rtp.payload_name = "VP8";
send_config->encoder_settings.payload_name = "VP8";
send_config->encoder_settings.encoder = encoder_.get();
(*receive_configs)[0].decoders.resize(1);
(*receive_configs)[0].decoders[0].payload_type =
send_config->rtp.payload_type;
send_config->encoder_settings.payload_type;
(*receive_configs)[0].decoders[0].payload_name =
send_config->rtp.payload_name;
send_config->encoder_settings.payload_name;
(*receive_configs)[0].decoders[0].decoder = decoder_.get();
}

8
video/end_to_end_tests/multi_stream_tester.cc
View File

@ -72,10 +72,10 @@ void MultiStreamTester::RunTest() {
VideoSendStream::Config send_config(sender_transport.get());
send_config.rtp.ssrcs.push_back(ssrc);
send_config.encoder_settings.encoder = encoders[i].get();
send_config.rtp.payload_name = "VP8";
send_config.rtp.payload_type = kVideoPayloadType;
send_config.encoder_settings.payload_name = "VP8";
send_config.encoder_settings.payload_type = kVideoPayloadType;
VideoEncoderConfig encoder_config;
test::FillEncoderConfiguration(kVideoCodecVP8, 1, &encoder_config);
test::FillEncoderConfiguration(1, &encoder_config);
encoder_config.max_bitrate_bps = 100000;
UpdateSendConfig(i, &send_config, &encoder_config, &frame_generators[i]);
@ -88,7 +88,7 @@ void MultiStreamTester::RunTest() {
receive_config.rtp.remote_ssrc = ssrc;
receive_config.rtp.local_ssrc = test::CallTest::kReceiverLocalVideoSsrc;
VideoReceiveStream::Decoder decoder =
test::CreateMatchingDecoder(send_config);
test::CreateMatchingDecoder(send_config.encoder_settings);
allocated_decoders.push_back(
std::unique_ptr<VideoDecoder>(decoder.decoder));
receive_config.decoders.push_back(decoder);

2
video/end_to_end_tests/retransmission_tests.cc
View File

@ -438,7 +438,7 @@ void RetransmissionEndToEndTest::DecodesRetransmittedFrame(bool enable_rtx,
// doesn't support FEC with NACK.
RTC_DCHECK_EQ(1, (*receive_configs)[0].decoders.size());
send_config->encoder_settings.encoder = encoder_.get();
send_config->rtp.payload_name = "VP8";
send_config->encoder_settings.payload_name = "VP8";
(*receive_configs)[0].decoders[0].payload_name = "VP8";
}

4
video/end_to_end_tests/rtp_rtcp_tests.cc
View File

@ -496,8 +496,8 @@ TEST_F(RtpRtcpEndToEndTest, TestFlexfecRtpStatePreservation) {
send_transport.get());
encoder = VP8Encoder::Create();
video_send_config_.encoder_settings.encoder = encoder.get();
video_send_config_.rtp.payload_name = "VP8";
video_send_config_.rtp.payload_type = kVideoSendPayloadType;
video_send_config_.encoder_settings.payload_name = "VP8";
video_send_config_.encoder_settings.payload_type = kVideoSendPayloadType;
video_send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
video_send_config_.rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[0]);
video_send_config_.rtp.rtx.payload_type = kSendRtxPayloadType;

3
video/picture_id_tests.cc
View File

@ -308,8 +308,7 @@ void PictureIdTest::SetupEncoder(VideoEncoder* encoder,
CreateSendConfig(kNumSimulcastStreams, 0, 0, send_transport_.get());
video_send_config_.encoder_settings.encoder = encoder;
video_send_config_.rtp.payload_name = payload_name;
video_encoder_config_.codec_type = PayloadStringToCodecType(payload_name);
video_send_config_.encoder_settings.payload_name = payload_name;
video_encoder_config_.video_stream_factory =
new rtc::RefCountedObject<VideoStreamFactory>(num_temporal_layers_);
video_encoder_config_.number_of_streams = 1;

6
video/replay.cc
View File

@ -247,6 +247,9 @@ void RtpReplay() {
}
receive_config.renderer = &file_passthrough;
VideoSendStream::Config::EncoderSettings encoder_settings;
encoder_settings.payload_name = flags::Codec();
encoder_settings.payload_type = flags::MediaPayloadType();
VideoReceiveStream::Decoder decoder;
std::unique_ptr<DecoderBitstreamFileWriter> bitstream_writer;
if (!flags::DecoderBitstreamFilename().empty()) {
@ -254,8 +257,7 @@ void RtpReplay() {
flags::DecoderBitstreamFilename().c_str()));
receive_config.pre_decode_callback = bitstream_writer.get();
}
decoder = test::CreateMatchingDecoder(flags::MediaPayloadType(),
flags::Codec());
decoder = test::CreateMatchingDecoder(encoder_settings);
if (!flags::DecoderBitstreamFilename().empty()) {
// Replace with a null decoder if we're writing the bitstream to a file
// instead.

2
video/send_statistics_proxy.cc
View File

@ -126,7 +126,7 @@ SendStatisticsProxy::SendStatisticsProxy(
const VideoSendStream::Config& config,
VideoEncoderConfig::ContentType content_type)
: clock_(clock),
payload_name_(config.rtp.payload_name),
payload_name_(config.encoder_settings.payload_name),
rtp_config_(config.rtp),
fallback_max_pixels_(GetFallbackMaxPixelsIfFieldTrialEnabled()),
fallback_max_pixels_disabled_(GetFallbackMaxPixelsIfFieldTrialDisabled()),

23
video/video_quality_test.cc
View File

@ -1264,8 +1264,6 @@ void VideoQualityTest::FillScalabilitySettings(
if (params->ss[video_idx].streams.empty() &&
params->ss[video_idx].infer_streams) {
webrtc::VideoEncoderConfig encoder_config;
encoder_config.codec_type =
PayloadStringToCodecType(params->video[video_idx].codec);
encoder_config.content_type =
params->screenshare[video_idx].enabled
? webrtc::VideoEncoderConfig::ContentType::kScreen
@ -1399,9 +1397,9 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
}
video_send_configs_[video_idx].encoder_settings.encoder =
video_encoders_[video_idx].get();
video_send_configs_[video_idx].rtp.payload_name =
video_send_configs_[video_idx].encoder_settings.payload_name =
params_.video[video_idx].codec;
video_send_configs_[video_idx].rtp.payload_type = payload_type;
video_send_configs_[video_idx].encoder_settings.payload_type = payload_type;
video_send_configs_[video_idx].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
video_send_configs_[video_idx].rtp.rtx.payload_type = kSendRtxPayloadType;
for (size_t i = 0; i < num_video_substreams; ++i) {
@ -1423,9 +1421,6 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
video_send_configs_[video_idx].rtp.extensions.push_back(RtpExtension(
RtpExtension::kVideoTimingUri, test::kVideoTimingExtensionId));
video_encoder_configs_[video_idx].codec_type =
PayloadStringToCodecType(params_.video[video_idx].codec);
video_encoder_configs_[video_idx].min_transmit_bitrate_bps =
params_.video[video_idx].min_transmit_bps;
@ -1479,8 +1474,10 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
i != params_.ss[video_idx].selected_stream) {
VideoReceiveStream::Decoder decoder;
decoder.decoder = new test::FakeDecoder();
decoder.payload_type = video_send_configs_[video_idx].rtp.payload_type;
decoder.payload_name = video_send_configs_[video_idx].rtp.payload_name;
decoder.payload_type =
video_send_configs_[video_idx].encoder_settings.payload_type;
decoder.payload_name =
video_send_configs_[video_idx].encoder_settings.payload_name;
new_receive_configs[i].decoders.clear();
allocated_decoders_.emplace_back(decoder.decoder);
new_receive_configs[i].decoders.push_back(decoder);
@ -1615,8 +1612,9 @@ void VideoQualityTest::SetupThumbnails(Transport* send_transport,
thumbnail_send_config.rtp.ssrcs.push_back(kThumbnailSendSsrcStart + i);
thumbnail_send_config.encoder_settings.encoder =
thumbnail_encoders_.back().get();
thumbnail_send_config.rtp.payload_name = params_.video[0].codec;
thumbnail_send_config.rtp.payload_type = kPayloadTypeVP8;
thumbnail_send_config.encoder_settings.payload_name =
params_.video[0].codec;
thumbnail_send_config.encoder_settings.payload_type = kPayloadTypeVP8;
thumbnail_send_config.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
thumbnail_send_config.rtp.rtx.payload_type = kSendRtxPayloadType;
thumbnail_send_config.rtp.rtx.ssrcs.push_back(kThumbnailRtxSsrcStart + i);
@ -1631,7 +1629,6 @@ void VideoQualityTest::SetupThumbnails(Transport* send_transport,
}
VideoEncoderConfig thumbnail_encoder_config;
thumbnail_encoder_config.codec_type = kVideoCodecVP8;
thumbnail_encoder_config.min_transmit_bitrate_bps = 7500;
thumbnail_send_config.suspend_below_min_bitrate =
params_.video[0].suspend_below_min_bitrate;
@ -1658,7 +1655,7 @@ void VideoQualityTest::SetupThumbnails(Transport* send_transport,
thumbnail_receive_config.renderer = &fake_renderer_;
VideoReceiveStream::Decoder decoder =
test::CreateMatchingDecoder(thumbnail_send_config);
test::CreateMatchingDecoder(thumbnail_send_config.encoder_settings);
allocated_decoders_.push_back(
std::unique_ptr<VideoDecoder>(decoder.decoder));
thumbnail_receive_config.decoders.clear();

16
video/video_send_stream.cc
View File

@ -729,7 +729,7 @@ VideoSendStreamImpl::VideoSendStreamImpl(
transport->keepalive_config())),
payload_router_(rtp_rtcp_modules_,
config_->rtp.ssrcs,
config_->rtp.payload_type,
config_->encoder_settings.payload_type,
suspended_payload_states),
weak_ptr_factory_(this),
overhead_bytes_per_packet_(0),
@ -823,8 +823,9 @@ VideoSendStreamImpl::VideoSendStreamImpl(
rtp_rtcp->RegisterRtcpStatisticsCallback(stats_proxy_);
rtp_rtcp->RegisterSendChannelRtpStatisticsCallback(stats_proxy_);
rtp_rtcp->SetMaxRtpPacketSize(config_->rtp.max_packet_size);
rtp_rtcp->RegisterVideoSendPayload(config_->rtp.payload_type,
config_->rtp.payload_name.c_str());
rtp_rtcp->RegisterVideoSendPayload(
config_->encoder_settings.payload_type,
config_->encoder_settings.payload_name.c_str());
}
fec_controller_->SetProtectionCallback(this);
@ -834,8 +835,8 @@ VideoSendStreamImpl::VideoSendStreamImpl(
}
RTC_DCHECK(config_->encoder_settings.encoder);
RTC_DCHECK_GE(config_->rtp.payload_type, 0);
RTC_DCHECK_LE(config_->rtp.payload_type, 127);
RTC_DCHECK_GE(config_->encoder_settings.payload_type, 0);
RTC_DCHECK_LE(config_->encoder_settings.payload_type, 127);
video_stream_encoder_->SetStartBitrate(
bitrate_allocator_->GetStartBitrate(this));
@ -1128,7 +1129,8 @@ void VideoSendStreamImpl::ConfigureProtection() {
// is a waste of bandwidth since FEC packets still have to be transmitted.
// Note that this is not the case with FlexFEC.
if (nack_enabled && IsUlpfecEnabled() &&
!PayloadTypeSupportsSkippingFecPackets(config_->rtp.payload_name)) {
!PayloadTypeSupportsSkippingFecPackets(
config_->encoder_settings.payload_name)) {
RTC_LOG(LS_WARNING)
<< "Transmitting payload type without picture ID using "
"NACK+ULPFEC is a waste of bandwidth since ULPFEC packets "
@ -1206,7 +1208,7 @@ void VideoSendStreamImpl::ConfigureSsrcs() {
RTC_DCHECK_GE(config_->rtp.rtx.payload_type, 0);
for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
rtp_rtcp->SetRtxSendPayloadType(config_->rtp.rtx.payload_type,
config_->rtp.payload_type);
config_->encoder_settings.payload_type);
rtp_rtcp->SetRtxSendStatus(kRtxRetransmitted | kRtxRedundantPayloads);
}
if (config_->rtp.ulpfec.red_payload_type != -1 &&

19
video/video_send_stream_tests.cc
View File

@ -532,7 +532,7 @@ class UlpfecObserver : public test::EndToEndTest {
VideoSendStreamTest::kNackRtpHistoryMs;
}
send_config->encoder_settings.encoder = encoder_;
send_config->rtp.payload_name = payload_name_;
send_config->encoder_settings.payload_name = payload_name_;
send_config->rtp.ulpfec.red_payload_type =
VideoSendStreamTest::kRedPayloadType;
send_config->rtp.ulpfec.ulpfec_payload_type =
@ -709,7 +709,7 @@ class FlexfecObserver : public test::EndToEndTest {
VideoSendStreamTest::kNackRtpHistoryMs;
}
send_config->encoder_settings.encoder = encoder_;
send_config->rtp.payload_name = payload_name_;
send_config->encoder_settings.payload_name = payload_name_;
if (header_extensions_enabled_) {
send_config->rtp.extensions.push_back(RtpExtension(
RtpExtension::kAbsSendTimeUri, test::kAbsSendTimeExtensionId));
@ -718,7 +718,6 @@ class FlexfecObserver : public test::EndToEndTest {
} else {
send_config->rtp.extensions.clear();
}
encoder_config->codec_type = PayloadStringToCodecType(payload_name_);
}
void PerformTest() override {
@ -1074,7 +1073,7 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
}
if (!test_generic_packetization_)
send_config->rtp.payload_name = "VP8";
send_config->encoder_settings.payload_name = "VP8";
send_config->encoder_settings.encoder = &encoder_;
send_config->rtp.max_packet_size = kMaxPacketSize;
@ -2118,7 +2117,7 @@ TEST_F(VideoSendStreamTest, VideoSendStreamUpdateActiveSimulcastLayers) {
video_send_config_.encoder_settings.encoder = &encoder;
video_send_config_.encoder_settings.internal_source = true;
video_send_config_.rtp.payload_name = "VP8";
video_send_config_.encoder_settings.payload_name = "VP8";
CreateVideoStreams();
});
@ -2492,9 +2491,8 @@ class VideoCodecConfigObserver : public test::SendTest,
std::vector<VideoReceiveStream::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder = this;
send_config->rtp.payload_name = codec_name_;
send_config->encoder_settings.payload_name = codec_name_;
encoder_config->codec_type = video_codec_type_;
encoder_config->encoder_specific_settings = GetEncoderSpecificSettings();
encoder_config->video_stream_factory =
new rtc::RefCountedObject<VideoStreamFactory>();
@ -3067,8 +3065,8 @@ class Vp9HeaderObserver : public test::SendTest {
std::vector<VideoReceiveStream::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder = vp9_encoder_.get();
send_config->rtp.payload_name = "VP9";
send_config->rtp.payload_type = kVp9PayloadType;
send_config->encoder_settings.payload_name = "VP9";
send_config->encoder_settings.payload_type = kVp9PayloadType;
ModifyVideoConfigsHook(send_config, receive_configs, encoder_config);
encoder_config->encoder_specific_settings = new rtc::RefCountedObject<
VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings_);
@ -3391,7 +3389,6 @@ void VideoSendStreamTest::TestVp9NonFlexMode(uint8_t num_temporal_layers,
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
encoder_config->codec_type = kVideoCodecVP9;
vp9_settings_.flexibleMode = false;
vp9_settings_.frameDroppingOn = false;
vp9_settings_.keyFrameInterval = kKeyFrameInterval;
@ -3446,7 +3443,6 @@ TEST_F(VideoSendStreamTest, Vp9NonFlexModeSmallResolution) {
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
encoder_config->codec_type = kVideoCodecVP9;
vp9_settings_.flexibleMode = false;
vp9_settings_.numberOfTemporalLayers = 1;
vp9_settings_.numberOfSpatialLayers = 1;
@ -3484,7 +3480,6 @@ TEST_F(VideoSendStreamTest, MAYBE_Vp9FlexModeRefCount) {
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
encoder_config->codec_type = kVideoCodecVP9;
encoder_config->content_type = VideoEncoderConfig::ContentType::kScreen;
vp9_settings_.flexibleMode = true;
vp9_settings_.numberOfTemporalLayers = 1;

5
video/video_stream_encoder.cc
View File

@ -552,8 +552,9 @@ void VideoStreamEncoder::ReconfigureEncoder() {
crop_height_ = last_frame_info_->height - highest_stream_height;
VideoCodec codec;
if (!VideoCodecInitializer::SetupCodec(
encoder_config_, streams, nack_enabled_, &codec, &rate_allocator_)) {
if (!VideoCodecInitializer::SetupCodec(encoder_config_, settings_, streams,
nack_enabled_, &codec,
&rate_allocator_)) {
RTC_LOG(LS_ERROR) << "Failed to create encoder configuration.";
}

15
video/video_stream_encoder_unittest.cc
View File

@ -284,11 +284,11 @@ class VideoStreamEncoderTest : public ::testing::Test {
metrics::Reset();
video_send_config_ = VideoSendStream::Config(nullptr);
video_send_config_.encoder_settings.encoder = &fake_encoder_;
video_send_config_.rtp.payload_name = "FAKE";
video_send_config_.rtp.payload_type = 125;
video_send_config_.encoder_settings.payload_name = "FAKE";
video_send_config_.encoder_settings.payload_type = 125;
VideoEncoderConfig video_encoder_config;
test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config);
test::FillEncoderConfiguration(1, &video_encoder_config);
video_encoder_config.video_stream_factory =
new rtc::RefCountedObject<VideoStreamFactory>(1, max_framerate_);
video_encoder_config_ = video_encoder_config.Copy();
@ -325,10 +325,9 @@ class VideoStreamEncoderTest : public ::testing::Test {
unsigned char num_spatial_layers,
bool nack_enabled,
bool screenshare) {
video_send_config_.rtp.payload_name = payload_name;
video_send_config_.encoder_settings.payload_name = payload_name;
VideoEncoderConfig video_encoder_config;
video_encoder_config.codec_type = PayloadStringToCodecType(payload_name);
video_encoder_config.number_of_streams = num_streams;
video_encoder_config.max_bitrate_bps = kTargetBitrateBps;
video_encoder_config.video_stream_factory =
@ -784,7 +783,7 @@ TEST_F(VideoStreamEncoderTest,
EXPECT_EQ(1, sink_.number_of_reconfigurations());
VideoEncoderConfig video_encoder_config;
test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config);
test::FillEncoderConfiguration(1, &video_encoder_config);
video_encoder_config.min_transmit_bitrate_bps = 9999;
video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config),
kMaxPayloadLength,
@ -2280,7 +2279,6 @@ TEST_F(VideoStreamEncoderTest, OveruseDetectorUpdatedOnReconfigureAndAdaption) {
// Trigger reconfigure encoder (without resetting the entire instance).
VideoEncoderConfig video_encoder_config;
video_encoder_config.codec_type = kVideoCodecVP8;
video_encoder_config.max_bitrate_bps = kTargetBitrateBps;
video_encoder_config.number_of_streams = 1;
video_encoder_config.video_stream_factory =
@ -2332,7 +2330,6 @@ TEST_F(VideoStreamEncoderTest,
// Trigger initial configuration.
VideoEncoderConfig video_encoder_config;
video_encoder_config.codec_type = kVideoCodecVP8;
video_encoder_config.max_bitrate_bps = kTargetBitrateBps;
video_encoder_config.number_of_streams = 1;
video_encoder_config.video_stream_factory =
@ -2395,7 +2392,6 @@ TEST_F(VideoStreamEncoderTest,
// Trigger initial configuration.
VideoEncoderConfig video_encoder_config;
video_encoder_config.codec_type = kVideoCodecVP8;
video_encoder_config.max_bitrate_bps = kTargetBitrateBps;
video_encoder_config.number_of_streams = 1;
video_encoder_config.video_stream_factory =
@ -3189,7 +3185,6 @@ TEST_F(VideoStreamEncoderTest, AcceptsFullHdAdaptedDownSimulcastFrames) {
video_stream_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
// Trigger reconfigure encoder (without resetting the entire instance).
VideoEncoderConfig video_encoder_config;
video_encoder_config.codec_type = kVideoCodecVP8;
video_encoder_config.max_bitrate_bps = kTargetBitrateBps;
video_encoder_config.number_of_streams = 1;
video_encoder_config.video_stream_factory =