Reland "Update internal SW codecs to return unique_ptrs"
This reverts commit 34c8e6bce8af0c31f2b0b31d691a6a931fa3cb7b.
Reason for revert: Fix Android compilation
Original change's description:
> Revert "Update internal SW codecs to return unique_ptrs"
>
> This reverts commit 4fe6adc06a8524ac25f85260bfe392eb31dae6b4.
>
> Reason for revert: Breaks android compile.
>
> Original change's description:
> > Update internal SW codecs to return unique_ptrs
> >
> > TBR=stefan@webrtc.org
> >
> > Bug: webrtc:7925
> > Change-Id: I84239b071a2608d928f09b06809090eec5eafb14
> > Reviewed-on: https://webrtc-review.googlesource.com/21165
> > Commit-Queue: Magnus Jedvert <magjed@webrtc.org>
> > Reviewed-by: Erik Språng <sprang@webrtc.org>
> > Cr-Commit-Position: refs/heads/master@{#20650}
>
> TBR=magjed@webrtc.org,sprang@webrtc.org,stefan@webrtc.org
>
> Change-Id: If33c3a0ee0dfce63d105558a2897a472f0633306
> No-Presubmit: true
> No-Tree-Checks: true
> No-Try: true
> Bug: webrtc:7925
> Reviewed-on: https://webrtc-review.googlesource.com/22540
> Reviewed-by: Magnus Jedvert <magjed@webrtc.org>
> Commit-Queue: Magnus Jedvert <magjed@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#20652}
TBR=magjed@webrtc.org,sprang@webrtc.org,stefan@webrtc.org
Change-Id: Ic8551af4687e927c9b605060155abdd5bc6208b2
Bug: webrtc:7925
Reviewed-on: https://webrtc-review.googlesource.com/22541
Commit-Queue: Magnus Jedvert <magjed@webrtc.org>
Reviewed-by: Magnus Jedvert <magjed@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#20655}
diff --git a/media/engine/internaldecoderfactory.cc b/media/engine/internaldecoderfactory.cc
index 86b4ed1..e8cecb7 100644
--- a/media/engine/internaldecoderfactory.cc
+++ b/media/engine/internaldecoderfactory.cc
@@ -33,15 +33,15 @@
std::unique_ptr<VideoDecoder> InternalDecoderFactory::CreateVideoDecoder(
const SdpVideoFormat& format) {
if (cricket::CodecNamesEq(format.name, cricket::kVp8CodecName))
- return std::unique_ptr<VideoDecoder>(VP8Decoder::Create());
+ return VP8Decoder::Create();
if (cricket::CodecNamesEq(format.name, cricket::kVp9CodecName)) {
RTC_DCHECK(VP9Decoder::IsSupported());
- return std::unique_ptr<VideoDecoder>(VP9Decoder::Create());
+ return VP9Decoder::Create();
}
if (cricket::CodecNamesEq(format.name, cricket::kH264CodecName))
- return std::unique_ptr<VideoDecoder>(H264Decoder::Create());
+ return H264Decoder::Create();
RTC_LOG(LS_ERROR) << "Trying to create decoder for unsupported format";
return nullptr;
diff --git a/media/engine/internalencoderfactory.cc b/media/engine/internalencoderfactory.cc
index 23c85cb..fa6783f 100644
--- a/media/engine/internalencoderfactory.cc
+++ b/media/engine/internalencoderfactory.cc
@@ -64,11 +64,11 @@
webrtc::PayloadStringToCodecType(codec.name);
switch (codec_type) {
case webrtc::kVideoCodecH264:
- return webrtc::H264Encoder::Create(codec);
+ return webrtc::H264Encoder::Create(codec).release();
case webrtc::kVideoCodecVP8:
- return webrtc::VP8Encoder::Create();
+ return webrtc::VP8Encoder::Create().release();
case webrtc::kVideoCodecVP9:
- return webrtc::VP9Encoder::Create();
+ return webrtc::VP9Encoder::Create().release();
default:
return nullptr;
}
diff --git a/media/engine/simulcast_encoder_adapter_unittest.cc b/media/engine/simulcast_encoder_adapter_unittest.cc
index 91b47de..a87daf5 100644
--- a/media/engine/simulcast_encoder_adapter_unittest.cc
+++ b/media/engine/simulcast_encoder_adapter_unittest.cc
@@ -13,9 +13,11 @@
#include <vector>
#include "common_video/include/video_frame_buffer.h"
+#include "media/engine/internalencoderfactory.h"
#include "media/engine/simulcast_encoder_adapter.h"
#include "modules/video_coding/codecs/vp8/simulcast_test_utility.h"
#include "modules/video_coding/include/video_codec_interface.h"
+#include "rtc_base/ptr_util.h"
#include "test/gmock.h"
namespace webrtc {
@@ -23,39 +25,19 @@
class TestSimulcastEncoderAdapter : public TestVp8Simulcast {
public:
- TestSimulcastEncoderAdapter() : factory_(new Vp8EncoderFactory()) {}
+ TestSimulcastEncoderAdapter()
+ : factory_(new cricket::InternalEncoderFactory()) {}
protected:
- class Vp8EncoderFactory : public cricket::WebRtcVideoEncoderFactory {
- public:
- Vp8EncoderFactory() {
- supported_codecs_.push_back(cricket::VideoCodec("VP8"));
- }
-
- const std::vector<cricket::VideoCodec>& supported_codecs() const override {
- return supported_codecs_;
- }
-
- VideoEncoder* CreateVideoEncoder(
- const cricket::VideoCodec& codec) override {
- return VP8Encoder::Create();
- }
-
- void DestroyVideoEncoder(VideoEncoder* encoder) override { delete encoder; }
-
- virtual ~Vp8EncoderFactory() {}
-
- private:
- std::vector<cricket::VideoCodec> supported_codecs_;
- };
-
- VP8Encoder* CreateEncoder() override {
- return new SimulcastEncoderAdapter(factory_.get());
+ std::unique_ptr<VP8Encoder> CreateEncoder() override {
+ return rtc::MakeUnique<SimulcastEncoderAdapter>(factory_.get());
}
- VP8Decoder* CreateDecoder() override { return VP8Decoder::Create(); }
+ std::unique_ptr<VP8Decoder> CreateDecoder() override {
+ return VP8Decoder::Create();
+ }
private:
- std::unique_ptr<Vp8EncoderFactory> factory_;
+ std::unique_ptr<cricket::WebRtcVideoEncoderFactory> factory_;
};
TEST_F(TestSimulcastEncoderAdapter, TestKeyFrameRequestsOnAllStreams) {
diff --git a/modules/video_coding/codecs/h264/h264.cc b/modules/video_coding/codecs/h264/h264.cc
index e694940..7771b13 100644
--- a/modules/video_coding/codecs/h264/h264.cc
+++ b/modules/video_coding/codecs/h264/h264.cc
@@ -21,6 +21,7 @@
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
+#include "rtc_base/ptr_util.h"
namespace webrtc {
@@ -70,12 +71,13 @@
CreateH264Format(H264::kProfileConstrainedBaseline, H264::kLevel3_1)};
}
-H264Encoder* H264Encoder::Create(const cricket::VideoCodec& codec) {
+std::unique_ptr<H264Encoder> H264Encoder::Create(
+ const cricket::VideoCodec& codec) {
RTC_DCHECK(H264Encoder::IsSupported());
#if defined(WEBRTC_USE_H264)
RTC_CHECK(g_rtc_use_h264);
RTC_LOG(LS_INFO) << "Creating H264EncoderImpl.";
- return new H264EncoderImpl(codec);
+ return rtc::MakeUnique<H264EncoderImpl>(codec);
#else
RTC_NOTREACHED();
return nullptr;
@@ -86,12 +88,12 @@
return IsH264CodecSupported();
}
-H264Decoder* H264Decoder::Create() {
+std::unique_ptr<H264Decoder> H264Decoder::Create() {
RTC_DCHECK(H264Decoder::IsSupported());
#if defined(WEBRTC_USE_H264)
RTC_CHECK(g_rtc_use_h264);
RTC_LOG(LS_INFO) << "Creating H264DecoderImpl.";
- return new H264DecoderImpl();
+ return rtc::MakeUnique<H264DecoderImpl>();
#else
RTC_NOTREACHED();
return nullptr;
diff --git a/modules/video_coding/codecs/h264/include/h264.h b/modules/video_coding/codecs/h264/include/h264.h
index 6c93b34..e23818b 100644
--- a/modules/video_coding/codecs/h264/include/h264.h
+++ b/modules/video_coding/codecs/h264/include/h264.h
@@ -12,6 +12,7 @@
#ifndef MODULES_VIDEO_CODING_CODECS_H264_INCLUDE_H264_H_
#define MODULES_VIDEO_CODING_CODECS_H264_INCLUDE_H264_H_
+#include <memory>
#include <vector>
#include "media/base/codec.h"
@@ -33,7 +34,7 @@
class H264Encoder : public VideoEncoder {
public:
- static H264Encoder* Create(const cricket::VideoCodec& codec);
+ static std::unique_ptr<H264Encoder> Create(const cricket::VideoCodec& codec);
// If H.264 is supported (any implementation).
static bool IsSupported();
@@ -42,7 +43,7 @@
class H264Decoder : public VideoDecoder {
public:
- static H264Decoder* Create();
+ static std::unique_ptr<H264Decoder> Create();
static bool IsSupported();
~H264Decoder() override {}
diff --git a/modules/video_coding/codecs/h264/test/h264_impl_unittest.cc b/modules/video_coding/codecs/h264/test/h264_impl_unittest.cc
index 255b2c3..8c32df4 100644
--- a/modules/video_coding/codecs/h264/test/h264_impl_unittest.cc
+++ b/modules/video_coding/codecs/h264/test/h264_impl_unittest.cc
@@ -16,11 +16,13 @@
class TestH264Impl : public VideoCodecTest {
protected:
- VideoEncoder* CreateEncoder() override {
+ std::unique_ptr<VideoEncoder> CreateEncoder() override {
return H264Encoder::Create(cricket::VideoCodec(cricket::kH264CodecName));
}
- VideoDecoder* CreateDecoder() override { return H264Decoder::Create(); }
+ std::unique_ptr<VideoDecoder> CreateDecoder() override {
+ return H264Decoder::Create();
+ }
VideoCodec codec_settings() override {
VideoCodec codec_inst;
diff --git a/modules/video_coding/codecs/stereo/test/stereo_adapter_unittest.cc b/modules/video_coding/codecs/stereo/test/stereo_adapter_unittest.cc
index 7c16620..caef8b1 100644
--- a/modules/video_coding/codecs/stereo/test/stereo_adapter_unittest.cc
+++ b/modules/video_coding/codecs/stereo/test/stereo_adapter_unittest.cc
@@ -31,12 +31,12 @@
encoder_factory_(new webrtc::MockVideoEncoderFactory) {}
protected:
- VideoDecoder* CreateDecoder() override {
- return new StereoDecoderAdapter(decoder_factory_.get());
+ std::unique_ptr<VideoDecoder> CreateDecoder() override {
+ return rtc::MakeUnique<StereoDecoderAdapter>(decoder_factory_.get());
}
- VideoEncoder* CreateEncoder() override {
- return new StereoEncoderAdapter(encoder_factory_.get());
+ std::unique_ptr<VideoEncoder> CreateEncoder() override {
+ return rtc::MakeUnique<StereoEncoderAdapter>(encoder_factory_.get());
}
VideoCodec codec_settings() override {
@@ -62,15 +62,17 @@
private:
void SetUp() override {
EXPECT_CALL(*decoder_factory_, Die());
- VideoDecoder* decoder1 = VP9Decoder::Create();
- VideoDecoder* decoder2 = VP9Decoder::Create();
+ // The decoders/encoders will be owned by the caller of
+ // CreateVideoDecoder()/CreateVideoEncoder().
+ VideoDecoder* decoder1 = VP9Decoder::Create().release();
+ VideoDecoder* decoder2 = VP9Decoder::Create().release();
EXPECT_CALL(*decoder_factory_, CreateVideoDecoderProxy(_))
.WillOnce(Return(decoder1))
.WillOnce(Return(decoder2));
EXPECT_CALL(*encoder_factory_, Die());
- VideoEncoder* encoder1 = VP9Encoder::Create();
- VideoEncoder* encoder2 = VP9Encoder::Create();
+ VideoEncoder* encoder1 = VP9Encoder::Create().release();
+ VideoEncoder* encoder2 = VP9Encoder::Create().release();
EXPECT_CALL(*encoder_factory_, CreateVideoEncoderProxy(_))
.WillOnce(Return(encoder1))
.WillOnce(Return(encoder2));
diff --git a/modules/video_coding/codecs/test/video_codec_test.cc b/modules/video_coding/codecs/test/video_codec_test.cc
index 85d76c3..b6faae8 100644
--- a/modules/video_coding/codecs/test/video_codec_test.cc
+++ b/modules/video_coding/codecs/test/video_codec_test.cc
@@ -63,8 +63,8 @@
input_frame_.reset(new VideoFrame(video_frame_buffer, kVideoRotation_0, 0));
fclose(source_file_);
- encoder_.reset(CreateEncoder());
- decoder_.reset(CreateDecoder());
+ encoder_ = CreateEncoder();
+ decoder_ = CreateDecoder();
encoder_->RegisterEncodeCompleteCallback(&encode_complete_callback_);
decoder_->RegisterDecodeCompleteCallback(&decode_complete_callback_);
diff --git a/modules/video_coding/codecs/test/video_codec_test.h b/modules/video_coding/codecs/test/video_codec_test.h
index eb43cd0..76f5234 100644
--- a/modules/video_coding/codecs/test/video_codec_test.h
+++ b/modules/video_coding/codecs/test/video_codec_test.h
@@ -68,8 +68,8 @@
VideoCodecTest* const test_;
};
- virtual VideoEncoder* CreateEncoder() = 0;
- virtual VideoDecoder* CreateDecoder() = 0;
+ virtual std::unique_ptr<VideoEncoder> CreateEncoder() = 0;
+ virtual std::unique_ptr<VideoDecoder> CreateDecoder() = 0;
virtual VideoCodec codec_settings() = 0;
void SetUp() override;
diff --git a/modules/video_coding/codecs/vp8/include/vp8.h b/modules/video_coding/codecs/vp8/include/vp8.h
index a5d3fb3..00808e2 100644
--- a/modules/video_coding/codecs/vp8/include/vp8.h
+++ b/modules/video_coding/codecs/vp8/include/vp8.h
@@ -13,20 +13,22 @@
#ifndef MODULES_VIDEO_CODING_CODECS_VP8_INCLUDE_VP8_H_
#define MODULES_VIDEO_CODING_CODECS_VP8_INCLUDE_VP8_H_
+#include <memory>
+
#include "modules/video_coding/include/video_codec_interface.h"
namespace webrtc {
class VP8Encoder : public VideoEncoder {
public:
- static VP8Encoder* Create();
+ static std::unique_ptr<VP8Encoder> Create();
virtual ~VP8Encoder() {}
}; // end of VP8Encoder class
class VP8Decoder : public VideoDecoder {
public:
- static VP8Decoder* Create();
+ static std::unique_ptr<VP8Decoder> Create();
virtual ~VP8Decoder() {}
}; // end of VP8Decoder class
diff --git a/modules/video_coding/codecs/vp8/simulcast_test_utility.h b/modules/video_coding/codecs/vp8/simulcast_test_utility.h
index dd22af8..7f32ad2 100644
--- a/modules/video_coding/codecs/vp8/simulcast_test_utility.h
+++ b/modules/video_coding/codecs/vp8/simulcast_test_utility.h
@@ -241,12 +241,12 @@
}
protected:
- virtual VP8Encoder* CreateEncoder() = 0;
- virtual VP8Decoder* CreateDecoder() = 0;
+ virtual std::unique_ptr<VP8Encoder> CreateEncoder() = 0;
+ virtual std::unique_ptr<VP8Decoder> CreateDecoder() = 0;
void SetUp() override {
- encoder_.reset(CreateEncoder());
- decoder_.reset(CreateDecoder());
+ encoder_ = CreateEncoder();
+ decoder_ = CreateDecoder();
SetUpCodec(kDefaultTemporalLayerProfile);
}
diff --git a/modules/video_coding/codecs/vp8/simulcast_unittest.cc b/modules/video_coding/codecs/vp8/simulcast_unittest.cc
index d6b6dc5..b1dd794 100644
--- a/modules/video_coding/codecs/vp8/simulcast_unittest.cc
+++ b/modules/video_coding/codecs/vp8/simulcast_unittest.cc
@@ -15,8 +15,12 @@
class TestVp8Impl : public TestVp8Simulcast {
protected:
- VP8Encoder* CreateEncoder() override { return VP8Encoder::Create(); }
- VP8Decoder* CreateDecoder() override { return VP8Decoder::Create(); }
+ std::unique_ptr<VP8Encoder> CreateEncoder() override {
+ return VP8Encoder::Create();
+ }
+ std::unique_ptr<VP8Decoder> CreateDecoder() override {
+ return VP8Decoder::Create();
+ }
};
TEST_F(TestVp8Impl, TestKeyFrameRequestsOnAllStreams) {
diff --git a/modules/video_coding/codecs/vp8/vp8_impl.cc b/modules/video_coding/codecs/vp8/vp8_impl.cc
index f687d35..107618f 100644
--- a/modules/video_coding/codecs/vp8/vp8_impl.cc
+++ b/modules/video_coding/codecs/vp8/vp8_impl.cc
@@ -30,6 +30,7 @@
#include "modules/video_coding/include/video_codec_interface.h"
#include "rtc_base/checks.h"
#include "rtc_base/numerics/exp_filter.h"
+#include "rtc_base/ptr_util.h"
#include "rtc_base/random.h"
#include "rtc_base/timeutils.h"
#include "rtc_base/trace_event.h"
@@ -162,12 +163,12 @@
} // namespace
-VP8Encoder* VP8Encoder::Create() {
- return new VP8EncoderImpl();
+std::unique_ptr<VP8Encoder> VP8Encoder::Create() {
+ return rtc::MakeUnique<VP8EncoderImpl>();
}
-VP8Decoder* VP8Decoder::Create() {
- return new VP8DecoderImpl();
+std::unique_ptr<VP8Decoder> VP8Decoder::Create() {
+ return rtc::MakeUnique<VP8DecoderImpl>();
}
vpx_enc_frame_flags_t VP8EncoderImpl::EncodeFlags(
diff --git a/modules/video_coding/codecs/vp9/include/vp9.h b/modules/video_coding/codecs/vp9/include/vp9.h
index 53cc3c0..172e69e 100644
--- a/modules/video_coding/codecs/vp9/include/vp9.h
+++ b/modules/video_coding/codecs/vp9/include/vp9.h
@@ -12,6 +12,8 @@
#ifndef MODULES_VIDEO_CODING_CODECS_VP9_INCLUDE_VP9_H_
#define MODULES_VIDEO_CODING_CODECS_VP9_INCLUDE_VP9_H_
+#include <memory>
+
#include "modules/video_coding/include/video_codec_interface.h"
namespace webrtc {
@@ -19,7 +21,7 @@
class VP9Encoder : public VideoEncoder {
public:
static bool IsSupported();
- static VP9Encoder* Create();
+ static std::unique_ptr<VP9Encoder> Create();
virtual ~VP9Encoder() {}
};
@@ -27,7 +29,7 @@
class VP9Decoder : public VideoDecoder {
public:
static bool IsSupported();
- static VP9Decoder* Create();
+ static std::unique_ptr<VP9Decoder> Create();
virtual ~VP9Decoder() {}
};
diff --git a/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc b/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc
index 45a88b1..3718707 100644
--- a/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc
+++ b/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc
@@ -20,9 +20,13 @@
class TestVp9Impl : public VideoCodecTest {
protected:
- VideoEncoder* CreateEncoder() override { return VP9Encoder::Create(); }
+ std::unique_ptr<VideoEncoder> CreateEncoder() override {
+ return VP9Encoder::Create();
+ }
- VideoDecoder* CreateDecoder() override { return VP9Decoder::Create(); }
+ std::unique_ptr<VideoDecoder> CreateDecoder() override {
+ return VP9Decoder::Create();
+ }
VideoCodec codec_settings() override {
VideoCodec codec_settings;
diff --git a/modules/video_coding/codecs/vp9/vp9_impl.cc b/modules/video_coding/codecs/vp9/vp9_impl.cc
index c68fea7..7c69dfd 100644
--- a/modules/video_coding/codecs/vp9/vp9_impl.cc
+++ b/modules/video_coding/codecs/vp9/vp9_impl.cc
@@ -27,6 +27,7 @@
#include "rtc_base/checks.h"
#include "rtc_base/keep_ref_until_done.h"
#include "rtc_base/logging.h"
+#include "rtc_base/ptr_util.h"
#include "rtc_base/random.h"
#include "rtc_base/timeutils.h"
#include "rtc_base/trace_event.h"
@@ -52,8 +53,8 @@
return true;
}
-VP9Encoder* VP9Encoder::Create() {
- return new VP9EncoderImpl();
+std::unique_ptr<VP9Encoder> VP9Encoder::Create() {
+ return rtc::MakeUnique<VP9EncoderImpl>();
}
void VP9EncoderImpl::EncoderOutputCodedPacketCallback(vpx_codec_cx_pkt* pkt,
@@ -841,8 +842,8 @@
return true;
}
-VP9Decoder* VP9Decoder::Create() {
- return new VP9DecoderImpl();
+std::unique_ptr<VP9Decoder> VP9Decoder::Create() {
+ return rtc::MakeUnique<VP9DecoderImpl>();
}
VP9DecoderImpl::VP9DecoderImpl()
diff --git a/modules/video_coding/codecs/vp9/vp9_noop.cc b/modules/video_coding/codecs/vp9/vp9_noop.cc
index 4522273..baa0486 100644
--- a/modules/video_coding/codecs/vp9/vp9_noop.cc
+++ b/modules/video_coding/codecs/vp9/vp9_noop.cc
@@ -22,7 +22,7 @@
return false;
}
-VP9Encoder* VP9Encoder::Create() {
+std::unique_ptr<VP9Encoder> VP9Encoder::Create() {
RTC_NOTREACHED();
return nullptr;
}
@@ -31,7 +31,7 @@
return false;
}
-VP9Decoder* VP9Decoder::Create() {
+std::unique_ptr<VP9Decoder> VP9Decoder::Create() {
RTC_NOTREACHED();
return nullptr;
}
diff --git a/modules/video_coding/generic_decoder.cc b/modules/video_coding/generic_decoder.cc
index cfe5acf..f3af20c 100644
--- a/modules/video_coding/generic_decoder.cc
+++ b/modules/video_coding/generic_decoder.cc
@@ -182,6 +182,9 @@
return VCM_OK;
}
+VCMGenericDecoder::VCMGenericDecoder(std::unique_ptr<VideoDecoder> decoder)
+ : VCMGenericDecoder(decoder.release(), false /* isExternal */) {}
+
VCMGenericDecoder::VCMGenericDecoder(VideoDecoder* decoder, bool isExternal)
: _callback(NULL),
_frameInfos(),
diff --git a/modules/video_coding/generic_decoder.h b/modules/video_coding/generic_decoder.h
index 2c1206f..2d940d8 100644
--- a/modules/video_coding/generic_decoder.h
+++ b/modules/video_coding/generic_decoder.h
@@ -76,6 +76,7 @@
class VCMGenericDecoder {
public:
+ explicit VCMGenericDecoder(std::unique_ptr<VideoDecoder> decoder);
explicit VCMGenericDecoder(VideoDecoder* decoder, bool isExternal = false);
~VCMGenericDecoder();
diff --git a/modules/video_coding/video_sender_unittest.cc b/modules/video_coding/video_sender_unittest.cc
index 6cc4ae9..0719b16 100644
--- a/modules/video_coding/video_sender_unittest.cc
+++ b/modules/video_coding/video_sender_unittest.cc
@@ -418,7 +418,7 @@
codec_, std::unique_ptr<TemporalLayersFactory>(tl_factory)));
codec_.VP8()->tl_factory = tl_factory;
- encoder_.reset(VP8Encoder::Create());
+ encoder_ = VP8Encoder::Create();
sender_->RegisterExternalEncoder(encoder_.get(), codec_.plType, false);
EXPECT_EQ(0, sender_->RegisterSendCodec(&codec_, 1, 1200));
}
diff --git a/sdk/android/src/jni/vp8codec.cc b/sdk/android/src/jni/vp8codec.cc
index 90182a1..1108ed0 100644
--- a/sdk/android/src/jni/vp8codec.cc
+++ b/sdk/android/src/jni/vp8codec.cc
@@ -20,14 +20,14 @@
VP8Encoder_createNativeEncoder,
JNIEnv* jni,
jclass) {
- return jlongFromPointer(VP8Encoder::Create());
+ return jlongFromPointer(VP8Encoder::Create().release());
}
JNI_FUNCTION_DECLARATION(jlong,
VP8Decoder_createNativeDecoder,
JNIEnv* jni,
jclass) {
- return jlongFromPointer(VP8Decoder::Create());
+ return jlongFromPointer(VP8Decoder::Create().release());
}
} // namespace jni
diff --git a/sdk/android/src/jni/vp9codec.cc b/sdk/android/src/jni/vp9codec.cc
index 6ad774e..cfdb334 100644
--- a/sdk/android/src/jni/vp9codec.cc
+++ b/sdk/android/src/jni/vp9codec.cc
@@ -20,14 +20,14 @@
VP9Encoder_createNativeEncoder,
JNIEnv* jni,
jclass) {
- return jlongFromPointer(VP9Encoder::Create());
+ return jlongFromPointer(VP9Encoder::Create().release());
}
JNI_FUNCTION_DECLARATION(jlong,
VP9Decoder_createNativeDecoder,
JNIEnv* jni,
jclass) {
- return jlongFromPointer(VP9Decoder::Create());
+ return jlongFromPointer(VP9Decoder::Create().release());
}
} // namespace jni
diff --git a/test/encoder_settings.cc b/test/encoder_settings.cc
index 673785d..bd700cf 100644
--- a/test/encoder_settings.cc
+++ b/test/encoder_settings.cc
@@ -88,11 +88,11 @@
decoder.payload_type = encoder_settings.payload_type;
decoder.payload_name = encoder_settings.payload_name;
if (encoder_settings.payload_name == "H264") {
- decoder.decoder = H264Decoder::Create();
+ decoder.decoder = H264Decoder::Create().release();
} else if (encoder_settings.payload_name == "VP8") {
- decoder.decoder = VP8Decoder::Create();
+ decoder.decoder = VP8Decoder::Create().release();
} else if (encoder_settings.payload_name == "VP9") {
- decoder.decoder = VP9Decoder::Create();
+ decoder.decoder = VP9Decoder::Create().release();
} else {
decoder.decoder = new FakeDecoder();
}
diff --git a/video/end_to_end_tests.cc b/video/end_to_end_tests.cc
index 96996ba..041fa17 100644
--- a/video/end_to_end_tests.cc
+++ b/video/end_to_end_tests.cc
@@ -329,16 +329,16 @@
CodecObserver(int no_frames_to_wait_for,
VideoRotation rotation_to_test,
const std::string& payload_name,
- webrtc::VideoEncoder* encoder,
- webrtc::VideoDecoder* decoder)
+ std::unique_ptr<webrtc::VideoEncoder> encoder,
+ std::unique_ptr<webrtc::VideoDecoder> decoder)
: EndToEndTest(4 * webrtc::EndToEndTest::kDefaultTimeoutMs),
// TODO(hta): This timeout (120 seconds) is excessive.
// https://bugs.webrtc.org/6830
no_frames_to_wait_for_(no_frames_to_wait_for),
expected_rotation_(rotation_to_test),
payload_name_(payload_name),
- encoder_(encoder),
- decoder_(decoder),
+ encoder_(std::move(encoder)),
+ decoder_(std::move(decoder)),
frame_counter_(0) {}
void PerformTest() override {
@@ -1553,7 +1553,7 @@
receiver_transport->SetReceiver(sender_call->Receiver());
for (size_t i = 0; i < kNumStreams; ++i)
- encoders[i].reset(VP8Encoder::Create());
+ encoders[i] = VP8Encoder::Create();
for (size_t i = 0; i < kNumStreams; ++i) {
uint32_t ssrc = codec_settings[i].ssrc;
@@ -4327,7 +4327,7 @@
const int kNumFlexfecStreams = 1;
CreateSendConfig(kNumVideoStreams, 0, kNumFlexfecStreams,
send_transport.get());
- encoder = rtc::WrapUnique(VP8Encoder::Create());
+ encoder = VP8Encoder::Create();
video_send_config_.encoder_settings.encoder = encoder.get();
video_send_config_.encoder_settings.payload_name = "VP8";
video_send_config_.encoder_settings.payload_type = kVideoSendPayloadType;
@@ -4994,8 +4994,8 @@
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
- encoder_.reset(VP8Encoder::Create());
- decoder_.reset(VP8Decoder::Create());
+ encoder_ = VP8Encoder::Create();
+ decoder_ = VP8Decoder::Create();
send_config->post_encode_callback = this;
send_config->encoder_settings.payload_name = "VP8";
diff --git a/video/video_quality_test.cc b/video/video_quality_test.cc
index d300d11..f56426f 100644
--- a/video/video_quality_test.cc
+++ b/video/video_quality_test.cc
@@ -23,6 +23,7 @@
#include "common_video/libyuv/include/webrtc_libyuv.h"
#include "logging/rtc_event_log/output/rtc_event_log_output_file.h"
#include "logging/rtc_event_log/rtc_event_log.h"
+#include "media/engine/internalencoderfactory.h"
#include "media/engine/webrtcvideoengine.h"
#include "modules/audio_mixer/audio_mixer_impl.h"
#include "modules/rtp_rtcp/include/rtp_header_parser.h"
@@ -1129,35 +1130,6 @@
const int64_t start_ms_;
};
-class Vp8EncoderFactory : public cricket::WebRtcVideoEncoderFactory {
- public:
- Vp8EncoderFactory() {
- supported_codecs_.push_back(cricket::VideoCodec("VP8"));
- }
- ~Vp8EncoderFactory() override { RTC_CHECK(live_encoders_.empty()); }
-
- const std::vector<cricket::VideoCodec>& supported_codecs() const override {
- return supported_codecs_;
- }
-
- VideoEncoder* CreateVideoEncoder(const cricket::VideoCodec& codec) override {
- VideoEncoder* encoder = VP8Encoder::Create();
- live_encoders_.insert(encoder);
- return encoder;
- }
-
- void DestroyVideoEncoder(VideoEncoder* encoder) override {
- auto it = live_encoders_.find(encoder);
- RTC_CHECK(it != live_encoders_.end());
- live_encoders_.erase(it);
- delete encoder;
- }
-
- private:
- std::vector<cricket::VideoCodec> supported_codecs_;
- std::set<VideoEncoder*> live_encoders_;
-};
-
VideoQualityTest::VideoQualityTest()
: clock_(Clock::GetRealTimeClock()), receive_logs_(0), send_logs_(0) {
payload_type_map_ = test::CallTest::payload_type_map_;
@@ -1413,7 +1385,7 @@
int payload_type;
if (params_.video.codec == "H264") {
- video_encoder_.reset(H264Encoder::Create(cricket::VideoCodec("H264")));
+ video_encoder_ = H264Encoder::Create(cricket::VideoCodec("H264"));
payload_type = kPayloadTypeH264;
} else if (params_.video.codec == "VP8") {
if (params_.screenshare.enabled && params_.ss.streams.size() > 1) {
@@ -1421,13 +1393,13 @@
// encoders usually can't natively do simulcast with different frame rates
// for the different layers.
video_encoder_.reset(
- new SimulcastEncoderAdapter(new Vp8EncoderFactory()));
+ new SimulcastEncoderAdapter(new cricket::InternalEncoderFactory()));
} else {
- video_encoder_.reset(VP8Encoder::Create());
+ video_encoder_ = VP8Encoder::Create();
}
payload_type = kPayloadTypeVP8;
} else if (params_.video.codec == "VP9") {
- video_encoder_.reset(VP9Encoder::Create());
+ video_encoder_ = VP9Encoder::Create();
payload_type = kPayloadTypeVP9;
} else {
RTC_NOTREACHED() << "Codec not supported!";