Google Git
Sign in
webkit / WebKit / refs/heads/master / . / Source / ThirdParty / libwebrtc / WebKit / libwebrtc-m87-diff
blob: 7f80c7088683d88848bf76371f48b85939dbf6e3 [file] [log] [blame]
commit 52ade488b09c6427fbe62663f4b2d10a65353485
Author: Youenn Fablet <youenn@apple.com>
Date: Tue Nov 3 17:29:10 2020 +0100
webrtc-new-fix
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/api/audio_codecs/ilbc/audio_encoder_ilbc.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/api/audio_codecs/ilbc/audio_encoder_ilbc.cc
index bd653b7979b1..117517b093d7 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/api/audio_codecs/ilbc/audio_encoder_ilbc.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/api/audio_codecs/ilbc/audio_encoder_ilbc.cc
@@ -32,7 +32,7 @@ int GetIlbcBitrate(int ptime) {
// 50 bytes per frame of 30 ms => (approx) 13333 bits/s.
return 13333;
default:
- FATAL();
+ RTC_FATAL();
}
}
} // namespace
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/api/media_types.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/api/media_types.cc
index 6bc693860d38..3eba7cfaebbf 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/api/media_types.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/api/media_types.cc
@@ -27,7 +27,7 @@ std::string MediaTypeToString(MediaType type) {
case MEDIA_TYPE_DATA:
return kMediaTypeData;
}
- FATAL();
+ RTC_FATAL();
// Not reachable; avoids compile warning.
return "";
}
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/api/stats/rtc_stats.h b/Source/ThirdParty/libwebrtc/Source/webrtc/api/stats/rtc_stats.h
index 5de5b7fbb048..7b1dfd41a22d 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/api/stats/rtc_stats.h
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/api/stats/rtc_stats.h
@@ -363,6 +363,14 @@ class RTCStatsMember : public RTCStatsMemberInterface {
T value_;
};
+#if !defined(WEBRTC_WEBKIT_BUILD)
+#define WEBRTC_DECLARE_RTCSTATSMEMBER_AS_EXTERN(T) \
+ extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT) \
+ RTCStatsMember<T>
+#else
+#define WEBRTC_DECLARE_RTCSTATSMEMBER_AS_EXTERN(T)
+#endif // WEBRTC_WEBKIT_BUILD
+
#define WEBRTC_DECLARE_RTCSTATSMEMBER(T) \
template <> \
RTC_EXPORT RTCStatsMemberInterface::Type RTCStatsMember<T>::StaticType(); \
@@ -374,8 +382,7 @@ class RTCStatsMember : public RTCStatsMemberInterface {
RTC_EXPORT std::string RTCStatsMember<T>::ValueToString() const; \
template <> \
RTC_EXPORT std::string RTCStatsMember<T>::ValueToJson() const; \
- extern template class RTC_EXPORT_TEMPLATE_DECLARE(RTC_EXPORT) \
- RTCStatsMember<T>
+ WEBRTC_DECLARE_RTCSTATSMEMBER_AS_EXTERN(T)
WEBRTC_DECLARE_RTCSTATSMEMBER(bool);
WEBRTC_DECLARE_RTCSTATSMEMBER(int32_t);
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/api/video/video_codec_type.h b/Source/ThirdParty/libwebrtc/Source/webrtc/api/video/video_codec_type.h
index 12dcfac1b9a6..fdbc5187d86e 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/api/video/video_codec_type.h
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/api/video/video_codec_type.h
@@ -22,6 +22,7 @@ enum VideoCodecType {
kVideoCodecVP9,
kVideoCodecAV1,
kVideoCodecH264,
+ kVideoCodecH265,
kVideoCodecMultiplex,
};
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/api/video_codecs/video_codec.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/api/video_codecs/video_codec.cc
index 490eced4e0d2..e625e8938aee 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/api/video_codecs/video_codec.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/api/video_codecs/video_codec.cc
@@ -25,6 +25,7 @@ constexpr char kPayloadNameVp9[] = "VP9";
// frozen.
constexpr char kPayloadNameAv1[] = "AV1X";
constexpr char kPayloadNameH264[] = "H264";
+constexpr char kPayloadNameH265[] = "H265";
constexpr char kPayloadNameGeneric[] = "Generic";
constexpr char kPayloadNameMultiplex[] = "Multiplex";
} // namespace
@@ -115,6 +116,10 @@ const char* CodecTypeToPayloadString(VideoCodecType type) {
return kPayloadNameAv1;
case kVideoCodecH264:
return kPayloadNameH264;
+#ifndef DISABLE_H265
+ case kVideoCodecH265:
+ return kPayloadNameH265;
+#endif
case kVideoCodecMultiplex:
return kPayloadNameMultiplex;
case kVideoCodecGeneric:
@@ -131,6 +136,10 @@ VideoCodecType PayloadStringToCodecType(const std::string& name) {
return kVideoCodecAV1;
if (absl::EqualsIgnoreCase(name, kPayloadNameH264))
return kVideoCodecH264;
+#ifndef DISABLE_H265
+ if (absl::EqualsIgnoreCase(name, kPayloadNameH265))
+ return kVideoCodecH265;
+#endif
if (absl::EqualsIgnoreCase(name, kPayloadNameMultiplex))
return kVideoCodecMultiplex;
return kVideoCodecGeneric;
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/api/video_codecs/video_decoder_software_fallback_wrapper.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/api/video_codecs/video_decoder_software_fallback_wrapper.cc
index 128087f20711..20b312cc06e1 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/api/video_codecs/video_decoder_software_fallback_wrapper.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/api/video_codecs/video_decoder_software_fallback_wrapper.cc
@@ -181,6 +181,12 @@ void VideoDecoderSoftwareFallbackWrapper::UpdateFallbackDecoderHistograms() {
RTC_HISTOGRAM_COUNTS_100000(kFallbackHistogramsUmaPrefix + "H264",
hw_decoded_frames_since_last_fallback_);
break;
+#ifndef DISABLE_H265
+ case kVideoCodecH265:
+ RTC_HISTOGRAM_COUNTS_100000(kFallbackHistogramsUmaPrefix + "H265",
+ hw_decoded_frames_since_last_fallback_);
+ break;
+#endif
case kVideoCodecMultiplex:
RTC_HISTOGRAM_COUNTS_100000(kFallbackHistogramsUmaPrefix + "Multiplex",
hw_decoded_frames_since_last_fallback_);
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/audio/remix_resample.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/audio/remix_resample.cc
index 3694d34e40a8..ebab2f4068b6 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/audio/remix_resample.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/audio/remix_resample.cc
@@ -56,7 +56,7 @@ void RemixAndResample(const int16_t* src_data,
if (resampler->InitializeIfNeeded(sample_rate_hz, dst_frame->sample_rate_hz_,
audio_ptr_num_channels) == -1) {
- FATAL() << "InitializeIfNeeded failed: sample_rate_hz = " << sample_rate_hz
+ RTC_FATAL() << "InitializeIfNeeded failed: sample_rate_hz = " << sample_rate_hz
<< ", dst_frame->sample_rate_hz_ = " << dst_frame->sample_rate_hz_
<< ", audio_ptr_num_channels = " << audio_ptr_num_channels;
}
@@ -70,7 +70,7 @@ void RemixAndResample(const int16_t* src_data,
resampler->Resample(audio_ptr, src_length, dst_frame->mutable_data(),
AudioFrame::kMaxDataSizeSamples);
if (out_length == -1) {
- FATAL() << "Resample failed: audio_ptr = " << audio_ptr
+ RTC_FATAL() << "Resample failed: audio_ptr = " << audio_ptr
<< ", src_length = " << src_length
<< ", dst_frame->mutable_data() = " << dst_frame->mutable_data();
}
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/call/rtp_payload_params.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/call/rtp_payload_params.cc
index ad979a590a7a..4d083b1721b2 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/call/rtp_payload_params.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/call/rtp_payload_params.cc
@@ -95,6 +95,15 @@ void PopulateRtpWithCodecSpecifics(const CodecSpecificInfo& info,
rtp->simulcastIdx = spatial_index.value_or(0);
return;
}
+#ifndef DISABLE_H265
+ case kVideoCodecH265: {
+ auto& h265_header = rtp->video_type_header.emplace<RTPVideoHeaderH265>();
+ h265_header.packetization_mode =
+ info.codecSpecific.H265.packetization_mode;
+ rtp->simulcastIdx = spatial_index.value_or(0);
+ return;
+ }
+#endif
case kVideoCodecMultiplex:
case kVideoCodecGeneric:
rtp->codec = kVideoCodecGeneric;
@@ -286,6 +295,11 @@ void RtpPayloadParams::SetGeneric(const CodecSpecificInfo* codec_specific_info,
is_keyframe, rtp_video_header);
}
return;
+#ifndef DISABLE_H265
+ case VideoCodecType::kVideoCodecH265:
+ // FIXME: Implement H265 to generic descriptor.
+ return;
+#endif
case VideoCodecType::kVideoCodecMultiplex:
return;
}
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/common_audio/fir_filter_factory.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/common_audio/fir_filter_factory.cc
index 4bcf05245f95..7b2217c77264 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/common_audio/fir_filter_factory.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/common_audio/fir_filter_factory.cc
@@ -36,10 +36,13 @@ FIRFilter* CreateFirFilter(const float* coefficients,
// If we know the minimum architecture at compile time, avoid CPU detection.
#if defined(WEBRTC_ARCH_X86_FAMILY)
// x86 CPU detection required.
+#if !defined(WEBRTC_WEBKIT_BUILD)
if (GetCPUInfo(kAVX2)) {
filter =
new FIRFilterAVX2(coefficients, coefficients_length, max_input_length);
- } else if (GetCPUInfo(kSSE2)) {
+ } else
+#endif
+ if (GetCPUInfo(kSSE2)) {
filter =
new FIRFilterSSE2(coefficients, coefficients_length, max_input_length);
} else {
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/common_audio/resampler/sinc_resampler.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/common_audio/resampler/sinc_resampler.cc
index 4fa78c5ede32..a2fc072ae322 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/common_audio/resampler/sinc_resampler.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/common_audio/resampler/sinc_resampler.cc
@@ -127,9 +127,12 @@ void SincResampler::InitializeCPUSpecificFeatures() {
convolve_proc_ = Convolve_NEON;
#elif defined(WEBRTC_ARCH_X86_FAMILY)
// Using AVX2 instead of SSE2 when AVX2 supported.
+#if !defined(WEBRTC_WEBKIT_BUILD)
if (GetCPUInfo(kAVX2))
convolve_proc_ = Convolve_AVX2;
- else if (GetCPUInfo(kSSE2))
+ else
+#endif
+ if (GetCPUInfo(kSSE2))
convolve_proc_ = Convolve_SSE;
else
convolve_proc_ = Convolve_C;
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/common_video/h265/h265_common.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/common_video/h265/h265_common.cc
new file mode 100644
index 000000000000..c639e135e510
--- /dev/null
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/common_video/h265/h265_common.cc
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "common_video/h265/h265_common.h"
+
+namespace webrtc {
+namespace H265 {
+
+const uint8_t kNaluTypeMask = 0x7E;
+
+std::vector<H264::NaluIndex> FindNaluIndices(const uint8_t* buffer,
+ size_t buffer_size) {
+ // This is sorta like Boyer-Moore, but with only the first optimization step:
+ // given a 3-byte sequence we're looking at, if the 3rd byte isn't 1 or 0,
+ // skip ahead to the next 3-byte sequence. 0s and 1s are relatively rare, so
+ // this will skip the majority of reads/checks.
+ std::vector<H264::NaluIndex> sequences;
+ if (buffer_size < kNaluShortStartSequenceSize)
+ return sequences;
+
+ const size_t end = buffer_size - kNaluShortStartSequenceSize;
+ for (size_t i = 0; i < end;) {
+ if (buffer[i + 2] > 1) {
+ i += 3;
+ } else if (buffer[i + 2] == 1 && buffer[i + 1] == 0 && buffer[i] == 0) {
+ // We found a start sequence, now check if it was a 3 of 4 byte one.
+ H264::NaluIndex index = {i, i + 3, 0};
+ if (index.start_offset > 0 && buffer[index.start_offset - 1] == 0)
+ --index.start_offset;
+
+ // Update length of previous entry.
+ auto it = sequences.rbegin();
+ if (it != sequences.rend())
+ it->payload_size = index.start_offset - it->payload_start_offset;
+
+ sequences.push_back(index);
+
+ i += 3;
+ } else {
+ ++i;
+ }
+ }
+
+ // Update length of last entry, if any.
+ auto it = sequences.rbegin();
+ if (it != sequences.rend())
+ it->payload_size = buffer_size - it->payload_start_offset;
+
+ return sequences;
+}
+
+NaluType ParseNaluType(uint8_t data) {
+ return static_cast<NaluType>((data & kNaluTypeMask) >> 1);
+}
+
+std::vector<uint8_t> ParseRbsp(const uint8_t* data, size_t length) {
+ std::vector<uint8_t> out;
+ out.reserve(length);
+
+ for (size_t i = 0; i < length;) {
+ // Be careful about over/underflow here. byte_length_ - 3 can underflow, and
+ // i + 3 can overflow, but byte_length_ - i can't, because i < byte_length_
+ // above, and that expression will produce the number of bytes left in
+ // the stream including the byte at i.
+ if (length - i >= 3 && !data[i] && !data[i + 1] && data[i + 2] == 3) {
+ // Two rbsp bytes.
+ out.push_back(data[i++]);
+ out.push_back(data[i++]);
+ // Skip the emulation byte.
+ i++;
+ } else {
+ // Single rbsp byte.
+ out.push_back(data[i++]);
+ }
+ }
+ return out;
+}
+
+void WriteRbsp(const uint8_t* bytes, size_t length, rtc::Buffer* destination) {
+ static const uint8_t kZerosInStartSequence = 2;
+ static const uint8_t kEmulationByte = 0x03u;
+ size_t num_consecutive_zeros = 0;
+ destination->EnsureCapacity(destination->size() + length);
+
+ for (size_t i = 0; i < length; ++i) {
+ uint8_t byte = bytes[i];
+ if (byte <= kEmulationByte &&
+ num_consecutive_zeros >= kZerosInStartSequence) {
+ // Need to escape.
+ destination->AppendData(kEmulationByte);
+ num_consecutive_zeros = 0;
+ }
+ destination->AppendData(byte);
+ if (byte == 0) {
+ ++num_consecutive_zeros;
+ } else {
+ num_consecutive_zeros = 0;
+ }
+ }
+}
+
+} // namespace H265
+} // namespace webrtc
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/common_video/h265/h265_common.h b/Source/ThirdParty/libwebrtc/Source/webrtc/common_video/h265/h265_common.h
new file mode 100644
index 000000000000..d3c5326b72c3
--- /dev/null
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/common_video/h265/h265_common.h
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef COMMON_VIDEO_H265_H265_COMMON_H_
+#define COMMON_VIDEO_H265_H265_COMMON_H_
+
+#include <memory>
+#include <vector>
+
+#include "common_video/h264/h264_common.h"
+#include "rtc_base/buffer.h"
+
+namespace webrtc {
+
+namespace H265 {
+// The size of a full NALU start sequence {0 0 0 1}, used for the first NALU
+// of an access unit, and for SPS and PPS blocks.
+const size_t kNaluLongStartSequenceSize = 4;
+
+// The size of a shortened NALU start sequence {0 0 1}, that may be used if
+// not the first NALU of an access unit or an SPS or PPS block.
+const size_t kNaluShortStartSequenceSize = 3;
+
+// The size of the NALU type byte (1).
+const size_t kNaluTypeSize = 1;
+
+enum NaluType : uint8_t {
+ kTrailN = 0,
+ kTrailR = 1,
+ kTsaN = 2,
+ kTsaR = 3,
+ kStsaN = 4,
+ kStsaR = 5,
+ kRadlN = 6,
+ kRadlR = 7,
+ kBlaWLp = 16,
+ kBlaWRadl = 17,
+ kBlaNLp = 18,
+ kIdrWRadl = 19,
+ kIdrNLp = 20,
+ kCra = 21,
+ kRsvIrapVcl23 = 23,
+ kVps = 32,
+ kSps = 33,
+ kPps = 34,
+ kAud = 35,
+ kPrefixSei = 39,
+ kSuffixSei = 40,
+ kAP = 48,
+ kFU = 49
+};
+
+enum SliceType : uint8_t { kP = 0, kB = 1, kI = 2, kSp = 3, kSi = 4 };
+
+// Returns a vector of the NALU indices in the given buffer.
+std::vector<H264::NaluIndex> FindNaluIndices(const uint8_t* buffer,
+ size_t buffer_size);
+
+// Get the NAL type from the header byte immediately following start sequence.
+NaluType ParseNaluType(uint8_t data);
+
+// Methods for parsing and writing RBSP. See section 7.4.2 of the H265 spec.
+//
+// The following sequences are illegal, and need to be escaped when encoding:
+// 00 00 00 -> 00 00 03 00
+// 00 00 01 -> 00 00 03 01
+// 00 00 02 -> 00 00 03 02
+// And things in the source that look like the emulation byte pattern (00 00 03)
+// need to have an extra emulation byte added, so it's removed when decoding:
+// 00 00 03 -> 00 00 03 03
+//
+// Decoding is simply a matter of finding any 00 00 03 sequence and removing
+// the 03 emulation byte.
+
+// Parse the given data and remove any emulation byte escaping.
+std::vector<uint8_t> ParseRbsp(const uint8_t* data, size_t length);
+
+// Write the given data to the destination buffer, inserting and emulation
+// bytes in order to escape any data the could be interpreted as a start
+// sequence.
+void WriteRbsp(const uint8_t* bytes, size_t length, rtc::Buffer* destination);
+} // namespace H265
+} // namespace webrtc
+
+#endif // COMMON_VIDEO_H265_H265_COMMON_H_
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/common_video/h265/h265_pps_parser.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/common_video/h265/h265_pps_parser.cc
new file mode 100644
index 000000000000..418411ced327
--- /dev/null
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/common_video/h265/h265_pps_parser.cc
@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "common_video/h265/h265_pps_parser.h"
+
+#include <memory>
+#include <vector>
+
+#include "common_video/h264/h264_common.h"
+#include "common_video/h265/h265_common.h"
+#include "rtc_base/bit_buffer.h"
+#include "rtc_base/logging.h"
+
+#define RETURN_EMPTY_ON_FAIL(x) \
+ if (!(x)) { \
+ return absl::nullopt; \
+ }
+
+namespace {
+const int kMaxPicInitQpDeltaValue = 25;
+const int kMinPicInitQpDeltaValue = -26;
+} // namespace
+
+namespace webrtc {
+
+// General note: this is based off the 02/2018 version of the H.265 standard.
+// You can find it on this page:
+// http://www.itu.int/rec/T-REC-H.265
+
+absl::optional<H265PpsParser::PpsState> H265PpsParser::ParsePps(
+ const uint8_t* data,
+ size_t length) {
+ // First, parse out rbsp, which is basically the source buffer minus emulation
+ // bytes (the last byte of a 0x00 0x00 0x03 sequence). RBSP is defined in
+ // section 7.3.1 of the H.264 standard.
+ std::vector<uint8_t> unpacked_buffer = H264::ParseRbsp(data, length);
+ rtc::BitBuffer bit_buffer(unpacked_buffer.data(), unpacked_buffer.size());
+ return ParseInternal(&bit_buffer);
+}
+
+bool H265PpsParser::ParsePpsIds(const uint8_t* data,
+ size_t length,
+ uint32_t* pps_id,
+ uint32_t* sps_id) {
+ RTC_DCHECK(pps_id);
+ RTC_DCHECK(sps_id);
+ // First, parse out rbsp, which is basically the source buffer minus emulation
+ // bytes (the last byte of a 0x00 0x00 0x03 sequence). RBSP is defined in
+ // section 7.3.1 of the H.265 standard.
+ std::vector<uint8_t> unpacked_buffer = H264::ParseRbsp(data, length);
+ rtc::BitBuffer bit_buffer(unpacked_buffer.data(), unpacked_buffer.size());
+ return ParsePpsIdsInternal(&bit_buffer, pps_id, sps_id);
+}
+
+absl::optional<uint32_t> H265PpsParser::ParsePpsIdFromSliceSegmentLayerRbsp(
+ const uint8_t* data,
+ size_t length,
+ uint8_t nalu_type) {
+ rtc::BitBuffer slice_reader(data, length);
+
+ // first_slice_segment_in_pic_flag: u(1)
+ uint32_t first_slice_segment_in_pic_flag = 0;
+ RETURN_EMPTY_ON_FAIL(
+ slice_reader.ReadBits(&first_slice_segment_in_pic_flag, 1));
+
+ if (nalu_type >= H265::NaluType::kBlaWLp &&
+ nalu_type <= H265::NaluType::kRsvIrapVcl23) {
+ // no_output_of_prior_pics_flag: u(1)
+ RETURN_EMPTY_ON_FAIL(slice_reader.ConsumeBits(1));
+ }
+
+ // slice_pic_parameter_set_id: ue(v)
+ uint32_t slice_pic_parameter_set_id = 0;
+ if (!slice_reader.ReadExponentialGolomb(&slice_pic_parameter_set_id))
+ return absl::nullopt;
+
+ return slice_pic_parameter_set_id;
+}
+
+absl::optional<H265PpsParser::PpsState> H265PpsParser::ParseInternal(
+ rtc::BitBuffer* bit_buffer) {
+ PpsState pps;
+
+ RETURN_EMPTY_ON_FAIL(ParsePpsIdsInternal(bit_buffer, &pps.id, &pps.sps_id));
+
+ uint32_t bits_tmp;
+ uint32_t golomb_ignored;
+ // entropy_coding_mode_flag: u(1)
+ uint32_t entropy_coding_mode_flag;
+ RETURN_EMPTY_ON_FAIL(bit_buffer->ReadBits(&entropy_coding_mode_flag, 1));
+ pps.entropy_coding_mode_flag = entropy_coding_mode_flag != 0;
+ // bottom_field_pic_order_in_frame_present_flag: u(1)
+ uint32_t bottom_field_pic_order_in_frame_present_flag;
+ RETURN_EMPTY_ON_FAIL(
+ bit_buffer->ReadBits(&bottom_field_pic_order_in_frame_present_flag, 1));
+ pps.bottom_field_pic_order_in_frame_present_flag =
+ bottom_field_pic_order_in_frame_present_flag != 0;
+
+ // num_slice_groups_minus1: ue(v)
+ uint32_t num_slice_groups_minus1;
+ RETURN_EMPTY_ON_FAIL(
+ bit_buffer->ReadExponentialGolomb(&num_slice_groups_minus1));
+ if (num_slice_groups_minus1 > 0) {
+ uint32_t slice_group_map_type;
+ // slice_group_map_type: ue(v)
+ RETURN_EMPTY_ON_FAIL(
+ bit_buffer->ReadExponentialGolomb(&slice_group_map_type));
+ if (slice_group_map_type == 0) {
+ for (uint32_t i_group = 0; i_group <= num_slice_groups_minus1;
+ ++i_group) {
+ // run_length_minus1[iGroup]: ue(v)
+ RETURN_EMPTY_ON_FAIL(
+ bit_buffer->ReadExponentialGolomb(&golomb_ignored));
+ }
+ } else if (slice_group_map_type == 1) {
+ // TODO(sprang): Implement support for dispersed slice group map type.
+ // See 8.2.2.2 Specification for dispersed slice group map type.
+ } else if (slice_group_map_type == 2) {
+ for (uint32_t i_group = 0; i_group <= num_slice_groups_minus1;
+ ++i_group) {
+ // top_left[iGroup]: ue(v)
+ RETURN_EMPTY_ON_FAIL(
+ bit_buffer->ReadExponentialGolomb(&golomb_ignored));
+ // bottom_right[iGroup]: ue(v)
+ RETURN_EMPTY_ON_FAIL(
+ bit_buffer->ReadExponentialGolomb(&golomb_ignored));
+ }
+ } else if (slice_group_map_type == 3 || slice_group_map_type == 4 ||
+ slice_group_map_type == 5) {
+ // slice_group_change_direction_flag: u(1)
+ RETURN_EMPTY_ON_FAIL(bit_buffer->ReadBits(&bits_tmp, 1));
+ // slice_group_change_rate_minus1: ue(v)
+ RETURN_EMPTY_ON_FAIL(bit_buffer->ReadExponentialGolomb(&golomb_ignored));
+ } else if (slice_group_map_type == 6) {
+ // pic_size_in_map_units_minus1: ue(v)
+ uint32_t pic_size_in_map_units_minus1;
+ RETURN_EMPTY_ON_FAIL(
+ bit_buffer->ReadExponentialGolomb(&pic_size_in_map_units_minus1));
+ uint32_t slice_group_id_bits = 0;
+ uint32_t num_slice_groups = num_slice_groups_minus1 + 1;
+ // If num_slice_groups is not a power of two an additional bit is required
+ // to account for the ceil() of log2() below.
+ if ((num_slice_groups & (num_slice_groups - 1)) != 0)
+ ++slice_group_id_bits;
+ while (num_slice_groups > 0) {
+ num_slice_groups >>= 1;
+ ++slice_group_id_bits;
+ }
+ for (uint32_t i = 0; i <= pic_size_in_map_units_minus1; i++) {
+ // slice_group_id[i]: u(v)
+ // Represented by ceil(log2(num_slice_groups_minus1 + 1)) bits.
+ RETURN_EMPTY_ON_FAIL(
+ bit_buffer->ReadBits(&bits_tmp, slice_group_id_bits));
+ }
+ }
+ }
+ // num_ref_idx_l0_default_active_minus1: ue(v)
+ RETURN_EMPTY_ON_FAIL(bit_buffer->ReadExponentialGolomb(&golomb_ignored));
+ // num_ref_idx_l1_default_active_minus1: ue(v)
+ RETURN_EMPTY_ON_FAIL(bit_buffer->ReadExponentialGolomb(&golomb_ignored));
+ // weighted_pred_flag: u(1)
+ uint32_t weighted_pred_flag;
+ RETURN_EMPTY_ON_FAIL(bit_buffer->ReadBits(&weighted_pred_flag, 1));
+ pps.weighted_pred_flag = weighted_pred_flag != 0;
+ // weighted_bipred_idc: u(2)
+ RETURN_EMPTY_ON_FAIL(bit_buffer->ReadBits(&pps.weighted_bipred_idc, 2));
+
+ // pic_init_qp_minus26: se(v)
+ RETURN_EMPTY_ON_FAIL(
+ bit_buffer->ReadSignedExponentialGolomb(&pps.pic_init_qp_minus26));
+ // Sanity-check parsed value
+ if (pps.pic_init_qp_minus26 > kMaxPicInitQpDeltaValue ||
+ pps.pic_init_qp_minus26 < kMinPicInitQpDeltaValue) {
+ RETURN_EMPTY_ON_FAIL(false);
+ }
+ // pic_init_qs_minus26: se(v)
+ RETURN_EMPTY_ON_FAIL(bit_buffer->ReadExponentialGolomb(&golomb_ignored));
+ // chroma_qp_index_offset: se(v)
+ RETURN_EMPTY_ON_FAIL(bit_buffer->ReadExponentialGolomb(&golomb_ignored));
+ // deblocking_filter_control_present_flag: u(1)
+ // constrained_intra_pred_flag: u(1)
+ RETURN_EMPTY_ON_FAIL(bit_buffer->ReadBits(&bits_tmp, 2));
+ // redundant_pic_cnt_present_flag: u(1)
+ RETURN_EMPTY_ON_FAIL(
+ bit_buffer->ReadBits(&pps.redundant_pic_cnt_present_flag, 1));
+
+ return pps;
+}
+
+bool H265PpsParser::ParsePpsIdsInternal(rtc::BitBuffer* bit_buffer,
+ uint32_t* pps_id,
+ uint32_t* sps_id) {
+ // pic_parameter_set_id: ue(v)
+ if (!bit_buffer->ReadExponentialGolomb(pps_id))
+ return false;
+ // seq_parameter_set_id: ue(v)
+ if (!bit_buffer->ReadExponentialGolomb(sps_id))
+ return false;
+ return true;
+}
+
+} // namespace webrtc
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/common_video/h265/h265_pps_parser.h b/Source/ThirdParty/libwebrtc/Source/webrtc/common_video/h265/h265_pps_parser.h
new file mode 100644
index 000000000000..cfa471883dca
--- /dev/null
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/common_video/h265/h265_pps_parser.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef COMMON_VIDEO_H265_PPS_PARSER_H_
+#define COMMON_VIDEO_H265_PPS_PARSER_H_
+
+#include "absl/types/optional.h"
+
+namespace rtc {
+class BitBuffer;
+}
+
+namespace webrtc {
+
+// A class for parsing out picture parameter set (PPS) data from a H265 NALU.
+class H265PpsParser {
+ public:
+ // The parsed state of the PPS. Only some select values are stored.
+ // Add more as they are actually needed.
+ struct PpsState {
+ PpsState() = default;
+
+ bool bottom_field_pic_order_in_frame_present_flag = false;
+ bool weighted_pred_flag = false;
+ bool entropy_coding_mode_flag = false;
+ uint32_t weighted_bipred_idc = false;
+ uint32_t redundant_pic_cnt_present_flag = 0;
+ int pic_init_qp_minus26 = 0;
+ uint32_t id = 0;
+ uint32_t sps_id = 0;
+ };
+
+ // Unpack RBSP and parse PPS state from the supplied buffer.
+ static absl::optional<PpsState> ParsePps(const uint8_t* data, size_t length);
+
+ static bool ParsePpsIds(const uint8_t* data,
+ size_t length,
+ uint32_t* pps_id,
+ uint32_t* sps_id);
+
+ static absl::optional<uint32_t> ParsePpsIdFromSliceSegmentLayerRbsp(
+ const uint8_t* data,
+ size_t length,
+ uint8_t nalu_type);
+
+ protected:
+ // Parse the PPS state, for a bit buffer where RBSP decoding has already been
+ // performed.
+ static absl::optional<PpsState> ParseInternal(rtc::BitBuffer* bit_buffer);
+ static bool ParsePpsIdsInternal(rtc::BitBuffer* bit_buffer,
+ uint32_t* pps_id,
+ uint32_t* sps_id);
+};
+
+} // namespace webrtc
+
+#endif // COMMON_VIDEO_H265_PPS_PARSER_H_
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/common_video/h265/h265_sps_parser.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/common_video/h265/h265_sps_parser.cc
new file mode 100644
index 000000000000..0433f4b0ee92
--- /dev/null
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/common_video/h265/h265_sps_parser.cc
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <memory>
+#include <vector>
+
+#include "common_video/h265/h265_common.h"
+#include "common_video/h265/h265_sps_parser.h"
+#include "rtc_base/bit_buffer.h"
+#include "rtc_base/logging.h"
+
+namespace {
+typedef absl::optional<webrtc::H265SpsParser::SpsState> OptionalSps;
+
+#define RETURN_EMPTY_ON_FAIL(x) \
+ if (!(x)) { \
+ return OptionalSps(); \
+ }
+} // namespace
+
+namespace webrtc {
+
+H265SpsParser::SpsState::SpsState() = default;
+
+// General note: this is based off the 02/2018 version of the H.265 standard.
+// You can find it on this page:
+// http://www.itu.int/rec/T-REC-H.265
+
+// Unpack RBSP and parse SPS state from the supplied buffer.
+absl::optional<H265SpsParser::SpsState> H265SpsParser::ParseSps(
+ const uint8_t* data,
+ size_t length) {
+ std::vector<uint8_t> unpacked_buffer = H265::ParseRbsp(data, length);
+ rtc::BitBuffer bit_buffer(unpacked_buffer.data(), unpacked_buffer.size());
+ return ParseSpsUpToVui(&bit_buffer);
+}
+
+absl::optional<H265SpsParser::SpsState> H265SpsParser::ParseSpsUpToVui(
+ rtc::BitBuffer* buffer) {
+ // Now, we need to use a bit buffer to parse through the actual HEVC SPS
+ // format. See Section 7.3.2.2.1 ("General sequence parameter set data
+ // syntax") of the H.265 standard for a complete description.
+ // Since we only care about resolution, we ignore the majority of fields, but
+ // we still have to actively parse through a lot of the data, since many of
+ // the fields have variable size.
+ // We're particularly interested in:
+ // chroma_format_idc -> affects crop units
+ // pic_{width,height}_* -> resolution of the frame in macroblocks (16x16).
+ // frame_crop_*_offset -> crop information
+
+ SpsState sps;
+
+ // The golomb values we have to read, not just consume.
+ uint32_t golomb_ignored;
+
+ // separate_colour_plane_flag is optional (assumed 0), but has implications
+ // about the ChromaArrayType, which modifies how we treat crop coordinates.
+ uint32_t separate_colour_plane_flag = 0;
+
+ // chroma_format_idc will be ChromaArrayType if separate_colour_plane_flag is
+ // 0. It defaults to 1, when not specified.
+ uint32_t chroma_format_idc = 1;
+
+ // sps_video_parameter_set_id: u(4)
+ uint32_t sps_video_parameter_set_id = 0;
+ RETURN_EMPTY_ON_FAIL(buffer->ReadBits(&sps_video_parameter_set_id, 4));
+ // sps_max_sub_layers_minus1: u(3)
+ uint32_t sps_max_sub_layers_minus1 = 0;
+ RETURN_EMPTY_ON_FAIL(buffer->ReadBits(&sps_max_sub_layers_minus1, 3));
+ // sps_temporal_id_nesting_flag: u(1)
+ RETURN_EMPTY_ON_FAIL(buffer->ConsumeBits(1));
+ // profile_tier_level(1, sps_max_sub_layers_minus1). We are acutally not
+ // using them, so read/skip over it.
+ // general_profile_space+general_tier_flag+general_prfile_idc: u(8)
+ RETURN_EMPTY_ON_FAIL(buffer->ConsumeBytes(1));
+ // general_profile_compatabilitiy_flag[32]
+ RETURN_EMPTY_ON_FAIL(buffer->ConsumeBytes(4));
+ // general_progressive_source_flag + interlaced_source_flag+
+ // non-packed_constraint flag + frame_only_constraint_flag: u(4)
+ RETURN_EMPTY_ON_FAIL(buffer->ConsumeBits(4));
+ // general_profile_idc decided flags or reserved. u(43)
+ RETURN_EMPTY_ON_FAIL(buffer->ConsumeBits(43));
+ // general_inbld_flag or reserved 0: u(1)
+ RETURN_EMPTY_ON_FAIL(buffer->ConsumeBits(1));
+ // general_level_idc: u(8)
+ RETURN_EMPTY_ON_FAIL(buffer->ConsumeBytes(1));
+ // if max_sub_layers_minus1 >=1, read the sublayer profile information
+ std::vector<uint32_t> sub_layer_profile_present_flags;
+ std::vector<uint32_t> sub_layer_level_present_flags;
+ uint32_t sub_layer_profile_present = 0;
+ uint32_t sub_layer_level_present = 0;
+ for (uint32_t i = 0; i < sps_max_sub_layers_minus1; i++) {
+ // sublayer_profile_present_flag and sublayer_level_presnet_flag: u(2)
+ RETURN_EMPTY_ON_FAIL(buffer->ReadBits(&sub_layer_profile_present, 1));
+ RETURN_EMPTY_ON_FAIL(buffer->ReadBits(&sub_layer_level_present, 1));
+ sub_layer_profile_present_flags.push_back(sub_layer_profile_present);
+ sub_layer_level_present_flags.push_back(sub_layer_level_present);
+ }
+ if (sps_max_sub_layers_minus1 > 0) {
+ for (uint32_t j = sps_max_sub_layers_minus1; j < 8; j++) {
+ // reserved 2 bits: u(2)
+ RETURN_EMPTY_ON_FAIL(buffer->ConsumeBits(2));
+ }
+ }
+ for (uint32_t k = 0; k < sps_max_sub_layers_minus1; k++) {
+ if (sub_layer_profile_present_flags[k]) { //
+ // sub_layer profile_space/tier_flag/profile_idc. ignored. u(8)
+ RETURN_EMPTY_ON_FAIL(buffer->ConsumeBytes(1));
+ // profile_compatability_flag: u(32)
+ RETURN_EMPTY_ON_FAIL(buffer->ConsumeBytes(4));
+ // sub_layer progressive_source_flag/interlaced_source_flag/
+ // non_packed_constraint_flag/frame_only_constraint_flag: u(4)
+ RETURN_EMPTY_ON_FAIL(buffer->ConsumeBits(4));
+ // following 43-bits are profile_idc specific. We simply read/skip it.
+ // u(43)
+ RETURN_EMPTY_ON_FAIL(buffer->ConsumeBits(43));
+ // 1-bit profile_idc specific inbld flag. We simply read/skip it. u(1)
+ RETURN_EMPTY_ON_FAIL(buffer->ConsumeBits(1));
+ }
+ if (sub_layer_level_present_flags[k]) {
+ // sub_layer_level_idc: u(8)
+ RETURN_EMPTY_ON_FAIL(buffer->ConsumeBytes(1));
+ }
+ }
+ // sps_seq_parameter_set_id: ue(v)
+ RETURN_EMPTY_ON_FAIL(buffer->ReadExponentialGolomb(&golomb_ignored));
+ // chrome_format_idc: ue(v)
+ RETURN_EMPTY_ON_FAIL(buffer->ReadExponentialGolomb(&chroma_format_idc));
+ if (chroma_format_idc == 3) {
+ // seperate_colour_plane_flag: u(1)
+ RETURN_EMPTY_ON_FAIL(buffer->ReadBits(&separate_colour_plane_flag, 1));
+ }
+ uint32_t pic_width_in_luma_samples = 0;
+ uint32_t pic_height_in_luma_samples = 0;
+ // pic_width_in_luma_samples: ue(v)
+ RETURN_EMPTY_ON_FAIL(
+ buffer->ReadExponentialGolomb(&pic_width_in_luma_samples));
+ // pic_height_in_luma_samples: ue(v)
+ RETURN_EMPTY_ON_FAIL(
+ buffer->ReadExponentialGolomb(&pic_height_in_luma_samples));
+ // conformance_window_flag: u(1)
+ uint32_t conformance_window_flag = 0;
+ RETURN_EMPTY_ON_FAIL(buffer->ReadBits(&conformance_window_flag, 1));
+
+ uint32_t conf_win_left_offset = 0;
+ uint32_t conf_win_right_offset = 0;
+ uint32_t conf_win_top_offset = 0;
+ uint32_t conf_win_bottom_offset = 0;
+ if (conformance_window_flag) {
+ // conf_win_left_offset: ue(v)
+ RETURN_EMPTY_ON_FAIL(buffer->ReadExponentialGolomb(&conf_win_left_offset));
+ // conf_win_right_offset: ue(v)
+ RETURN_EMPTY_ON_FAIL(buffer->ReadExponentialGolomb(&conf_win_right_offset));
+ // conf_win_top_offset: ue(v)
+ RETURN_EMPTY_ON_FAIL(buffer->ReadExponentialGolomb(&conf_win_top_offset));
+ // conf_win_bottom_offset: ue(v)
+ RETURN_EMPTY_ON_FAIL(
+ buffer->ReadExponentialGolomb(&conf_win_bottom_offset));
+ }
+
+ // Far enough! We don't use the rest of the SPS.
+
+ sps.vps_id = sps_video_parameter_set_id;
+
+ // Start with the resolution determined by the pic_width/pic_height fields.
+ sps.width = pic_width_in_luma_samples;
+ sps.height = pic_height_in_luma_samples;
+
+ if (conformance_window_flag) {
+ int sub_width_c = ((1 == chroma_format_idc) || (2 == chroma_format_idc)) &&
+ (0 == separate_colour_plane_flag)
+ ? 2
+ : 1;
+ int sub_height_c =
+ (1 == chroma_format_idc) && (0 == separate_colour_plane_flag) ? 2 : 1;
+ // the offset includes the pixel within conformance window. so don't need to
+ // +1 as per spec
+ sps.width -= sub_width_c * (conf_win_right_offset + conf_win_left_offset);
+ sps.height -= sub_height_c * (conf_win_top_offset + conf_win_bottom_offset);
+ }
+
+ return OptionalSps(sps);
+}
+
+} // namespace webrtc
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/common_video/h265/h265_sps_parser.h b/Source/ThirdParty/libwebrtc/Source/webrtc/common_video/h265/h265_sps_parser.h
new file mode 100644
index 000000000000..a0f86b698326
--- /dev/null
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/common_video/h265/h265_sps_parser.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef COMMON_VIDEO_H265_H265_SPS_PARSER_H_
+#define COMMON_VIDEO_H265_H265_SPS_PARSER_H_
+
+#include "absl/types/optional.h"
+
+namespace rtc {
+class BitBuffer;
+}
+
+namespace webrtc {
+
+// A class for parsing out sequence parameter set (SPS) data from an H265 NALU.
+class H265SpsParser {
+ public:
+ // The parsed state of the SPS. Only some select values are stored.
+ // Add more as they are actually needed.
+ struct SpsState {
+ SpsState();
+
+ uint32_t width = 0;
+ uint32_t height = 0;
+ uint32_t delta_pic_order_always_zero_flag = 0;
+ uint32_t separate_colour_plane_flag = 0;
+ uint32_t frame_mbs_only_flag = 0;
+ uint32_t log2_max_frame_num_minus4 = 0;
+ uint32_t log2_max_pic_order_cnt_lsb_minus4 = 0;
+ uint32_t pic_order_cnt_type = 0;
+ uint32_t max_num_ref_frames = 0;
+ uint32_t vui_params_present = 0;
+ uint32_t id = 0;
+ uint32_t vps_id = 0;
+ };
+
+ // Unpack RBSP and parse SPS state from the supplied buffer.
+ static absl::optional<SpsState> ParseSps(const uint8_t* data, size_t length);
+
+ protected:
+ // Parse the SPS state, up till the VUI part, for a bit buffer where RBSP
+ // decoding has already been performed.
+ static absl::optional<SpsState> ParseSpsUpToVui(rtc::BitBuffer* buffer);
+};
+
+} // namespace webrtc
+#endif // COMMON_VIDEO_H265_H265_SPS_PARSER_H_
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/common_video/h265/h265_vps_parser.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/common_video/h265/h265_vps_parser.cc
new file mode 100644
index 000000000000..2391ae51df0f
--- /dev/null
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/common_video/h265/h265_vps_parser.cc
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <memory>
+#include <vector>
+
+#include "common_video/h265/h265_common.h"
+#include "common_video/h265/h265_vps_parser.h"
+#include "rtc_base/bit_buffer.h"
+#include "rtc_base/logging.h"
+
+namespace {
+typedef absl::optional<webrtc::H265VpsParser::VpsState> OptionalVps;
+
+#define RETURN_EMPTY_ON_FAIL(x) \
+ if (!(x)) { \
+ return OptionalVps(); \
+ }
+} // namespace
+
+namespace webrtc {
+
+H265VpsParser::VpsState::VpsState() = default;
+
+// General note: this is based off the 02/2018 version of the H.265 standard.
+// You can find it on this page:
+// http://www.itu.int/rec/T-REC-H.265
+
+// Unpack RBSP and parse SPS state from the supplied buffer.
+absl::optional<H265VpsParser::VpsState> H265VpsParser::ParseVps(
+ const uint8_t* data,
+ size_t length) {
+ std::vector<uint8_t> unpacked_buffer = H265::ParseRbsp(data, length);
+ rtc::BitBuffer bit_buffer(unpacked_buffer.data(), unpacked_buffer.size());
+ return ParseInternal(&bit_buffer);
+}
+
+absl::optional<H265VpsParser::VpsState> H265VpsParser::ParseInternal(
+ rtc::BitBuffer* buffer) {
+ // Now, we need to use a bit buffer to parse through the actual HEVC VPS
+ // format. See Section 7.3.2.1 ("Video parameter set RBSP syntax") of the
+ // H.265 standard for a complete description.
+
+ VpsState vps;
+
+ // vps_video_parameter_set_id: u(4)
+ uint32_t vps_video_parameter_set_id = 0;
+ RETURN_EMPTY_ON_FAIL(buffer->ReadBits(&vps_video_parameter_set_id, 4));
+
+ vps.id = vps_video_parameter_set_id;
+ vps.id = 0;
+ return OptionalVps(vps);
+}
+
+} // namespace webrtc
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/common_video/h265/h265_vps_parser.h b/Source/ThirdParty/libwebrtc/Source/webrtc/common_video/h265/h265_vps_parser.h
new file mode 100644
index 000000000000..e8a2775f43df
--- /dev/null
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/common_video/h265/h265_vps_parser.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef COMMON_VIDEO_H265_H265_VPS_PARSER_H_
+#define COMMON_VIDEO_H265_H265_VPS_PARSER_H_
+
+#include "absl/types/optional.h"
+
+namespace rtc {
+class BitBuffer;
+}
+
+namespace webrtc {
+
+// A class for parsing out sequence parameter set (VPS) data from an H265 NALU.
+class H265VpsParser {
+ public:
+ // The parsed state of the VPS. Only some select values are stored.
+ // Add more as they are actually needed.
+ struct VpsState {
+ VpsState();
+
+ uint32_t id = 0;
+ };
+
+ // Unpack RBSP and parse VPS state from the supplied buffer.
+ static absl::optional<VpsState> ParseVps(const uint8_t* data, size_t length);
+
+ protected:
+ // Parse the VPS state, for a bit buffer where RBSP decoding has already been
+ // performed.
+ static absl::optional<VpsState> ParseInternal(rtc::BitBuffer* bit_buffer);
+};
+
+} // namespace webrtc
+#endif // COMMON_VIDEO_H265_H265_VPS_PARSER_H_
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/common_video/video_frame_buffer.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/common_video/video_frame_buffer.cc
index 823c5ad7a118..dad595b8db31 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/common_video/video_frame_buffer.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/common_video/video_frame_buffer.cc
@@ -266,7 +266,7 @@ rtc::scoped_refptr<PlanarYuvBuffer> WrapYuvBuffer(
return WrapI444Buffer(width, height, y_plane, y_stride, u_plane, u_stride,
v_plane, v_stride, no_longer_used);
default:
- FATAL() << "Unexpected frame buffer type.";
+ RTC_FATAL() << "Unexpected frame buffer type.";
return nullptr;
}
}
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng.cc
index 600cb0c06a23..fb08251e3e71 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng.cc
@@ -172,7 +172,7 @@ AudioEncoder::EncodedInfo AudioEncoderCng::EncodeImpl(
break;
}
case Vad::kError: {
- FATAL(); // Fails only if fed invalid data.
+ RTC_FATAL(); // Fails only if fed invalid data.
break;
}
}
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_coding/codecs/ilbc/audio_encoder_ilbc.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_coding/codecs/ilbc/audio_encoder_ilbc.cc
index 032de20246f3..4bfaa6e478d5 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_coding/codecs/ilbc/audio_encoder_ilbc.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_coding/codecs/ilbc/audio_encoder_ilbc.cc
@@ -34,7 +34,7 @@ int GetIlbcBitrate(int ptime) {
// 50 bytes per frame of 30 ms => (approx) 13333 bits/s.
return 13333;
default:
- FATAL();
+ RTC_FATAL();
}
}
@@ -144,7 +144,7 @@ size_t AudioEncoderIlbcImpl::RequiredOutputSizeBytes() const {
case 6:
return 2 * 50;
default:
- FATAL();
+ RTC_FATAL();
}
}
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_coding/neteq/tools/rtp_file_source.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_coding/neteq/tools/rtp_file_source.cc
index f57806557859..b02ef4479acb 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_coding/neteq/tools/rtp_file_source.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_coding/neteq/tools/rtp_file_source.cc
@@ -91,7 +91,7 @@ bool RtpFileSource::OpenFile(const std::string& file_name) {
return true;
rtp_reader_.reset(RtpFileReader::Create(RtpFileReader::kPcap, file_name));
if (!rtp_reader_) {
- FATAL() << "Couldn't open input file as either a rtpdump or .pcap. Note "
+ RTC_FATAL() << "Couldn't open input file as either a rtpdump or .pcap. Note "
"that .pcapng is not supported.";
}
return true;
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_processing/aec3/adaptive_fir_filter.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_processing/aec3/adaptive_fir_filter.cc
index bf3a7809f42b..82b01fea2079 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_processing/aec3/adaptive_fir_filter.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_processing/aec3/adaptive_fir_filter.cc
@@ -556,10 +556,12 @@ void AdaptiveFirFilter::Filter(const RenderBuffer& render_buffer,
case Aec3Optimization::kSse2:
aec3::ApplyFilter_Sse2(render_buffer, current_size_partitions_, H_, S);
break;
+#if !defined(WEBRTC_WEBKIT_BUILD)
case Aec3Optimization::kAvx2:
aec3::ApplyFilter_Avx2(render_buffer, current_size_partitions_, H_, S);
break;
#endif
+#endif
#if defined(WEBRTC_HAS_NEON)
case Aec3Optimization::kNeon:
aec3::ApplyFilter_Neon(render_buffer, current_size_partitions_, H_, S);
@@ -600,10 +602,12 @@ void AdaptiveFirFilter::ComputeFrequencyResponse(
case Aec3Optimization::kSse2:
aec3::ComputeFrequencyResponse_Sse2(current_size_partitions_, H_, H2);
break;
+#if !defined(WEBRTC_WEBKIT_BUILD)
case Aec3Optimization::kAvx2:
aec3::ComputeFrequencyResponse_Avx2(current_size_partitions_, H_, H2);
break;
#endif
+#endif
#if defined(WEBRTC_HAS_NEON)
case Aec3Optimization::kNeon:
aec3::ComputeFrequencyResponse_Neon(current_size_partitions_, H_, H2);
@@ -626,11 +630,13 @@ void AdaptiveFirFilter::AdaptAndUpdateSize(const RenderBuffer& render_buffer,
aec3::AdaptPartitions_Sse2(render_buffer, G, current_size_partitions_,
&H_);
break;
+#if !defined(WEBRTC_WEBKIT_BUILD)
case Aec3Optimization::kAvx2:
aec3::AdaptPartitions_Avx2(render_buffer, G, current_size_partitions_,
&H_);
break;
#endif
+#endif
#if defined(WEBRTC_HAS_NEON)
case Aec3Optimization::kNeon:
aec3::AdaptPartitions_Neon(render_buffer, G, current_size_partitions_,
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_processing/aec3/adaptive_fir_filter_erl.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_processing/aec3/adaptive_fir_filter_erl.cc
index 45b881397984..baa1986668a9 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_processing/aec3/adaptive_fir_filter_erl.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_processing/aec3/adaptive_fir_filter_erl.cc
@@ -85,10 +85,12 @@ void ComputeErl(const Aec3Optimization& optimization,
case Aec3Optimization::kSse2:
aec3::ErlComputer_SSE2(H2, erl);
break;
+#if !defined(WEBRTC_WEBKIT_BUILD)
case Aec3Optimization::kAvx2:
aec3::ErlComputer_AVX2(H2, erl);
break;
#endif
+#endif
#if defined(WEBRTC_HAS_NEON)
case Aec3Optimization::kNeon:
aec3::ErlComputer_NEON(H2, erl);
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_processing/aec3/fft_data.h b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_processing/aec3/fft_data.h
index 9c25e784aa01..141606185fac 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_processing/aec3/fft_data.h
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_processing/aec3/fft_data.h
@@ -63,9 +63,11 @@ struct FftData {
power_spectrum[kFftLengthBy2] = re[kFftLengthBy2] * re[kFftLengthBy2] +
im[kFftLengthBy2] * im[kFftLengthBy2];
} break;
+#if !defined(WEBRTC_WEBKIT_BUILD)
case Aec3Optimization::kAvx2:
SpectrumAVX2(power_spectrum);
break;
+#endif
#endif
default:
std::transform(re.begin(), re.end(), im.begin(), power_spectrum.begin(),
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_processing/aec3/filter_analyzer.h b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_processing/aec3/filter_analyzer.h
index b0b7070119f6..f08ae0e79aa7 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_processing/aec3/filter_analyzer.h
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_processing/aec3/filter_analyzer.h
@@ -99,11 +99,11 @@ class FilterAnalyzer {
int delay_blocks);
private:
- bool significant_peak_;
- float filter_floor_accum_;
- float filter_secondary_peak_;
- size_t filter_floor_low_limit_;
- size_t filter_floor_high_limit_;
+ bool significant_peak_ = false;
+ float filter_floor_accum_ = 0.f;
+ float filter_secondary_peak_ = 0.f;
+ size_t filter_floor_low_limit_ = 0;
+ size_t filter_floor_high_limit_ = 0;
const float active_render_threshold_;
size_t consistent_estimate_counter_ = 0;
int consistent_delay_reference_ = -10;
@@ -122,8 +122,8 @@ class FilterAnalyzer {
consistent_filter_detector.Reset();
}
- float gain;
- size_t peak_index;
+ float gain = 0.f;
+ size_t peak_index = 0;
int filter_length_blocks;
bool consistent_estimate = false;
ConsistentFilterDetector consistent_filter_detector;
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_processing/aec3/matched_filter.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_processing/aec3/matched_filter.cc
index 64b2d4e697ad..9c93ddc81947 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_processing/aec3/matched_filter.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_processing/aec3/matched_filter.cc
@@ -364,12 +364,14 @@ void MatchedFilter::Update(const DownsampledRenderBuffer& render_buffer,
smoothing_, render_buffer.buffer, y,
filters_[n], &filters_updated, &error_sum);
break;
+#if !defined(WEBRTC_WEBKIT_BUILD)
case Aec3Optimization::kAvx2:
aec3::MatchedFilterCore_AVX2(x_start_index, x2_sum_threshold,
smoothing_, render_buffer.buffer, y,
filters_[n], &filters_updated, &error_sum);
break;
#endif
+#endif
#if defined(WEBRTC_HAS_NEON)
case Aec3Optimization::kNeon:
aec3::MatchedFilterCore_NEON(x_start_index, x2_sum_threshold,
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_processing/aec3/vector_math.h b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_processing/aec3/vector_math.h
index e4d1381ae176..c8427f848cac 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_processing/aec3/vector_math.h
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/audio_processing/aec3/vector_math.h
@@ -59,10 +59,12 @@ class VectorMath {
x[j] = sqrtf(x[j]);
}
} break;
+#if !defined(WEBRTC_WEBKIT_BUILD)
case Aec3Optimization::kAvx2:
SqrtAVX2(x);
break;
#endif
+#endif
#if defined(WEBRTC_HAS_NEON)
case Aec3Optimization::kNeon: {
const int x_size = static_cast<int>(x.size());
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/remote_bitrate_estimator/inter_arrival.h b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/remote_bitrate_estimator/inter_arrival.h
index dbc630ff6324..f18d5a078f3c 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/remote_bitrate_estimator/inter_arrival.h
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/remote_bitrate_estimator/inter_arrival.h
@@ -60,7 +60,8 @@ class InterArrival {
first_timestamp(0),
timestamp(0),
first_arrival_ms(-1),
- complete_time_ms(-1) {}
+ complete_time_ms(-1),
+ last_system_time_ms(0) {}
bool IsFirstPacket() const { return complete_time_ms == -1; }
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/rtp_rtcp/source/create_video_rtp_depacketizer.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/rtp_rtcp/source/create_video_rtp_depacketizer.cc
index 724ad8c42edf..a92c2599a4f1 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/rtp_rtcp/source/create_video_rtp_depacketizer.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/rtp_rtcp/source/create_video_rtp_depacketizer.cc
@@ -13,6 +13,7 @@
#include <memory>
#include "api/video/video_codec_type.h"
+#include "modules/rtp_rtcp/source/rtp_format_h265.h"
#include "modules/rtp_rtcp/source/video_rtp_depacketizer.h"
#include "modules/rtp_rtcp/source/video_rtp_depacketizer_av1.h"
#include "modules/rtp_rtcp/source/video_rtp_depacketizer_generic.h"
@@ -27,6 +28,10 @@ std::unique_ptr<VideoRtpDepacketizer> CreateVideoRtpDepacketizer(
switch (codec) {
case kVideoCodecH264:
return std::make_unique<VideoRtpDepacketizerH264>();
+#ifndef DISABLE_H265
+ case kVideoCodecH265:
+ return std::make_unique<VideoRtpDepacketizerGeneric>();
+#endif
case kVideoCodecVP8:
return std::make_unique<VideoRtpDepacketizerVp8>();
case kVideoCodecVP9:
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/rtp_rtcp/source/h265_sps_parser.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/rtp_rtcp/source/h265_sps_parser.cc
new file mode 100644
index 000000000000..3f34630aa87b
--- /dev/null
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/rtp_rtcp/source/h265_sps_parser.cc
@@ -0,0 +1,191 @@
+/*
+ * Intel License
+ * See https://01.org/open-webrtc-toolkit
+ * This is released under Apache License 2.0 and it is free for both academic and commercial use.
+ */
+
+#include "webrtc/modules/rtp_rtcp/source/h265_sps_parser.h"
+
+#include "rtc_base/bit_buffer.h"
+#include "rtc_base/byte_buffer.h"
+#include "rtc_base/logging.h"
+
+#include <vector>
+
+#define RETURN_FALSE_ON_FAIL(x) \
+ if (!(x)) { \
+ return false; \
+ }
+
+namespace webrtc {
+
+H265SpsParser::H265SpsParser(const uint8_t* sps, size_t byte_length)
+ : sps_(sps), byte_length_(byte_length), width_(), height_() {
+}
+
+bool H265SpsParser::Parse() {
+ // General note: this is based off the 04/2015 version of the H.265 standard.
+ // You can find it on this page:
+ // http://www.itu.int/rec/T-REC-H.265
+
+ const char* sps_bytes = reinterpret_cast<const char*>(sps_);
+ // First, parse out rbsp, which is basically the source buffer minus emulation
+ // bytes (the last byte of a 0x00 0x00 0x03 sequence). RBSP is defined in
+ // section 7.3.1.1 of the H.265 standard, similar to H264.
+ rtc::ByteBufferWriter rbsp_buffer;
+ for (size_t i = 0; i < byte_length_;) {
+ // Be careful about over/underflow here. byte_length_ - 3 can underflow, and
+ // i + 3 can overflow, but byte_length_ - i can't, because i < byte_length_
+ // above, and that expression will produce the number of bytes left in
+ // the stream including the byte at i.
+ if (byte_length_ - i >= 3 && sps_[i] == 0 && sps_[i + 1] == 0 &&
+ sps_[i + 2] == 3) {
+ // Two rbsp bytes + the emulation byte.
+ rbsp_buffer.WriteBytes(sps_bytes + i, 2);
+ i += 3;
+ } else {
+ // Single rbsp byte.
+ rbsp_buffer.WriteBytes(sps_bytes + i, 1);
+ i++;
+ }
+ }
+
+ // Now, we need to use a bit buffer to parse through the actual HEVC SPS
+ // format. See Section 7.3.2.1.1 ("Sequence parameter set data syntax") of the
+ // H.265 standard for a complete description.
+ // Since we only care about resolution, we ignore the majority of fields, but
+ // we still have to actively parse through a lot of the data, since many of
+ // the fields have variable size.
+ // Unlike H264, for H265, the picture size is indicated by pic_width_in_luma_samples
+ // and pic_height_in_luma_samples, if conformance_window_flag !=1;
+ // When conformance_window_flag is 1, the width is adjusted with con_win_xx_offset
+ //
+ rtc::BitBuffer parser(reinterpret_cast<const uint8_t*>(rbsp_buffer.Data()),
+ rbsp_buffer.Length());
+
+ // The golomb values we have to read, not just consume.
+ uint32_t golomb_ignored;
+
+ // separate_colour_plane_flag is optional (assumed 0), but has implications
+ // about the ChromaArrayType, which modifies how we treat crop coordinates.
+ uint32_t separate_colour_plane_flag = 0;
+ // chroma_format_idc will be ChromaArrayType if separate_colour_plane_flag is
+ // 0. It defaults to 1, when not specified.
+ uint32_t chroma_format_idc = 1;
+
+
+ // sps_video_parameter_set_id: u(4)
+ RETURN_FALSE_ON_FAIL(parser.ConsumeBits(4));
+ // sps_max_sub_layers_minus1: u(3)
+ uint32_t sps_max_sub_layers_minus1 = 0;
+ RETURN_FALSE_ON_FAIL(parser.ReadBits(&sps_max_sub_layers_minus1, 3));
+ // sps_temporal_id_nesting_flag: u(1)
+ RETURN_FALSE_ON_FAIL(parser.ConsumeBits(1));
+ // profile_tier_level(1, sps_max_sub_layers_minus1). We are acutally not
+ // using them, so read/skip over it.
+ // general_profile_space+general_tier_flag+general_prfile_idc: u(8)
+ RETURN_FALSE_ON_FAIL(parser.ConsumeBytes(1));
+ // general_profile_compatabilitiy_flag[32]
+ RETURN_FALSE_ON_FAIL(parser.ConsumeBytes(4));
+ // general_progressive_source_flag + interlaced_source_flag+ non-packed_constraint
+ // flag + frame_only_constraint_flag: u(4)
+ RETURN_FALSE_ON_FAIL(parser.ConsumeBits(4));
+ // general_profile_idc decided flags or reserved. u(43)
+ RETURN_FALSE_ON_FAIL(parser.ConsumeBits(43));
+ // general_inbld_flag or reserved 0: u(1)
+ RETURN_FALSE_ON_FAIL(parser.ConsumeBits(1));
+ // general_level_idc: u(8)
+ RETURN_FALSE_ON_FAIL(parser.ConsumeBytes(1));
+ // if max_sub_layers_minus1 >=1, read the sublayer profile information
+ std::vector<uint32_t> sub_layer_profile_present_flags;
+ std::vector<uint32_t> sub_layer_level_present_flags;
+ uint32_t sub_layer_profile_present = 0;
+ uint32_t sub_layer_level_present = 0;
+ for (uint32_t i = 0; i < sps_max_sub_layers_minus1; i++) {
+ //sublayer_profile_present_flag and sublayer_level_presnet_flag: u(2)
+ RETURN_FALSE_ON_FAIL(parser.ReadBits(&sub_layer_profile_present, 1));
+ RETURN_FALSE_ON_FAIL(parser.ReadBits(&sub_layer_level_present, 1));
+ sub_layer_profile_present_flags.push_back(sub_layer_profile_present);
+ sub_layer_level_present_flags.push_back(sub_layer_level_present);
+ }
+ if (sps_max_sub_layers_minus1 > 0) {
+ for (uint32_t j = sps_max_sub_layers_minus1; j < 8; j++) {
+ // reserved 2 bits: u(2)
+ RETURN_FALSE_ON_FAIL(parser.ConsumeBits(2));
+ }
+ }
+ for (uint32_t k = 0; k < sps_max_sub_layers_minus1; k++) {
+ if(sub_layer_profile_present_flags[k]) {//
+ // sub_layer profile_space/tier_flag/profile_idc. ignored. u(8)
+ RETURN_FALSE_ON_FAIL(parser.ConsumeBytes(1));
+ // profile_compatability_flag: u(32)
+ RETURN_FALSE_ON_FAIL(parser.ConsumeBytes(4));
+ // sub_layer progressive_source_flag/interlaced_source_flag/
+ // non_packed_constraint_flag/frame_only_constraint_flag: u(4)
+ RETURN_FALSE_ON_FAIL(parser.ConsumeBits(4));
+ // following 43-bits are profile_idc specific. We simply read/skip it. u(43)
+ RETURN_FALSE_ON_FAIL(parser.ConsumeBits(43));
+ // 1-bit profile_idc specific inbld flag. We simply read/skip it. u(1)
+ RETURN_FALSE_ON_FAIL(parser.ConsumeBits(1));
+ }
+ if (sub_layer_level_present_flags[k]) {
+ // sub_layer_level_idc: u(8)
+ RETURN_FALSE_ON_FAIL(parser.ConsumeBytes(1));
+ }
+ }
+ //sps_seq_parameter_set_id: ue(v)
+ RETURN_FALSE_ON_FAIL(parser.ReadExponentialGolomb(&golomb_ignored));
+ // chrome_format_idc: ue(v)
+ RETURN_FALSE_ON_FAIL(parser.ReadExponentialGolomb(&chroma_format_idc));
+ if (chroma_format_idc == 3) {
+ // seperate_colour_plane_flag: u(1)
+ RETURN_FALSE_ON_FAIL(parser.ReadBits(&separate_colour_plane_flag, 1));
+ }
+ uint32_t pic_width_in_luma_samples = 0;
+ uint32_t pic_height_in_luma_samples = 0;
+ // pic_width_in_luma_samples: ue(v)
+ RETURN_FALSE_ON_FAIL(parser.ReadExponentialGolomb(&pic_width_in_luma_samples));
+ // pic_height_in_luma_samples: ue(v)
+ RETURN_FALSE_ON_FAIL(parser.ReadExponentialGolomb(&pic_height_in_luma_samples));
+ // conformance_window_flag: u(1)
+ uint32_t conformance_window_flag = 0;
+ RETURN_FALSE_ON_FAIL(parser.ReadBits(&conformance_window_flag, 1));
+
+ uint32_t conf_win_left_offset = 0;
+ uint32_t conf_win_right_offset = 0;
+ uint32_t conf_win_top_offset = 0;
+ uint32_t conf_win_bottom_offset = 0;
+ if (conformance_window_flag) {
+ // conf_win_left_offset: ue(v)
+ RETURN_FALSE_ON_FAIL(parser.ReadExponentialGolomb(&conf_win_left_offset));
+ // conf_win_right_offset: ue(v)
+ RETURN_FALSE_ON_FAIL(parser.ReadExponentialGolomb(&conf_win_right_offset));
+ // conf_win_top_offset: ue(v)
+ RETURN_FALSE_ON_FAIL(parser.ReadExponentialGolomb(&conf_win_top_offset));
+ // conf_win_bottom_offset: ue(v)
+ RETURN_FALSE_ON_FAIL(parser.ReadExponentialGolomb(&conf_win_bottom_offset));
+ }
+
+ //For enough to get the resolution information. calcaluate according to HEVC spec 7.4.3.2
+ int width = 0;
+ int height = 0;
+
+ width = pic_width_in_luma_samples;
+ height = pic_height_in_luma_samples;
+
+ if (conformance_window_flag) {
+ int sub_width_c = ((1 == chroma_format_idc) || (2 == chroma_format_idc)) &&
+ (0 == separate_colour_plane_flag) ? 2 : 1;
+ int sub_height_c = (1 == chroma_format_idc) && (0 == separate_colour_plane_flag) ? 2 : 1;
+ //the offset includes the pixel within conformance window. so don't need to +1 as per spec
+ width -= sub_width_c*(conf_win_right_offset + conf_win_left_offset);
+ height -= sub_height_c*(conf_win_top_offset + conf_win_bottom_offset);
+ }
+
+ width_ = width;
+ height_ = height;
+ return true;
+
+}
+
+} // namespace webrtc
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/rtp_rtcp/source/h265_sps_parser.h b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/rtp_rtcp/source/h265_sps_parser.h
new file mode 100644
index 000000000000..c642b9bd5376
--- /dev/null
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/rtp_rtcp/source/h265_sps_parser.h
@@ -0,0 +1,34 @@
+/*
+ * Intel License
+ * See https://01.org/open-webrtc-toolkit
+ * This is released under Apache License 2.0 and it is free for both academic and commercial use.
+ */
+
+#ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_H265_SPS_PARSER_H_
+#define WEBRTC_MODULES_RTP_RTCP_SOURCE_H265_SPS_PARSER_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+namespace webrtc {
+
+// A class for parsing out sequence parameter set (SPS) data from an H265 NALU.
+// Currently, only resolution is read without being ignored.
+class H265SpsParser {
+ public:
+ H265SpsParser(const uint8_t* sps, size_t byte_length);
+ // Parses the SPS to completion. Returns true if the SPS was parsed correctly.
+ bool Parse();
+ uint16_t width() { return width_; }
+ uint16_t height() { return height_; }
+
+ private:
+ const uint8_t* const sps_;
+ const size_t byte_length_;
+
+ uint16_t width_;
+ uint16_t height_;
+};
+
+} // namespace webrtc
+#endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_H265_SPS_PARSER_H_
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/rtp_rtcp/source/rtp_format.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/rtp_rtcp/source/rtp_format.cc
index 7703a6bf0f62..62cdea012114 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/rtp_rtcp/source/rtp_format.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/rtp_rtcp/source/rtp_format.cc
@@ -14,6 +14,7 @@
#include "absl/types/variant.h"
#include "modules/rtp_rtcp/source/rtp_format_h264.h"
+#include "modules/rtp_rtcp/source/rtp_format_h265.h"
#include "modules/rtp_rtcp/source/rtp_format_video_generic.h"
#include "modules/rtp_rtcp/source/rtp_format_vp8.h"
#include "modules/rtp_rtcp/source/rtp_format_vp9.h"
@@ -56,6 +57,12 @@ std::unique_ptr<RtpPacketizer> RtpPacketizer::Create(
case kVideoCodecAV1:
return std::make_unique<RtpPacketizerAv1>(payload, limits,
rtp_video_header.frame_type);
+#ifndef DISABLE_H265
+ case kVideoCodecH265: {
+ return std::make_unique<RtpPacketizerGeneric>(payload, limits,
+ rtp_video_header);
+ }
+#endif
default: {
return std::make_unique<RtpPacketizerGeneric>(payload, limits,
rtp_video_header);
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/rtp_rtcp/source/rtp_format_h265.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/rtp_rtcp/source/rtp_format_h265.cc
new file mode 100644
index 000000000000..2d8717cf65aa
--- /dev/null
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/rtp_rtcp/source/rtp_format_h265.cc
@@ -0,0 +1,648 @@
+/*
+ * Intel License
+ * See https://01.org/open-webrtc-toolkit
+ * This is released under Apache License 2.0 and it is free for both academic and commercial use.
+ */
+
+#include <string.h>
+
+#include "common_video/h264/h264_common.h"
+#include "common_video/h265/h265_common.h"
+#include "common_video/h265/h265_pps_parser.h"
+#include "common_video/h265/h265_sps_parser.h"
+#include "common_video/h265/h265_vps_parser.h"
+#include "modules/include/module_common_types.h"
+#include "modules/rtp_rtcp/source/byte_io.h"
+#include "modules/rtp_rtcp/source/rtp_format_h265.h"
+#include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
+#include "modules/video_coding/codecs/h265/include/h265_globals.h"
+#include "rtc_base/logging.h"
+using namespace rtc;
+
+namespace webrtc {
+namespace {
+
+enum NaluType {
+ kTrailN = 0,
+ kTrailR = 1,
+ kTsaN = 2,
+ kTsaR = 3,
+ kStsaN = 4,
+ kStsaR = 5,
+ kRadlN = 6,
+ kRadlR = 7,
+ kBlaWLp = 16,
+ kBlaWRadl = 17,
+ kBlaNLp = 18,
+ kIdrWRadl = 19,
+ kIdrNLp = 20,
+ kCra = 21,
+ kVps = 32,
+ kHevcSps = 33,
+ kHevcPps = 34,
+ kHevcAud = 35,
+ kPrefixSei = 39,
+ kSuffixSei = 40,
+ kHevcAp = 48,
+ kHevcFu = 49
+};
+
+/*
+ 0 1 2 3
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | PayloadHdr (Type=49) | FU header | DONL (cond) |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-|
+*/
+// Unlike H.264, HEVC NAL header is 2-bytes.
+static const size_t kHevcNalHeaderSize = 2;
+// H.265's FU is constructed of 2-byte payload header, and 1-byte FU header
+static const size_t kHevcFuHeaderSize = 1;
+static const size_t kHevcLengthFieldSize = 2;
+static const size_t kHevcApHeaderSize =
+ kHevcNalHeaderSize + kHevcLengthFieldSize;
+
+enum HevcNalHdrMasks {
+ kHevcFBit = 0x80,
+ kHevcTypeMask = 0x7E,
+ kHevcLayerIDHMask = 0x1,
+ kHevcLayerIDLMask = 0xF8,
+ kHevcTIDMask = 0x7,
+ kHevcTypeMaskN = 0x81,
+ kHevcTypeMaskInFuHeader = 0x3F
+};
+
+// Bit masks for FU headers.
+enum HevcFuDefs { kHevcSBit = 0x80, kHevcEBit = 0x40, kHevcFuTypeBit = 0x3F };
+
+// TODO(pbos): Avoid parsing this here as well as inside the jitter buffer.
+bool ParseApStartOffsets(const uint8_t* nalu_ptr,
+ size_t length_remaining,
+ std::vector<size_t>* offsets) {
+ size_t offset = 0;
+ while (length_remaining > 0) {
+ // Buffer doesn't contain room for additional nalu length.
+ if (length_remaining < sizeof(uint16_t))
+ return false;
+ uint16_t nalu_size = ByteReader<uint16_t>::ReadBigEndian(nalu_ptr);
+ nalu_ptr += sizeof(uint16_t);
+ length_remaining -= sizeof(uint16_t);
+ if (nalu_size > length_remaining)
+ return false;
+ nalu_ptr += nalu_size;
+ length_remaining -= nalu_size;
+
+ offsets->push_back(offset + kHevcApHeaderSize);
+ offset += kHevcLengthFieldSize + nalu_size;
+ }
+ return true;
+}
+
+} // namespace
+
+RtpPacketizerH265::RtpPacketizerH265(
+ rtc::ArrayView<const uint8_t> payload,
+ PayloadSizeLimits limits,
+ H265PacketizationMode packetization_mode)
+ : limits_(limits),
+ num_packets_left_(0) {
+ // Guard against uninitialized memory in packetization_mode.
+ RTC_CHECK(packetization_mode == H265PacketizationMode::NonInterleaved ||
+ packetization_mode == H265PacketizationMode::SingleNalUnit);
+
+ for (const auto& nalu :
+ H265::FindNaluIndices(payload.data(), payload.size())) {
+ input_fragments_.push_back(Fragment(payload.data() + nalu.payload_start_offset, nalu.payload_size));
+ }
+
+ if (!GeneratePackets(packetization_mode)) {
+ // If failed to generate all the packets, discard already generated
+ // packets in case the caller would ignore return value and still try to
+ // call NextPacket().
+ num_packets_left_ = 0;
+ while (!packets_.empty()) {
+ packets_.pop();
+ }
+ }
+}
+
+RtpPacketizerH265::~RtpPacketizerH265() {}
+
+size_t RtpPacketizerH265::NumPackets() const {
+ return num_packets_left_;
+}
+
+RtpPacketizerH265::Fragment::Fragment(const uint8_t* buffer, size_t length)
+ : buffer(buffer), length(length) {}
+RtpPacketizerH265::Fragment::Fragment(const Fragment& fragment)
+ : buffer(fragment.buffer), length(fragment.length) {}
+
+
+bool RtpPacketizerH265::GeneratePackets(
+ H265PacketizationMode packetization_mode) {
+ // For HEVC we follow non-interleaved mode for the packetization,
+ // and don't support single-nalu mode at present.
+ for (size_t i = 0; i < input_fragments_.size();) {
+ int fragment_len = input_fragments_[i].length;
+ int single_packet_capacity = limits_.max_payload_len;
+ if (input_fragments_.size() == 1)
+ single_packet_capacity -= limits_.single_packet_reduction_len;
+ else if (i == 0)
+ single_packet_capacity -= limits_.first_packet_reduction_len;
+ else if (i + 1 == input_fragments_.size()) {
+ // Pretend that last fragment is larger instead of making last packet
+ // smaller.
+ single_packet_capacity -= limits_.last_packet_reduction_len;
+ }
+ if (fragment_len > single_packet_capacity) {
+ PacketizeFu(i);
+ ++i;
+ } else {
+ PacketizeSingleNalu(i);
+ ++i;
+ }
+ }
+ return true;
+}
+
+bool RtpPacketizerH265::PacketizeFu(size_t fragment_index) {
+ // Fragment payload into packets (FU).
+ // Strip out the original header and leave room for the FU header.
+ const Fragment& fragment = input_fragments_[fragment_index];
+ PayloadSizeLimits limits = limits_;
+ limits.max_payload_len -= kHevcFuHeaderSize + kHevcNalHeaderSize;
+
+ // Update single/first/last packet reductions unless it is single/first/last
+ // fragment.
+ if (input_fragments_.size() != 1) {
+ // if this fragment is put into a single packet, it might still be the
+ // first or the last packet in the whole sequence of packets.
+ if (fragment_index == input_fragments_.size() - 1) {
+ limits.single_packet_reduction_len = limits_.last_packet_reduction_len;
+ } else if (fragment_index == 0) {
+ limits.single_packet_reduction_len = limits_.first_packet_reduction_len;
+ } else {
+ limits.single_packet_reduction_len = 0;
+ }
+ }
+ if (fragment_index != 0)
+ limits.first_packet_reduction_len = 0;
+ if (fragment_index != input_fragments_.size() - 1)
+ limits.last_packet_reduction_len = 0;
+
+ // Strip out the original header.
+ size_t payload_left = fragment.length - kHevcNalHeaderSize;
+ int offset = kHevcNalHeaderSize;
+
+ std::vector<int> payload_sizes = SplitAboutEqually(payload_left, limits);
+ if (payload_sizes.empty())
+ return false;
+
+ for (size_t i = 0; i < payload_sizes.size(); ++i) {
+ int packet_length = payload_sizes[i];
+ RTC_CHECK_GT(packet_length, 0);
+ uint16_t header = (fragment.buffer[0] << 8) | fragment.buffer[1];
+ packets_.push(PacketUnit(Fragment(fragment.buffer + offset, packet_length),
+ /*first_fragment=*/i == 0,
+ /*last_fragment=*/i == payload_sizes.size() - 1,
+ false, header));
+ offset += packet_length;
+ payload_left -= packet_length;
+ }
+ num_packets_left_ += payload_sizes.size();
+ RTC_CHECK_EQ(0, payload_left);
+ return true;
+}
+
+
+bool RtpPacketizerH265::PacketizeSingleNalu(size_t fragment_index) {
+ // Add a single NALU to the queue, no aggregation.
+ size_t payload_size_left = limits_.max_payload_len;
+ if (input_fragments_.size() == 1)
+ payload_size_left -= limits_.single_packet_reduction_len;
+ else if (fragment_index == 0)
+ payload_size_left -= limits_.first_packet_reduction_len;
+ else if (fragment_index + 1 == input_fragments_.size())
+ payload_size_left -= limits_.last_packet_reduction_len;
+ const Fragment* fragment = &input_fragments_[fragment_index];
+ if (payload_size_left < fragment->length) {
+ RTC_LOG(LS_ERROR) << "Failed to fit a fragment to packet in SingleNalu "
+ "packetization mode. Payload size left "
+ << payload_size_left << ", fragment length "
+ << fragment->length << ", packet capacity "
+ << limits_.max_payload_len;
+ return false;
+ }
+ RTC_CHECK_GT(fragment->length, 0u);
+ packets_.push(PacketUnit(*fragment, true /* first */, true /* last */,
+ false /* aggregated */, fragment->buffer[0]));
+ ++num_packets_left_;
+ return true;
+}
+
+int RtpPacketizerH265::PacketizeAp(size_t fragment_index) {
+ // Aggregate fragments into one packet (STAP-A).
+ size_t payload_size_left = limits_.max_payload_len;
+ if (input_fragments_.size() == 1)
+ payload_size_left -= limits_.single_packet_reduction_len;
+ else if (fragment_index == 0)
+ payload_size_left -= limits_.first_packet_reduction_len;
+ int aggregated_fragments = 0;
+ size_t fragment_headers_length = 0;
+ const Fragment* fragment = &input_fragments_[fragment_index];
+ RTC_CHECK_GE(payload_size_left, fragment->length);
+ ++num_packets_left_;
+
+ auto payload_size_needed = [&] {
+ size_t fragment_size = fragment->length + fragment_headers_length;
+ if (input_fragments_.size() == 1) {
+ // Single fragment, single packet, payload_size_left already adjusted
+ // with limits_.single_packet_reduction_len.
+ return fragment_size;
+ }
+ if (fragment_index == input_fragments_.size() - 1) {
+ // Last fragment, so StrapA might be the last packet.
+ return fragment_size + limits_.last_packet_reduction_len;
+ }
+ return fragment_size;
+ };
+
+ while (payload_size_left >= payload_size_needed()) {
+ RTC_CHECK_GT(fragment->length, 0);
+ packets_.push(PacketUnit(*fragment, aggregated_fragments == 0, false, true,
+ fragment->buffer[0]));
+ payload_size_left -= fragment->length;
+ payload_size_left -= fragment_headers_length;
+
+ fragment_headers_length = kHevcLengthFieldSize;
+ // If we are going to try to aggregate more fragments into this packet
+ // we need to add the STAP-A NALU header and a length field for the first
+ // NALU of this packet.
+ if (aggregated_fragments == 0)
+ fragment_headers_length += kHevcNalHeaderSize + kHevcLengthFieldSize;
+ ++aggregated_fragments;
+
+ // Next fragment.
+ ++fragment_index;
+ if (fragment_index == input_fragments_.size())
+ break;
+ fragment = &input_fragments_[fragment_index];
+ }
+ RTC_CHECK_GT(aggregated_fragments, 0);
+ packets_.back().last_fragment = true;
+ return fragment_index;
+}
+
+bool RtpPacketizerH265::NextPacket(RtpPacketToSend* rtp_packet) {
+ RTC_DCHECK(rtp_packet);
+
+ if (packets_.empty()) {
+ return false;
+ }
+
+ PacketUnit packet = packets_.front();
+
+ if (packet.first_fragment && packet.last_fragment) {
+ // Single NAL unit packet.
+ size_t bytes_to_send = packet.source_fragment.length;
+ uint8_t* buffer = rtp_packet->AllocatePayload(bytes_to_send);
+ memcpy(buffer, packet.source_fragment.buffer, bytes_to_send);
+ packets_.pop();
+ input_fragments_.pop_front();
+ } else if (packet.aggregated) {
+ bool is_last_packet = num_packets_left_ == 1;
+ NextAggregatePacket(rtp_packet, is_last_packet);
+ } else {
+ NextFragmentPacket(rtp_packet);
+ }
+ rtp_packet->SetMarker(packets_.empty());
+ --num_packets_left_;
+ return true;
+}
+
+void RtpPacketizerH265::NextAggregatePacket(RtpPacketToSend* rtp_packet,
+ bool last) {
+ size_t payload_capacity = rtp_packet->FreeCapacity();
+ RTC_CHECK_GE(payload_capacity, kHevcNalHeaderSize);
+ uint8_t* buffer = rtp_packet->AllocatePayload(payload_capacity);
+
+ PacketUnit* packet = &packets_.front();
+ RTC_CHECK(packet->first_fragment);
+ uint8_t payload_hdr_h = packet->header >> 8;
+ uint8_t payload_hdr_l = packet->header & 0xFF;
+ uint8_t layer_id_h = payload_hdr_h & kHevcLayerIDHMask;
+
+ payload_hdr_h =
+ (payload_hdr_h & kHevcTypeMaskN) | (kHevcAp << 1) | layer_id_h;
+
+ buffer[0] = payload_hdr_h;
+ buffer[1] = payload_hdr_l;
+ int index = kHevcNalHeaderSize;
+ bool is_last_fragment = packet->last_fragment;
+ while (packet->aggregated) {
+ // Add NAL unit length field.
+ const Fragment& fragment = packet->source_fragment;
+ ByteWriter<uint16_t>::WriteBigEndian(&buffer[index], fragment.length);
+ index += kHevcLengthFieldSize;
+ // Add NAL unit.
+ memcpy(&buffer[index], fragment.buffer, fragment.length);
+ index += fragment.length;
+ packets_.pop();
+ input_fragments_.pop_front();
+ if (is_last_fragment)
+ break;
+ packet = &packets_.front();
+ is_last_fragment = packet->last_fragment;
+ }
+ RTC_CHECK(is_last_fragment);
+ rtp_packet->SetPayloadSize(index);
+}
+
+void RtpPacketizerH265::NextFragmentPacket(RtpPacketToSend* rtp_packet) {
+ PacketUnit* packet = &packets_.front();
+ // NAL unit fragmented over multiple packets (FU).
+ // We do not send original NALU header, so it will be replaced by the
+ // PayloadHdr of the first packet.
+ uint8_t payload_hdr_h =
+ packet->header >> 8; // 1-bit F, 6-bit type, 1-bit layerID highest-bit
+ uint8_t payload_hdr_l = packet->header & 0xFF;
+ uint8_t layer_id_h = payload_hdr_h & kHevcLayerIDHMask;
+ uint8_t fu_header = 0;
+ // S | E |6 bit type.
+ fu_header |= (packet->first_fragment ? kHevcSBit : 0);
+ fu_header |= (packet->last_fragment ? kHevcEBit : 0);
+ uint8_t type = (payload_hdr_h & kHevcTypeMask) >> 1;
+ fu_header |= type;
+ // Now update payload_hdr_h with FU type.
+ payload_hdr_h =
+ (payload_hdr_h & kHevcTypeMaskN) | (kHevcFu << 1) | layer_id_h;
+ const Fragment& fragment = packet->source_fragment;
+ uint8_t* buffer = rtp_packet->AllocatePayload(
+ kHevcFuHeaderSize + kHevcNalHeaderSize + fragment.length);
+ buffer[0] = payload_hdr_h;
+ buffer[1] = payload_hdr_l;
+ buffer[2] = fu_header;
+
+ if (packet->last_fragment) {
+ memcpy(buffer + kHevcFuHeaderSize + kHevcNalHeaderSize, fragment.buffer,
+ fragment.length);
+ } else {
+ memcpy(buffer + kHevcFuHeaderSize + kHevcNalHeaderSize, fragment.buffer,
+ fragment.length);
+ }
+ packets_.pop();
+}
+
+absl::optional<VideoRtpDepacketizer::ParsedRtpPayload> VideoRtpDepacketizerH265::Parse(
+ rtc::CopyOnWriteBuffer rtp_payload) {
+ size_t payload_data_length = rtp_payload.size();
+ if (payload_data_length == 0) {
+ RTC_LOG(LS_ERROR) << "Empty payload.";
+ return absl::nullopt;
+ }
+
+ ParsedRtpPayload parsed_payload;
+
+ uint8_t* payload_data = rtp_payload.data();
+
+ offset_ = 0;
+ length_ = payload_data_length;
+ modified_buffer_.reset();
+
+ uint8_t nal_type = (payload_data[0] & kHevcTypeMask) >> 1;
+ parsed_payload.video_header
+ .video_type_header.emplace<RTPVideoHeaderH265>();
+
+ if (nal_type == H265::NaluType::kFU) {
+ // Fragmented NAL units (FU-A).
+ if (!ParseFuNalu(&parsed_payload, payload_data))
+ return absl::nullopt;
+ } else {
+ // We handle STAP-A and single NALU's the same way here. The jitter buffer
+ // will depacketize the STAP-A into NAL units later.
+ // TODO(sprang): Parse STAP-A offsets here and store in fragmentation vec.
+ if (!ProcessApOrSingleNalu(&parsed_payload, payload_data))
+ return absl::nullopt;
+ }
+
+ const uint8_t* payload =
+ modified_buffer_ ? modified_buffer_->data() : payload_data;
+
+ parsed_payload.video_payload = { payload + offset_, length_ };
+ return parsed_payload;
+}
+
+bool VideoRtpDepacketizerH265::ProcessApOrSingleNalu(
+ ParsedRtpPayload* parsed_payload,
+ const uint8_t* payload_data) {
+ parsed_payload->video_header.width = 0;
+ parsed_payload->video_header.height = 0;
+ parsed_payload->video_header.codec = kVideoCodecH265;
+ parsed_payload->video_header.is_first_packet_in_frame = true;
+ auto& h265_header = absl::get<RTPVideoHeaderH265>(
+ parsed_payload->video_header.video_type_header);
+
+ const uint8_t* nalu_start = payload_data + kHevcNalHeaderSize;
+ const size_t nalu_length = length_ - kHevcNalHeaderSize;
+ uint8_t nal_type = (payload_data[0] & kHevcTypeMask) >> 1;
+ std::vector<size_t> nalu_start_offsets;
+ if (nal_type == H265::NaluType::kAP) {
+ // Skip the StapA header (StapA NAL type + length).
+ if (length_ <= kHevcApHeaderSize) {
+ RTC_LOG(LS_ERROR) << "AP header truncated.";
+ return false;
+ }
+
+ if (!ParseApStartOffsets(nalu_start, nalu_length, &nalu_start_offsets)) {
+ RTC_LOG(LS_ERROR) << "AP packet with incorrect NALU packet lengths.";
+ return false;
+ }
+
+ h265_header.packetization_type = kH265AP;
+ // nal_type = (payload_data[kHevcApHeaderSize] & kHevcTypeMask) >> 1;
+ } else {
+ h265_header.packetization_type = kH265SingleNalu;
+ nalu_start_offsets.push_back(0);
+ }
+ h265_header.nalu_type = nal_type;
+ parsed_payload->video_header.frame_type = VideoFrameType::kVideoFrameDelta;
+
+ nalu_start_offsets.push_back(length_ + kHevcLengthFieldSize); // End offset.
+ for (size_t i = 0; i < nalu_start_offsets.size() - 1; ++i) {
+ size_t start_offset = nalu_start_offsets[i];
+ // End offset is actually start offset for next unit, excluding length field
+ // so remove that from this units length.
+ size_t end_offset = nalu_start_offsets[i + 1] - kHevcLengthFieldSize;
+ if (end_offset - start_offset < kHevcNalHeaderSize) { // Same as H.264.
+ RTC_LOG(LS_ERROR) << "AP packet too short";
+ return false;
+ }
+
+ H265NaluInfo nalu;
+ nalu.type = (payload_data[start_offset] & kHevcTypeMask) >> 1;
+ nalu.vps_id = -1;
+ nalu.sps_id = -1;
+ nalu.pps_id = -1;
+ start_offset += kHevcNalHeaderSize;
+ switch (nalu.type) {
+ case H265::NaluType::kVps: {
+ absl::optional<H265VpsParser::VpsState> vps = H265VpsParser::ParseVps(
+ &payload_data[start_offset], end_offset - start_offset);
+ if (vps) {
+ nalu.vps_id = vps->id;
+ } else {
+ RTC_LOG(LS_WARNING) << "Failed to parse VPS id from VPS slice.";
+ }
+ break;
+ }
+ case H265::NaluType::kSps: {
+ // Check if VUI is present in SPS and if it needs to be modified to
+ // avoid excessive decoder latency.
+
+ // Copy any previous data first (likely just the first header).
+ std::unique_ptr<rtc::Buffer> output_buffer(new rtc::Buffer());
+ if (start_offset)
+ output_buffer->AppendData(payload_data, start_offset);
+
+ absl::optional<H265SpsParser::SpsState> sps = H265SpsParser::ParseSps(
+ &payload_data[start_offset], end_offset - start_offset);
+
+ if (sps) {
+ parsed_payload->video_header.width = sps->width;
+ parsed_payload->video_header.height = sps->height;
+ nalu.sps_id = sps->id;
+ nalu.vps_id = sps->vps_id;
+ } else {
+ RTC_LOG(LS_WARNING)
+ << "Failed to parse SPS and VPS id from SPS slice.";
+ }
+ parsed_payload->video_header.frame_type = VideoFrameType::kVideoFrameKey;
+ break;
+ }
+ case H265::NaluType::kPps: {
+ uint32_t pps_id;
+ uint32_t sps_id;
+ if (H265PpsParser::ParsePpsIds(&payload_data[start_offset],
+ end_offset - start_offset, &pps_id,
+ &sps_id)) {
+ nalu.pps_id = pps_id;
+ nalu.sps_id = sps_id;
+ } else {
+ RTC_LOG(LS_WARNING)
+ << "Failed to parse PPS id and SPS id from PPS slice.";
+ }
+ break;
+ }
+ case H265::NaluType::kIdrWRadl:
+ case H265::NaluType::kIdrNLp:
+ case H265::NaluType::kCra:
+ parsed_payload->video_header.frame_type = VideoFrameType::kVideoFrameKey;
+ case H265::NaluType::kTrailN:
+ case H265::NaluType::kTrailR: {
+ absl::optional<uint32_t> pps_id =
+ H265PpsParser::ParsePpsIdFromSliceSegmentLayerRbsp(
+ &payload_data[start_offset], end_offset - start_offset,
+ nalu.type);
+ if (pps_id) {
+ nalu.pps_id = *pps_id;
+ } else {
+ RTC_LOG(LS_WARNING) << "Failed to parse PPS id from slice of type: "
+ << static_cast<int>(nalu.type);
+ }
+ break;
+ }
+ // Slices below don't contain SPS or PPS ids.
+ case H265::NaluType::kAud:
+ case H265::NaluType::kTsaN:
+ case H265::NaluType::kTsaR:
+ case H265::NaluType::kStsaN:
+ case H265::NaluType::kStsaR:
+ case H265::NaluType::kRadlN:
+ case H265::NaluType::kRadlR:
+ case H265::NaluType::kBlaWLp:
+ case H265::NaluType::kBlaWRadl:
+ case H265::NaluType::kPrefixSei:
+ case H265::NaluType::kSuffixSei:
+ break;
+ case H265::NaluType::kAP:
+ case H265::NaluType::kFU:
+ RTC_LOG(LS_WARNING) << "Unexpected AP or FU received.";
+ return false;
+ }
+
+ if (h265_header.nalus_length == kMaxNalusPerPacket) {
+ RTC_LOG(LS_WARNING)
+ << "Received packet containing more than " << kMaxNalusPerPacket
+ << " NAL units. Will not keep track sps and pps ids for all of them.";
+ } else {
+ h265_header.nalus[h265_header.nalus_length++] = nalu;
+ }
+ }
+ return true;
+}
+
+bool VideoRtpDepacketizerH265::ParseFuNalu(
+ ParsedRtpPayload* parsed_payload,
+ const uint8_t* payload_data) {
+ if (length_ < kHevcFuHeaderSize + kHevcNalHeaderSize) {
+ RTC_LOG(LS_ERROR) << "FU NAL units truncated.";
+ return false;
+ }
+ uint8_t f = payload_data[0] & kHevcFBit;
+ uint8_t layer_id_h = payload_data[0] & kHevcLayerIDHMask;
+ uint8_t layer_id_l_unshifted = payload_data[1] & kHevcLayerIDLMask;
+ uint8_t tid = payload_data[1] & kHevcTIDMask;
+
+ uint8_t original_nal_type = payload_data[2] & kHevcTypeMaskInFuHeader;
+ bool first_fragment = payload_data[2] & kHevcSBit;
+ H265NaluInfo nalu;
+ nalu.type = original_nal_type;
+ nalu.vps_id = -1;
+ nalu.sps_id = -1;
+ nalu.pps_id = -1;
+ if (first_fragment) {
+ offset_ = 1;
+ length_ -= 1;
+ absl::optional<uint32_t> pps_id =
+ H265PpsParser::ParsePpsIdFromSliceSegmentLayerRbsp(
+ payload_data + kHevcNalHeaderSize + kHevcFuHeaderSize,
+ length_ - kHevcFuHeaderSize, nalu.type);
+ if (pps_id) {
+ nalu.pps_id = *pps_id;
+ } else {
+ RTC_LOG(LS_WARNING)
+ << "Failed to parse PPS from first fragment of FU NAL "
+ "unit with original type: "
+ << static_cast<int>(nalu.type);
+ }
+ uint8_t* payload = const_cast<uint8_t*>(payload_data + offset_);
+ payload[0] = f | original_nal_type << 1 | layer_id_h;
+ payload[1] = layer_id_l_unshifted | tid;
+ } else {
+ offset_ = kHevcNalHeaderSize + kHevcFuHeaderSize;
+ length_ -= (kHevcNalHeaderSize + kHevcFuHeaderSize);
+ }
+
+ if (original_nal_type == H265::NaluType::kIdrWRadl
+ || original_nal_type == H265::NaluType::kIdrNLp
+ || original_nal_type == H265::NaluType::kCra) {
+ parsed_payload->video_header.frame_type = VideoFrameType::kVideoFrameKey;
+ } else {
+ parsed_payload->video_header.frame_type = VideoFrameType::kVideoFrameDelta;
+ }
+ parsed_payload->video_header.width = 0;
+ parsed_payload->video_header.height = 0;
+ parsed_payload->video_header.codec = kVideoCodecH265;
+ parsed_payload->video_header.is_first_packet_in_frame = first_fragment;
+ auto& h265_header = absl::get<RTPVideoHeaderH265>(
+ parsed_payload->video_header.video_type_header);
+ h265_header.packetization_type = kH265FU;
+ h265_header.nalu_type = original_nal_type;
+ if (first_fragment) {
+ h265_header.nalus[h265_header.nalus_length] = nalu;
+ h265_header.nalus_length = 1;
+ }
+ return true;
+}
+
+} // namespace webrtc
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/rtp_rtcp/source/rtp_format_h265.h b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/rtp_rtcp/source/rtp_format_h265.h
new file mode 100644
index 000000000000..58ad1202a425
--- /dev/null
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/rtp_rtcp/source/rtp_format_h265.h
@@ -0,0 +1,129 @@
+/*
+ * Intel License
+ * See https://01.org/open-webrtc-toolkit
+ * This is released under Apache License 2.0 and it is free for both academic and commercial use.
+ */
+
+#ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_FORMAT_H265_H_
+#define WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_FORMAT_H265_H_
+
+#include <queue>
+#include <string>
+#include "api/array_view.h"
+#include "modules/include/module_common_types.h"
+#include "modules/rtp_rtcp/source/rtp_format.h"
+#include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
+#include "modules/rtp_rtcp/source/rtp_format.h"
+#include "modules/rtp_rtcp/source/video_rtp_depacketizer.h"
+#include "modules/video_coding/codecs/h265/include/h265_globals.h"
+#include "rtc_base/buffer.h"
+#include "rtc_base/constructor_magic.h"
+
+namespace webrtc {
+
+class RtpPacketizerH265 : public RtpPacketizer {
+ public:
+ // Initialize with payload from encoder.
+ // The payload_data must be exactly one encoded H.265 frame.
+ RtpPacketizerH265(rtc::ArrayView<const uint8_t> payload,
+ PayloadSizeLimits limits,
+ H265PacketizationMode packetization_mode);
+
+ ~RtpPacketizerH265() override;
+
+ size_t NumPackets() const override;
+
+ // Get the next payload with H.265 payload header.
+ // buffer is a pointer to where the output will be written.
+ // bytes_to_send is an output variable that will contain number of bytes
+ // written to buffer. The parameter last_packet is true for the last packet of
+ // the frame, false otherwise (i.e., call the function again to get the
+ // next packet).
+ // Returns true on success or false if there was no payload to packetize.
+ bool NextPacket(RtpPacketToSend* rtp_packet) override;
+
+ private:
+ struct Packet {
+ Packet(size_t offset,
+ size_t size,
+ bool first_fragment,
+ bool last_fragment,
+ bool aggregated,
+ uint16_t header)
+ : offset(offset),
+ size(size),
+ first_fragment(first_fragment),
+ last_fragment(last_fragment),
+ aggregated(aggregated),
+ header(header) {}
+
+ size_t offset;
+ size_t size;
+ bool first_fragment;
+ bool last_fragment;
+ bool aggregated;
+ uint16_t header; // Different from H264
+ };
+ struct Fragment {
+ Fragment(const uint8_t* buffer, size_t length);
+ explicit Fragment(const Fragment& fragment);
+ const uint8_t* buffer = nullptr;
+ size_t length = 0;
+ std::unique_ptr<rtc::Buffer> tmp_buffer;
+ };
+ struct PacketUnit {
+ PacketUnit(const Fragment& source_fragment,
+ bool first_fragment,
+ bool last_fragment,
+ bool aggregated,
+ uint16_t header)
+ : source_fragment(source_fragment),
+ first_fragment(first_fragment),
+ last_fragment(last_fragment),
+ aggregated(aggregated),
+ header(header) {}
+
+ const Fragment source_fragment;
+ bool first_fragment;
+ bool last_fragment;
+ bool aggregated;
+ uint16_t header;
+ };
+ typedef std::queue<Packet> PacketQueue;
+ std::deque<Fragment> input_fragments_;
+ std::queue<PacketUnit> packets_;
+
+ bool GeneratePackets(H265PacketizationMode packetization_mode);
+ bool PacketizeFu(size_t fragment_index);
+ int PacketizeAp(size_t fragment_index);
+ bool PacketizeSingleNalu(size_t fragment_index);
+
+ void NextAggregatePacket(RtpPacketToSend* rtp_packet, bool last);
+ void NextFragmentPacket(RtpPacketToSend* rtp_packet);
+
+ const PayloadSizeLimits limits_;
+ size_t num_packets_left_;
+
+ RTC_DISALLOW_COPY_AND_ASSIGN(RtpPacketizerH265);
+};
+
+// Depacketizer for H.265.
+class VideoRtpDepacketizerH265 : public VideoRtpDepacketizer {
+ public:
+ virtual ~VideoRtpDepacketizerH265() {}
+
+ absl::optional<ParsedRtpPayload> Parse(
+ rtc::CopyOnWriteBuffer rtp_payload) override;
+
+ private:
+ bool ParseFuNalu(ParsedRtpPayload* parsed_payload,
+ const uint8_t* payload_data);
+ bool ProcessApOrSingleNalu(ParsedRtpPayload* parsed_payload,
+ const uint8_t* payload_data);
+
+ size_t offset_;
+ size_t length_;
+ std::unique_ptr<rtc::Buffer> modified_buffer_;
+};
+} // namespace webrtc
+#endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_FORMAT_H265_H_
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc
index 8ce1eed9139e..c4453cdb8166 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc
@@ -749,6 +749,9 @@ uint8_t RTPSenderVideo::GetTemporalId(const RTPVideoHeader& header) {
return vp9.temporal_idx;
}
uint8_t operator()(const RTPVideoHeaderH264&) { return kNoTemporalIdx; }
+#ifndef DISABLE_H265
+ uint8_t operator()(const RTPVideoHeaderH265&) { return kNoTemporalIdx; }
+#endif
uint8_t operator()(const RTPVideoHeaderLegacyGeneric&) {
return kNoTemporalIdx;
}
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/rtp_rtcp/source/rtp_video_header.h b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/rtp_rtcp/source/rtp_video_header.h
index ca3415587d75..aff98633d974 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/rtp_rtcp/source/rtp_video_header.h
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/rtp_rtcp/source/rtp_video_header.h
@@ -24,6 +24,7 @@
#include "api/video/video_rotation.h"
#include "api/video/video_timing.h"
#include "modules/video_coding/codecs/h264/include/h264_globals.h"
+#include "modules/video_coding/codecs/h265/include/h265_globals.h"
#include "modules/video_coding/codecs/vp8/include/vp8_globals.h"
#include "modules/video_coding/codecs/vp9/include/vp9_globals.h"
@@ -39,6 +40,9 @@ using RTPVideoTypeHeader = absl::variant<absl::monostate,
RTPVideoHeaderVP8,
RTPVideoHeaderVP9,
RTPVideoHeaderH264,
+#ifndef DISABLE_H265
+ RTPVideoHeaderH265,
+#endif
RTPVideoHeaderLegacyGeneric>;
struct RTPVideoHeader {
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/video_coding/codecs/h265/include/h265_globals.h b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/video_coding/codecs/h265/include/h265_globals.h
new file mode 100644
index 000000000000..bc0eef236cfe
--- /dev/null
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/video_coding/codecs/h265/include/h265_globals.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+// This file contains codec dependent definitions that are needed in
+// order to compile the WebRTC codebase, even if this codec is not used.
+
+#ifndef MODULES_VIDEO_CODING_CODECS_H265_INCLUDE_H265_GLOBALS_H_
+#define MODULES_VIDEO_CODING_CODECS_H265_INCLUDE_H265_GLOBALS_H_
+
+#ifndef DISABLE_H265
+
+#include "modules/video_coding/codecs/h264/include/h264_globals.h"
+
+namespace webrtc {
+
+// The packetization types that we support: single, aggregated, and fragmented.
+enum H265PacketizationTypes {
+ kH265SingleNalu, // This packet contains a single NAL unit.
+ kH265AP, // This packet contains aggregation Packet.
+ // If this packet has an associated NAL unit type,
+ // it'll be for the first such aggregated packet.
+ kH265FU, // This packet contains a FU (fragmentation
+ // unit) packet, meaning it is a part of a frame
+ // that was too large to fit into a single packet.
+};
+
+struct H265NaluInfo {
+ uint8_t type;
+ int vps_id;
+ int sps_id;
+ int pps_id;
+};
+
+enum class H265PacketizationMode {
+ NonInterleaved = 0, // Mode 1 - STAP-A, FU-A is allowed
+ SingleNalUnit // Mode 0 - only single NALU allowed
+};
+
+struct RTPVideoHeaderH265 {
+ // The NAL unit type. If this is a header for a fragmented packet, it's the
+ // NAL unit type of the original data. If this is the header for an aggregated
+ // packet, it's the NAL unit type of the first NAL unit in the packet.
+ uint8_t nalu_type;
+ H265PacketizationTypes packetization_type;
+ H265NaluInfo nalus[kMaxNalusPerPacket];
+ size_t nalus_length;
+ // The packetization type of this buffer - single, aggregated or fragmented.
+ H265PacketizationMode packetization_mode;
+};
+
+} // namespace webrtc
+
+#endif
+
+#endif // MODULES_VIDEO_CODING_CODECS_H265_INCLUDE_H265_GLOBALS_H_
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/video_coding/codecs/vp9/vp9_impl.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/video_coding/codecs/vp9/vp9_impl.cc
index 1e37c293873d..abd1b96f4705 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/video_coding/codecs/vp9/vp9_impl.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/video_coding/codecs/vp9/vp9_impl.cc
@@ -984,6 +984,8 @@ int VP9EncoderImpl::Encode(const VideoFrame& input_image,
rtc::scoped_refptr<const I010BufferInterface> i010_copy;
switch (profile_) {
case VP9Profile::kProfile0: {
+ // FIXME: Update libvpx to enable that code path.
+#if !defined(WEBRTC_WEBKIT_BUILD)
if (input_image.video_frame_buffer()->type() ==
VideoFrameBuffer::Type::kNV12) {
const NV12BufferInterface* nv12_buffer =
@@ -997,6 +999,7 @@ int VP9EncoderImpl::Encode(const VideoFrame& input_image,
raw_->stride[VPX_PLANE_U] = nv12_buffer->StrideUV();
raw_->stride[VPX_PLANE_V] = nv12_buffer->StrideUV();
} else {
+#endif
rtc::scoped_refptr<I420BufferInterface> i420_buffer =
input_image.video_frame_buffer()->ToI420();
video_frame_buffer = i420_buffer;
@@ -1009,7 +1012,7 @@ int VP9EncoderImpl::Encode(const VideoFrame& input_image,
raw_->stride[VPX_PLANE_Y] = i420_buffer->StrideY();
raw_->stride[VPX_PLANE_U] = i420_buffer->StrideU();
raw_->stride[VPX_PLANE_V] = i420_buffer->StrideV();
- }
+// }
break;
}
case VP9Profile::kProfile1: {
@@ -1682,8 +1685,11 @@ void VP9EncoderImpl::MaybeRewrapRawWithFormat(const vpx_img_fmt fmt) {
if (!raw_) {
raw_ = vpx_img_wrap(nullptr, fmt, codec_.width, codec_.height, 1, nullptr);
} else if (raw_->fmt != fmt) {
+ // FIXME: Update libvpx to enable that code path.
+#if !defined(WEBRTC_WEBKIT_BUILD)
RTC_LOG(INFO) << "Switching VP9 encoder pixel format to "
<< (fmt == VPX_IMG_FMT_NV12 ? "NV12" : "I420");
+#endif
vpx_img_free(raw_);
raw_ = vpx_img_wrap(nullptr, fmt, codec_.width, codec_.height, 1, nullptr);
}
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/video_coding/h265_vps_sps_pps_tracker.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/video_coding/h265_vps_sps_pps_tracker.cc
new file mode 100644
index 000000000000..30cb14fddb8d
--- /dev/null
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/video_coding/h265_vps_sps_pps_tracker.cc
@@ -0,0 +1,312 @@
+/*
+ * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "modules/video_coding/h265_vps_sps_pps_tracker.h"
+
+#include <string>
+#include <utility>
+
+#include "common_video/h264/h264_common.h"
+#include "common_video/h265/h265_common.h"
+#include "common_video/h265/h265_pps_parser.h"
+#include "common_video/h265/h265_sps_parser.h"
+#include "common_video/h265/h265_vps_parser.h"
+#include "modules/video_coding/codecs/h264/include/h264_globals.h"
+#include "modules/video_coding/codecs/h265/include/h265_globals.h"
+#include "modules/video_coding/frame_object.h"
+#include "modules/video_coding/packet_buffer.h"
+#include "rtc_base/checks.h"
+#include "rtc_base/logging.h"
+
+namespace webrtc {
+namespace video_coding {
+
+namespace {
+const uint8_t start_code_h265[] = {0, 0, 0, 1};
+} // namespace
+
+H265VpsSpsPpsTracker::FixedBitstream H265VpsSpsPpsTracker::CopyAndFixBitstream(rtc::ArrayView<const uint8_t> bitstream,
+ RTPVideoHeader* video_header_pointer) {
+ const uint8_t* data = bitstream.data();
+ const size_t data_size = bitstream.size();
+ RTPVideoHeader& video_header = *video_header_pointer;
+ RTC_DCHECK(video_header.codec == kVideoCodecH265);
+
+ auto& h265_header =
+ absl::get<RTPVideoHeaderH265>(video_header.video_type_header);
+
+ bool append_vps_sps_pps = false;
+ auto vps = vps_data_.end();
+ auto sps = sps_data_.end();
+ auto pps = pps_data_.end();
+
+ for (size_t i = 0; i < h265_header.nalus_length; ++i) {
+ const H265NaluInfo& nalu = h265_header.nalus[i];
+ switch (nalu.type) {
+ case H265::NaluType::kVps: {
+ vps_data_[nalu.vps_id].size = 0;
+ break;
+ }
+ case H265::NaluType::kSps: {
+ sps_data_[nalu.sps_id].vps_id = nalu.vps_id;
+ sps_data_[nalu.sps_id].width = video_header.width;
+ sps_data_[nalu.sps_id].height = video_header.height;
+ break;
+ }
+ case H265::NaluType::kPps: {
+ pps_data_[nalu.pps_id].sps_id = nalu.sps_id;
+ break;
+ }
+ case H265::NaluType::kIdrWRadl:
+ case H265::NaluType::kIdrNLp:
+ case H265::NaluType::kCra: {
+ // If this is the first packet of an IDR, make sure we have the required
+ // SPS/PPS and also calculate how much extra space we need in the buffer
+ // to prepend the SPS/PPS to the bitstream with start codes.
+ if (video_header.is_first_packet_in_frame) {
+ if (nalu.pps_id == -1) {
+ RTC_LOG(LS_WARNING) << "No PPS id in IDR nalu.";
+ return {kRequestKeyframe};
+ }
+
+ pps = pps_data_.find(nalu.pps_id);
+ if (pps == pps_data_.end()) {
+ RTC_LOG(LS_WARNING)
+ << "No PPS with id " << nalu.pps_id << " received";
+ return {kRequestKeyframe};
+ }
+
+ sps = sps_data_.find(pps->second.sps_id);
+ if (sps == sps_data_.end()) {
+ RTC_LOG(LS_WARNING)
+ << "No SPS with id << " << pps->second.sps_id << " received";
+ return {kRequestKeyframe};
+ }
+
+ vps = vps_data_.find(sps->second.vps_id);
+ if (vps == vps_data_.end()) {
+ RTC_LOG(LS_WARNING)
+ << "No VPS with id " << sps->second.vps_id << " received";
+ return {kRequestKeyframe};
+ }
+
+ // Since the first packet of every keyframe should have its width and
+ // height set we set it here in the case of it being supplied out of
+ // band.
+ video_header.width = sps->second.width;
+ video_header.height = sps->second.height;
+
+ // If the VPS/SPS/PPS was supplied out of band then we will have saved
+ // the actual bitstream in |data|.
+ // This branch is not verified.
+ if (vps->second.data && sps->second.data && pps->second.data) {
+ RTC_DCHECK_GT(vps->second.size, 0);
+ RTC_DCHECK_GT(sps->second.size, 0);
+ RTC_DCHECK_GT(pps->second.size, 0);
+ append_vps_sps_pps = true;
+ }
+ }
+ break;
+ }
+ default:
+ break;
+ }
+ }
+
+ RTC_CHECK(!append_vps_sps_pps ||
+ (sps != sps_data_.end() && pps != pps_data_.end()));
+
+ // Calculate how much space we need for the rest of the bitstream.
+ size_t required_size = 0;
+
+ if (append_vps_sps_pps) {
+ required_size += vps->second.size + sizeof(start_code_h265);
+ required_size += sps->second.size + sizeof(start_code_h265);
+ required_size += pps->second.size + sizeof(start_code_h265);
+ }
+
+ if (h265_header.packetization_type == kH265AP) {
+ const uint8_t* nalu_ptr = data + 1;
+ while (nalu_ptr < data + data_size) {
+ RTC_DCHECK(video_header.is_first_packet_in_frame);
+ required_size += sizeof(start_code_h265);
+
+ // The first two bytes describe the length of a segment.
+ uint16_t segment_length = nalu_ptr[0] << 8 | nalu_ptr[1];
+ nalu_ptr += 2;
+
+ required_size += segment_length;
+ nalu_ptr += segment_length;
+ }
+ } else {
+ if (video_header.is_first_packet_in_frame)
+ required_size += sizeof(start_code_h265);
+ required_size += data_size;
+ }
+
+ // Then we copy to the new buffer.
+ FixedBitstream fixed;
+ fixed.bitstream.EnsureCapacity(required_size);
+
+ if (append_vps_sps_pps) {
+ // Insert VPS.
+ fixed.bitstream.AppendData(start_code_h265);
+ fixed.bitstream.AppendData(vps->second.data.get(), vps->second.size);
+
+ // Insert SPS.
+ fixed.bitstream.AppendData(start_code_h265);
+ fixed.bitstream.AppendData(sps->second.data.get(), sps->second.size);
+
+ // Insert PPS.
+ fixed.bitstream.AppendData(start_code_h265);
+ fixed.bitstream.AppendData(pps->second.data.get(), pps->second.size);
+
+ // Update codec header to reflect the newly added SPS and PPS.
+ H265NaluInfo vps_info;
+ vps_info.type = H265::NaluType::kVps;
+ vps_info.vps_id = vps->first;
+ vps_info.sps_id = -1;
+ vps_info.pps_id = -1;
+ H265NaluInfo sps_info;
+ sps_info.type = H265::NaluType::kSps;
+ sps_info.vps_id = vps->first;
+ sps_info.sps_id = sps->first;
+ sps_info.pps_id = -1;
+ H265NaluInfo pps_info;
+ pps_info.type = H265::NaluType::kPps;
+ pps_info.vps_id = vps->first;
+ pps_info.sps_id = sps->first;
+ pps_info.pps_id = pps->first;
+ if (h265_header.nalus_length + 2 <= kMaxNalusPerPacket) {
+ h265_header.nalus[h265_header.nalus_length++] = vps_info;
+ h265_header.nalus[h265_header.nalus_length++] = sps_info;
+ h265_header.nalus[h265_header.nalus_length++] = pps_info;
+ } else {
+ RTC_LOG(LS_WARNING) << "Not enough space in H.265 codec header to insert "
+ "SPS/PPS provided out-of-band.";
+ }
+ }
+
+ // Copy the rest of the bitstream and insert start codes.
+ if (h265_header.packetization_type == kH265AP) {
+ const uint8_t* nalu_ptr = data + 1;
+ while (nalu_ptr < data + data_size) {
+ fixed.bitstream.AppendData(start_code_h265);
+
+ // The first two bytes describe the length of a segment.
+ uint16_t segment_length = nalu_ptr[0] << 8 | nalu_ptr[1];
+ nalu_ptr += 2;
+
+ size_t copy_end = nalu_ptr - data + segment_length;
+ if (copy_end > data_size) {
+ return {kDrop};
+ }
+
+ fixed.bitstream.AppendData(nalu_ptr, segment_length);
+ nalu_ptr += segment_length;
+ }
+ } else {
+ if (video_header.is_first_packet_in_frame) {
+ fixed.bitstream.AppendData(start_code_h265);
+ }
+ fixed.bitstream.AppendData(bitstream.data(), bitstream.size());
+ }
+
+ fixed.action = kInsert;
+ return fixed;
+}
+
+void H265VpsSpsPpsTracker::InsertVpsSpsPpsNalus(
+ const std::vector<uint8_t>& vps,
+ const std::vector<uint8_t>& sps,
+ const std::vector<uint8_t>& pps) {
+ constexpr size_t kNaluHeaderOffset = 1;
+ if (vps.size() < kNaluHeaderOffset) {
+ RTC_LOG(LS_WARNING) << "VPS size " << vps.size() << " is smaller than "
+ << kNaluHeaderOffset;
+ return;
+ }
+ if ((vps[0] & 0x7e) >> 1 != H265::NaluType::kSps) {
+ RTC_LOG(LS_WARNING) << "SPS Nalu header missing";
+ return;
+ }
+ if (sps.size() < kNaluHeaderOffset) {
+ RTC_LOG(LS_WARNING) << "SPS size " << sps.size() << " is smaller than "
+ << kNaluHeaderOffset;
+ return;
+ }
+ if ((sps[0] & 0x7e) >> 1 != H265::NaluType::kSps) {
+ RTC_LOG(LS_WARNING) << "SPS Nalu header missing";
+ return;
+ }
+ if (pps.size() < kNaluHeaderOffset) {
+ RTC_LOG(LS_WARNING) << "PPS size " << pps.size() << " is smaller than "
+ << kNaluHeaderOffset;
+ return;
+ }
+ if ((pps[0] & 0x7e) >> 1 != H265::NaluType::kPps) {
+ RTC_LOG(LS_WARNING) << "SPS Nalu header missing";
+ return;
+ }
+ absl::optional<H265VpsParser::VpsState> parsed_vps = H265VpsParser::ParseVps(
+ vps.data() + kNaluHeaderOffset, vps.size() - kNaluHeaderOffset);
+ absl::optional<H265SpsParser::SpsState> parsed_sps = H265SpsParser::ParseSps(
+ sps.data() + kNaluHeaderOffset, sps.size() - kNaluHeaderOffset);
+ absl::optional<H265PpsParser::PpsState> parsed_pps = H265PpsParser::ParsePps(
+ pps.data() + kNaluHeaderOffset, pps.size() - kNaluHeaderOffset);
+
+ if (!parsed_vps) {
+ RTC_LOG(LS_WARNING) << "Failed to parse VPS.";
+ }
+
+ if (!parsed_sps) {
+ RTC_LOG(LS_WARNING) << "Failed to parse SPS.";
+ }
+
+ if (!parsed_pps) {
+ RTC_LOG(LS_WARNING) << "Failed to parse PPS.";
+ }
+
+ if (!parsed_vps || !parsed_pps || !parsed_sps) {
+ return;
+ }
+
+ VpsInfo vps_info;
+ vps_info.size = vps.size();
+ uint8_t* vps_data = new uint8_t[vps_info.size];
+ memcpy(vps_data, vps.data(), vps_info.size);
+ vps_info.data.reset(vps_data);
+ vps_data_[parsed_vps->id] = std::move(vps_info);
+
+ SpsInfo sps_info;
+ sps_info.size = sps.size();
+ sps_info.width = parsed_sps->width;
+ sps_info.height = parsed_sps->height;
+ sps_info.vps_id = parsed_sps->vps_id;
+ uint8_t* sps_data = new uint8_t[sps_info.size];
+ memcpy(sps_data, sps.data(), sps_info.size);
+ sps_info.data.reset(sps_data);
+ sps_data_[parsed_sps->id] = std::move(sps_info);
+
+ PpsInfo pps_info;
+ pps_info.size = pps.size();
+ pps_info.sps_id = parsed_pps->sps_id;
+ uint8_t* pps_data = new uint8_t[pps_info.size];
+ memcpy(pps_data, pps.data(), pps_info.size);
+ pps_info.data.reset(pps_data);
+ pps_data_[parsed_pps->id] = std::move(pps_info);
+
+ RTC_LOG(LS_INFO) << "Inserted SPS id " << parsed_sps->id << " and PPS id "
+ << parsed_pps->id << " (referencing SPS "
+ << parsed_pps->sps_id << ")";
+}
+
+} // namespace video_coding
+} // namespace webrtc
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/video_coding/h265_vps_sps_pps_tracker.h b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/video_coding/h265_vps_sps_pps_tracker.h
new file mode 100644
index 000000000000..7ac5e2a001cb
--- /dev/null
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/video_coding/h265_vps_sps_pps_tracker.h
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef MODULES_VIDEO_CODING_H265_VPS_SPS_PPS_TRACKER_H_
+#define MODULES_VIDEO_CODING_H265_VPS_SPS_PPS_TRACKER_H_
+
+#include <cstdint>
+#include <map>
+#include <memory>
+#include <vector>
+
+#include "api/array_view.h"
+#include "modules/include/module_common_types.h"
+#include "modules/rtp_rtcp/source/rtp_video_header.h"
+#include "rtc_base/copy_on_write_buffer.h"
+
+namespace webrtc {
+
+class VCMPacket;
+
+namespace video_coding {
+
+class H265VpsSpsPpsTracker {
+ public:
+ enum PacketAction { kInsert, kDrop, kRequestKeyframe };
+ struct FixedBitstream {
+ PacketAction action;
+ rtc::CopyOnWriteBuffer bitstream;
+ };
+
+ // Returns fixed bitstream and modifies |video_header|.
+ FixedBitstream CopyAndFixBitstream(rtc::ArrayView<const uint8_t> bitstream,
+ RTPVideoHeader* video_header);
+
+ void InsertVpsSpsPpsNalus(const std::vector<uint8_t>& vps,
+ const std::vector<uint8_t>& sps,
+ const std::vector<uint8_t>& pps);
+
+ private:
+ struct VpsInfo {
+ size_t size = 0;
+ std::unique_ptr<uint8_t[]> data;
+ };
+
+ struct PpsInfo {
+ int sps_id = -1;
+ size_t size = 0;
+ std::unique_ptr<uint8_t[]> data;
+ };
+
+ struct SpsInfo {
+ int vps_id = -1;
+ size_t size = 0;
+ int width = -1;
+ int height = -1;
+ std::unique_ptr<uint8_t[]> data;
+ };
+
+ std::map<uint32_t, VpsInfo> vps_data_;
+ std::map<uint32_t, PpsInfo> pps_data_;
+ std::map<uint32_t, SpsInfo> sps_data_;
+};
+
+} // namespace video_coding
+} // namespace webrtc
+
+#endif // MODULES_VIDEO_CODING_H264_SPS_PPS_TRACKER_H_
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/video_coding/include/video_codec_interface.h b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/video_coding/include/video_codec_interface.h
index c7b116f4ae3f..6a0f49cd2cf9 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/modules/video_coding/include/video_codec_interface.h
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/modules/video_coding/include/video_codec_interface.h
@@ -20,6 +20,7 @@
#include "common_video/generic_frame_descriptor/generic_frame_info.h"
#include "modules/include/module_common_types.h"
#include "modules/video_coding/codecs/h264/include/h264_globals.h"
+#include "modules/video_coding/codecs/h265/include/h265_globals.h"
#include "modules/video_coding/codecs/vp9/include/vp9_globals.h"
#include "modules/video_coding/include/video_error_codes.h"
#include "rtc_base/system/rtc_export.h"
@@ -92,10 +93,20 @@ struct CodecSpecificInfoH264 {
};
static_assert(std::is_pod<CodecSpecificInfoH264>::value, "");
+#ifndef DISABLE_H265
+struct CodecSpecificInfoH265 {
+ H265PacketizationMode packetization_mode;
+ bool idr_frame;
+};
+#endif
+
union CodecSpecificInfoUnion {
CodecSpecificInfoVP8 VP8;
CodecSpecificInfoVP9 VP9;
CodecSpecificInfoH264 H264;
+#ifndef DISABLE_H265
+ CodecSpecificInfoH265 H265;
+#endif
};
static_assert(std::is_pod<CodecSpecificInfoUnion>::value, "");
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/p2p/base/tcp_port.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/p2p/base/tcp_port.cc
index efbf62e49602..1458f8c11008 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/p2p/base/tcp_port.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/p2p/base/tcp_port.cc
@@ -364,7 +364,11 @@ TCPConnection::TCPConnection(TCPPort* port,
RTC_LOG(LS_VERBOSE) << ToString() << ": socket ipaddr: "
<< socket_->GetLocalAddress().ToSensitiveString()
<< ", port() Network:" << port->Network()->ToString();
+#if defined(WEBRTC_WEBKIT_BUILD)
+ RTC_DCHECK(socket->GetLocalAddress().IsLoopbackIP() || absl::c_any_of(
+#else
RTC_DCHECK(absl::c_any_of(
+#endif
port_->Network()->GetIPs(), [this](const rtc::InterfaceAddress& addr) {
return socket_->GetLocalAddress().ipaddr() == addr;
}));
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/pc/peer_connection_factory.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/pc/peer_connection_factory.cc
index 3565c52390a4..37acd5c73fef 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/pc/peer_connection_factory.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/pc/peer_connection_factory.cc
@@ -192,7 +192,7 @@ RtpCapabilities PeerConnectionFactory::GetRtpSenderCapabilities(
return RtpCapabilities();
}
// Not reached; avoids compile warning.
- FATAL();
+ RTC_FATAL();
}
RtpCapabilities PeerConnectionFactory::GetRtpReceiverCapabilities(
@@ -217,7 +217,7 @@ RtpCapabilities PeerConnectionFactory::GetRtpReceiverCapabilities(
return RtpCapabilities();
}
// Not reached; avoids compile warning.
- FATAL();
+ RTC_FATAL();
}
rtc::scoped_refptr<AudioSourceInterface>
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/pc/rtp_parameters_conversion.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/pc/rtp_parameters_conversion.cc
index 9c7a337ab416..c4b45607b7db 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/pc/rtp_parameters_conversion.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/pc/rtp_parameters_conversion.cc
@@ -77,7 +77,7 @@ RTCErrorOr<cricket::FeedbackParam> ToCricketFeedbackParam(
return cricket::FeedbackParam(cricket::kRtcpFbParamTransportCc);
}
// Not reached; avoids compile warning.
- FATAL();
+ RTC_FATAL();
}
template <typename C>
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/checks.h b/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/checks.h
index 61c074ac8228..90cef74f07f3 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/checks.h
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/checks.h
@@ -95,7 +95,7 @@ RTC_NORETURN void rtc_FatalMessage(const char* file, int line, const char* msg);
// messages if the condition doesn't hold. Prefer them to raw RTC_CHECK and
// RTC_DCHECK.
//
-// - FATAL() aborts unconditionally.
+// - RTC_FATAL() aborts unconditionally.
namespace rtc {
namespace webrtc_checks_impl {
@@ -431,9 +431,9 @@ class FatalLogCall final {
#define RTC_NOTREACHED() RTC_DCHECK(RTC_UNREACHABLE_CODE_HIT)
// TODO(bugs.webrtc.org/8454): Add an RTC_ prefix or rename differently.
-#define FATAL() \
+#define RTC_FATAL() \
::rtc::webrtc_checks_impl::FatalLogCall<false>(__FILE__, __LINE__, \
- "FATAL()") & \
+ "RTC_FATAL()") & \
::rtc::webrtc_checks_impl::LogStreamer<>()
// Performs the integer division a/b and returns the result. CHECKs that the
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/experiments/min_video_bitrate_experiment.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/experiments/min_video_bitrate_experiment.cc
index 11450d084921..be654e8c123d 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/experiments/min_video_bitrate_experiment.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/experiments/min_video_bitrate_experiment.cc
@@ -99,6 +99,9 @@ absl::optional<DataRate> GetExperimentalMinVideoBitrate(VideoCodecType type) {
case kVideoCodecAV1:
return min_bitrate_av1.GetOptional();
case kVideoCodecH264:
+#ifndef DISABLE_H265
+ case kVideoCodecH265:
+#endif
return min_bitrate_h264.GetOptional();
case kVideoCodecGeneric:
case kVideoCodecMultiplex:
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/logging.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/logging.cc
index 13a5f025975a..bc700086fb17 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/logging.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/logging.cc
@@ -44,6 +44,7 @@ static const int kMaxLogLineSize = 1024 - 60;
#include "absl/base/attributes.h"
#include "rtc_base/checks.h"
#include "rtc_base/platform_thread_types.h"
+#include "rtc_base/never_destroyed.h"
#include "rtc_base/string_encode.h"
#include "rtc_base/string_utils.h"
#include "rtc_base/strings/string_builder.h"
@@ -75,7 +76,13 @@ const char* FilenameFromPath(const char* file) {
// Global lock for log subsystem, only needed to serialize access to streams_.
// TODO(bugs.webrtc.org/11665): this is not currently constant initialized and
// trivially destructible.
-webrtc::Mutex g_log_mutex_;
+webrtc::Mutex& logMutex() {
+ static auto mutex = NeverDestroyed<webrtc::Mutex>();
+ return mutex.get();
+}
+
+static LogMessage::LogOutputCallback g_log_output_callback = nullptr;
+
} // namespace
/////////////////////////////////////////////////////////////////////////////
@@ -88,7 +95,7 @@ bool LogMessage::log_to_stderr_ = true;
// Note: we explicitly do not clean this up, because of the uncertain ordering
// of destructors at program exit. Let the person who sets the stream trigger
// cleanup by setting to null, or let it leak (safe at program exit).
-ABSL_CONST_INIT LogSink* LogMessage::streams_ RTC_GUARDED_BY(g_log_mutex_) =
+ABSL_CONST_INIT LogSink* LogMessage::streams_ RTC_GUARDED_BY(logMutex()) =
nullptr;
ABSL_CONST_INIT std::atomic<bool> LogMessage::streams_empty_ = {true};
@@ -201,7 +208,7 @@ LogMessage::~LogMessage() {
#endif
}
- webrtc::MutexLock lock(&g_log_mutex_);
+ webrtc::MutexLock lock(&logMutex());
for (LogSink* entry = streams_; entry != nullptr; entry = entry->next_) {
if (severity_ >= entry->min_severity_) {
#if defined(WEBRTC_ANDROID)
@@ -230,6 +237,17 @@ int LogMessage::GetMinLogSeverity() {
LoggingSeverity LogMessage::GetLogToDebug() {
return g_dbg_sev;
}
+
+#if defined(WEBRTC_WEBKIT_BUILD)
+void LogMessage::SetLogOutput(LoggingSeverity min_sev, LogOutputCallback callback)
+{
+ g_dbg_sev = min_sev;
+ webrtc::MutexLock lock(&logMutex());
+ UpdateMinLogSeverity();
+ g_log_output_callback = callback;
+}
+#endif
+
int64_t LogMessage::LogStartTime() {
static const int64_t g_start = SystemTimeMillis();
return g_start;
@@ -250,7 +268,7 @@ void LogMessage::LogTimestamps(bool on) {
void LogMessage::LogToDebug(LoggingSeverity min_sev) {
g_dbg_sev = min_sev;
- webrtc::MutexLock lock(&g_log_mutex_);
+ webrtc::MutexLock lock(&logMutex());
UpdateMinLogSeverity();
}
@@ -259,7 +277,7 @@ void LogMessage::SetLogToStderr(bool log_to_stderr) {
}
int LogMessage::GetLogToStream(LogSink* stream) {
- webrtc::MutexLock lock(&g_log_mutex_);
+ webrtc::MutexLock lock(&logMutex());
LoggingSeverity sev = LS_NONE;
for (LogSink* entry = streams_; entry != nullptr; entry = entry->next_) {
if (stream == nullptr || stream == entry) {
@@ -270,7 +288,7 @@ int LogMessage::GetLogToStream(LogSink* stream) {
}
void LogMessage::AddLogToStream(LogSink* stream, LoggingSeverity min_sev) {
- webrtc::MutexLock lock(&g_log_mutex_);
+ webrtc::MutexLock lock(&logMutex());
stream->min_severity_ = min_sev;
stream->next_ = streams_;
streams_ = stream;
@@ -279,7 +297,7 @@ void LogMessage::AddLogToStream(LogSink* stream, LoggingSeverity min_sev) {
}
void LogMessage::RemoveLogToStream(LogSink* stream) {
- webrtc::MutexLock lock(&g_log_mutex_);
+ webrtc::MutexLock lock(&logMutex());
for (LogSink** entry = &streams_; *entry != nullptr;
entry = &(*entry)->next_) {
if (*entry == stream) {
@@ -341,7 +359,7 @@ void LogMessage::ConfigureLogging(const char* params) {
}
void LogMessage::UpdateMinLogSeverity()
- RTC_EXCLUSIVE_LOCKS_REQUIRED(g_log_mutex_) {
+ RTC_EXCLUSIVE_LOCKS_REQUIRED(logMutex()) {
LoggingSeverity min_sev = g_dbg_sev;
for (LogSink* entry = streams_; entry != nullptr; entry = entry->next_) {
min_sev = std::min(min_sev, entry->min_severity_);
@@ -435,6 +453,9 @@ void LogMessage::OutputToDebug(const std::string& str,
}
}
#endif // WEBRTC_ANDROID
+ if (g_log_output_callback) {
+ g_log_output_callback(severity, str.c_str());
+ }
if (log_to_stderr) {
fprintf(stderr, "%s", str.c_str());
fflush(stderr);
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/logging.h b/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/logging.h
index d2607c28b704..64c1201ec72e 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/logging.h
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/logging.h
@@ -460,6 +460,12 @@ class LogMessage {
// Debug: Debug console on Windows, otherwise stderr
static void LogToDebug(LoggingSeverity min_sev);
static LoggingSeverity GetLogToDebug();
+
+#if defined(WEBRTC_WEBKIT_BUILD)
+ typedef void (*LogOutputCallback)(LoggingSeverity severity, const char*);
+ static void SetLogOutput(LoggingSeverity min_sev, LogOutputCallback);
+#endif
+
// Sets whether logs will be directed to stderr in debug mode.
static void SetLogToStderr(bool log_to_stderr);
// Stream: Any non-blocking stream interface.
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/never_destroyed.h b/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/never_destroyed.h
new file mode 100644
index 000000000000..fcc62e355341
--- /dev/null
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/never_destroyed.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2018 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <type_traits>
+#include <utility>
+
+namespace rtc {
+
+template<typename T> class NeverDestroyed {
+public:
+ template<typename... Args> NeverDestroyed(Args&&... args)
+ {
+ new (storagePointer()) T(std::forward<Args>(args)...);
+ }
+
+ NeverDestroyed(NeverDestroyed&& other)
+ {
+ new (storagePointer()) T(std::move(*other.storagePointer()));
+ }
+
+ operator T&() { return *storagePointer(); }
+ T& get() { return *storagePointer(); }
+
+ operator const T&() const { return *storagePointer(); }
+ const T& get() const { return *storagePointer(); }
+
+private:
+ NeverDestroyed(const NeverDestroyed&) = delete;
+ NeverDestroyed& operator=(const NeverDestroyed&) = delete;
+
+ using PointerType = typename std::remove_const<T>::type*;
+
+ PointerType storagePointer() const { return const_cast<PointerType>(reinterpret_cast<const T*>(&m_storage)); }
+
+ // FIXME: Investigate whether we should allocate a hunk of virtual memory
+ // and hand out chunks of it to NeverDestroyed instead, to reduce fragmentation.
+ typename std::aligned_storage<sizeof(T), std::alignment_of<T>::value>::type m_storage;
+};
+
+template<typename T> inline NeverDestroyed<T> makeNeverDestroyed(T&& argument)
+{
+ return NeverDestroyed<T>(std::move(argument));
+}
+
+} // namespace rtc
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/numerics/safe_conversions.h b/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/numerics/safe_conversions.h
index 5d58672510cf..1fa280cf9f16 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/numerics/safe_conversions.h
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/numerics/safe_conversions.h
@@ -63,11 +63,11 @@ inline constexpr Dst saturated_cast(Src value) {
// Should fail only on attempting to assign NaN to a saturated integer.
case internal::TYPE_INVALID:
- FATAL();
+ RTC_FATAL();
return std::numeric_limits<Dst>::max();
}
- FATAL();
+ RTC_FATAL();
return static_cast<Dst>(value);
}
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/openssl_certificate.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/openssl_certificate.cc
index 9459f76df6c2..887c7b77d6a7 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/openssl_certificate.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/openssl_certificate.cc
@@ -245,11 +245,11 @@ std::unique_ptr<SSLCertificate> OpenSSLCertificate::Clone() const {
std::string OpenSSLCertificate::ToPEMString() const {
BIO* bio = BIO_new(BIO_s_mem());
if (!bio) {
- FATAL() << "Unreachable code.";
+ RTC_FATAL() << "Unreachable code.";
}
if (!PEM_write_bio_X509(bio, x509_)) {
BIO_free(bio);
- FATAL() << "Unreachable code.";
+ RTC_FATAL() << "Unreachable code.";
}
BIO_write(bio, "\0", 1);
char* buffer;
@@ -265,11 +265,11 @@ void OpenSSLCertificate::ToDER(Buffer* der_buffer) const {
// Calculates the DER representation of the certificate, from scratch.
BIO* bio = BIO_new(BIO_s_mem());
if (!bio) {
- FATAL() << "Unreachable code.";
+ RTC_FATAL() << "Unreachable code.";
}
if (!i2d_X509_bio(bio, x509_)) {
BIO_free(bio);
- FATAL() << "Unreachable code.";
+ RTC_FATAL() << "Unreachable code.";
}
char* data = nullptr;
size_t length = BIO_get_mem_data(bio, &data);
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/openssl_stream_adapter.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/openssl_stream_adapter.cc
index 0f8c1fcb1381..905bea0dc02b 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/openssl_stream_adapter.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/openssl_stream_adapter.cc
@@ -1000,6 +1000,10 @@ SSL_CTX* OpenSSLStreamAdapter::SetupSSLContext() {
break;
case SSL_PROTOCOL_TLS_12:
default:
+#if defined(WEBRTC_WEBKIT_BUILD)
+ SSL_CTX_set_min_proto_version(
+ ctx, ssl_mode_ == SSL_MODE_DTLS ? DTLS1_2_VERSION : TLS1_2_VERSION);
+#endif
SSL_CTX_set_max_proto_version(
ctx, ssl_mode_ == SSL_MODE_DTLS ? DTLS1_2_VERSION : TLS1_2_VERSION);
break;
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/physical_socket_server.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/physical_socket_server.cc
index cf6e79279511..1d23a35ee663 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/physical_socket_server.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/physical_socket_server.cc
@@ -636,6 +636,10 @@ SocketDispatcher::~SocketDispatcher() {
bool SocketDispatcher::Initialize() {
RTC_DCHECK(s_ != INVALID_SOCKET);
// Must be a non-blocking
+#if defined(WEBRTC_WEBKIT_BUILD)
+ if (s_ < 0 || s_ >= FD_SETSIZE)
+ return false;
+#endif
#if defined(WEBRTC_WIN)
u_long argp = 1;
ioctlsocket(s_, FIONBIO, &argp);
@@ -1285,6 +1289,10 @@ bool PhysicalSocketServer::WaitSelect(int cmsWait, bool process_io) {
// "select"ing a file descriptor that is equal to or larger than
// FD_SETSIZE will result in undefined behavior.
RTC_DCHECK_LT(fd, FD_SETSIZE);
+#if defined(WEBRTC_WEBKIT_BUILD)
+ if (fd < 0 || fd >= FD_SETSIZE)
+ continue;
+#endif
if (fd > fdmax)
fdmax = fd;
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/string_utils.h b/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/string_utils.h
index 23c55cb89359..3f2b1bb80f89 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/string_utils.h
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/string_utils.h
@@ -11,7 +11,10 @@
#ifndef RTC_BASE_STRING_UTILS_H_
#define RTC_BASE_STRING_UTILS_H_
+#if !defined(WEBRTC_WEBKIT_BUILD)
#include <ctype.h>
+#endif // !defined(WEBRTC_WEBKIT_BUILD)
+
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/trace_event.h b/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/trace_event.h
index a0b788fbf943..626597c22be8 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/trace_event.h
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/rtc_base/trace_event.h
@@ -1019,4 +1019,4 @@ class TraceEndOnScopeClose {
#endif // RTC_TRACE_EVENTS_ENABLED
-#endif // RTC_BASE_TRACE_EVENT_H_
\ No newline at end of file
+#endif // RTC_BASE_TRACE_EVENT_H_
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/WebKit/WebKitEncoder.h b/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/WebKit/WebKitEncoder.h
index e703f628a37a..23d97ecc4ebf 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/WebKit/WebKitEncoder.h
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/WebKit/WebKitEncoder.h
@@ -72,29 +72,15 @@ struct WebKitEncodedFrameInfo {
template<class Decoder> static bool decode(Decoder&, WebKitEncodedFrameInfo&);
};
-class WebKitRTPFragmentationHeader {
-public:
- explicit WebKitRTPFragmentationHeader(webrtc::RTPFragmentationHeader* = nullptr);
-
- template<class Encoder> void encode(Encoder&) const;
- template<class Decoder> static bool decode(Decoder&, WebKitRTPFragmentationHeader&);
-
- webrtc::RTPFragmentationHeader* value() { return m_value; };
-
-private:
- webrtc::RTPFragmentationHeader* m_value { nullptr };
- std::unique_ptr<webrtc::RTPFragmentationHeader> m_ownedHeader;
-};
-
using LocalEncoder = void*;
-using LocalEncoderCallback = void (^)(const uint8_t* buffer, size_t size, const webrtc::WebKitEncodedFrameInfo&, webrtc::RTPFragmentationHeader*);
+using LocalEncoderCallback = void (^)(const uint8_t* buffer, size_t size, const webrtc::WebKitEncodedFrameInfo&);
void* createLocalEncoder(const webrtc::SdpVideoFormat&, LocalEncoderCallback);
void releaseLocalEncoder(LocalEncoder);
void initializeLocalEncoder(LocalEncoder, uint16_t width, uint16_t height, unsigned int startBitrate, unsigned int maxBitrate, unsigned int minBitrate, uint32_t maxFramerate);
void encodeLocalEncoderFrame(LocalEncoder, CVPixelBufferRef, int64_t timeStampNs, uint32_t timeStamp, webrtc::VideoRotation, bool isKeyframeRequired);
void setLocalEncoderRates(LocalEncoder, uint32_t bitRate, uint32_t frameRate);
void setLocalEncoderLowLatency(LocalEncoder, bool isLowLatencyEnabled);
-void encoderVideoTaskComplete(void*, webrtc::VideoCodecType, uint8_t* buffer, size_t length, const WebKitEncodedFrameInfo&, const webrtc::RTPFragmentationHeader*);
+void encoderVideoTaskComplete(void*, webrtc::VideoCodecType, uint8_t* buffer, size_t length, const WebKitEncodedFrameInfo&);
template<class Decoder>
bool WebKitEncodedFrameInfo::decode(Decoder& decoder, WebKitEncodedFrameInfo& info)
@@ -167,58 +153,4 @@ void WebKitEncodedFrameInfo::encode(Encoder& encoder) const
encoder << timing.receive_finish_ms;
}
-inline WebKitRTPFragmentationHeader::WebKitRTPFragmentationHeader(webrtc::RTPFragmentationHeader* header)
- : m_value(header)
-{
-}
-
-template<class Encoder>
-void WebKitRTPFragmentationHeader::encode(Encoder& encoder) const
-{
- encoder << !!m_value;
- if (!m_value)
- return;
-
- encoder << static_cast<unsigned>(m_value->Size());
- for (unsigned i = 0; i < m_value->Size(); ++i) {
- encoder << static_cast<unsigned>(m_value->Offset(i));
- encoder << static_cast<unsigned>(m_value->Length(i));
- }
-}
-
-template<class Decoder>
-bool WebKitRTPFragmentationHeader::decode(Decoder& decoder, WebKitRTPFragmentationHeader& header)
-{
- bool hasValue;
- if (!decoder.decode(hasValue))
- return false;
-
- if (!hasValue) {
- header.m_value = nullptr;
- return true;
- }
-
- unsigned size;
- if (!decoder.decode(size))
- return false;
-
- auto ownedHeader = std::make_unique<webrtc::RTPFragmentationHeader>();
- ownedHeader->VerifyAndAllocateFragmentationHeader(size);
- for (size_t i = 0; i < size; ++i) {
- unsigned offset, length;
- if (!decoder.decode(offset))
- return false;
- if (!decoder.decode(length))
- return false;
-
- ownedHeader->fragmentationOffset[i] = offset;
- ownedHeader->fragmentationLength[i] = length;
- }
-
- header.m_ownedHeader = std::move(ownedHeader);
- header.m_value = header.m_ownedHeader.get();
-
- return true;
-}
-
}
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/WebKit/WebKitEncoder.mm b/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/WebKit/WebKitEncoder.mm
index d9cf7a5de9af..d7951c6121d6 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/WebKit/WebKitEncoder.mm
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/WebKit/WebKitEncoder.mm
@@ -31,7 +31,6 @@
#include "media/engine/encoder_simulcast_proxy.h"
#include "modules/video_coding/utility/simulcast_utility.h"
#include "sdk/objc/api/peerconnection/RTCEncodedImage+Private.h"
-#include "sdk/objc/api/peerconnection/RTCRtpFragmentationHeader+Private.h"
#include "sdk/objc/api/peerconnection/RTCVideoCodecInfo+Private.h"
#include "sdk/objc/api/peerconnection/RTCVideoEncoderSettings+Private.h"
#include "sdk/objc/components/video_codec/RTCDefaultVideoEncoderFactory.h"
@@ -291,7 +290,7 @@ int32_t RemoteVideoEncoder::RegisterEncodeCompleteCallback(EncodedImageCallback*
return videoEncoderCallbacks().registerEncodeCompleteCallback(m_internalEncoder, callback);
}
-void encoderVideoTaskComplete(void* callback, webrtc::VideoCodecType codecType, uint8_t* buffer, size_t length, const WebKitEncodedFrameInfo& info, const webrtc::RTPFragmentationHeader* header)
+void encoderVideoTaskComplete(void* callback, webrtc::VideoCodecType codecType, uint8_t* buffer, size_t length, const WebKitEncodedFrameInfo& info)
{
webrtc::EncodedImage encodedImage(buffer, length, length);
encodedImage._encodedWidth = info.width;
@@ -313,7 +312,7 @@ void encoderVideoTaskComplete(void* callback, webrtc::VideoCodecType codecType,
else if (codecType == kVideoCodecH265)
codecSpecificInfo.codecSpecific.H265.packetization_mode = H265PacketizationMode::NonInterleaved;
- static_cast<EncodedImageCallback*>(callback)->OnEncodedImage(encodedImage, &codecSpecificInfo, header);
+ static_cast<EncodedImageCallback*>(callback)->OnEncodedImage(encodedImage, &codecSpecificInfo);
}
void* createLocalEncoder(const webrtc::SdpVideoFormat& format, LocalEncoderCallback callback)
@@ -321,7 +320,7 @@ void* createLocalEncoder(const webrtc::SdpVideoFormat& format, LocalEncoderCallb
auto *codecInfo = [[RTCVideoCodecInfo alloc] initWithNativeSdpVideoFormat: format];
auto *encoder = [[WK_RTCLocalVideoH264H265Encoder alloc] initWithCodecInfo:codecInfo];
- [encoder setCallback:^BOOL(RTCEncodedImage *_Nonnull frame, id<RTCCodecSpecificInfo> _Nonnull codecSpecificInfo, RTCRtpFragmentationHeader *_Nonnull header) {
+ [encoder setCallback:^BOOL(RTCEncodedImage *_Nonnull frame, id<RTCCodecSpecificInfo> _Nonnull codecSpecificInfo, RTCRtpFragmentationHeader * _Nullable header) {
EncodedImage encodedImage = [frame nativeEncodedImage];
WebKitEncodedFrameInfo info;
@@ -337,7 +336,7 @@ void* createLocalEncoder(const webrtc::SdpVideoFormat& format, LocalEncoderCallb
info.qp = encodedImage.qp_;
info.timing = encodedImage.timing_;
- callback(encodedImage.data(), encodedImage.size(), info, [header createNativeFragmentationHeader].get());
+ callback(encodedImage.data(), encodedImage.size(), info);
return YES;
}];
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/Framework/Classes/PeerConnection/RTCVideoCodec+Private.h b/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/Framework/Classes/PeerConnection/RTCVideoCodec+Private.h
index 3233e4e9f2be..edeb8ad4b9fa 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/Framework/Classes/PeerConnection/RTCVideoCodec+Private.h
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/Framework/Classes/PeerConnection/RTCVideoCodec+Private.h
@@ -9,7 +9,7 @@
*/
#import "api/peerconnection/RTCEncodedImage+Private.h"
-#import "api/peerconnection/RTCRtpFragmentationHeader+Private.h"
+//#import "api/peerconnection/RTCRtpFragmentationHeader+Private.h"
#import "api/peerconnection/RTCVideoCodecInfo+Private.h"
#import "api/peerconnection/RTCVideoEncoderSettings+Private.h"
#import "components/video_codec/RTCCodecSpecificInfoH264+Private.h"
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/base/RTCVideoEncoder.h b/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/base/RTCVideoEncoder.h
index c5257674d834..398e57c11cd7 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/base/RTCVideoEncoder.h
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/base/RTCVideoEncoder.h
@@ -23,7 +23,7 @@ NS_ASSUME_NONNULL_BEGIN
/** Callback block for encoder. */
typedef BOOL (^RTCVideoEncoderCallback)(RTCEncodedImage *frame,
id<RTCCodecSpecificInfo> info,
- RTCRtpFragmentationHeader *header);
+ RTCRtpFragmentationHeader* __nullable header);
/** Protocol for encoder implementations. */
RTC_OBJC_EXPORT
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/components/video_codec/RTCDefaultVideoDecoderFactory.m b/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/components/video_codec/RTCDefaultVideoDecoderFactory.m
index 0437e6a34b3d..1e5aac8d240c 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/components/video_codec/RTCDefaultVideoDecoderFactory.m
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/components/video_codec/RTCDefaultVideoDecoderFactory.m
@@ -46,37 +46,39 @@ - (id)initWithH265:(bool)supportsH265 vp9:(bool)supportsVP9 vp9VTB:(bool)support
}
- (NSArray<RTCVideoCodecInfo *> *)supportedCodecs {
- NSDictionary<NSString *, NSString *> *constrainedHighParams = @{
+ NSMutableArray<RTCVideoCodecInfo *> *codecs = [[NSMutableArray alloc] initWithCapacity:5];
+
+ [codecs addObject: [[RTCVideoCodecInfo alloc] initWithName:kRTCVideoCodecH264Name parameters: @{
@"profile-level-id" : kRTCMaxSupportedH264ProfileLevelConstrainedHigh,
@"level-asymmetry-allowed" : @"1",
@"packetization-mode" : @"1",
- };
- RTCVideoCodecInfo *constrainedHighInfo =
- [[RTCVideoCodecInfo alloc] initWithName:kRTCVideoCodecH264Name
- parameters:constrainedHighParams];
-
- NSDictionary<NSString *, NSString *> *constrainedBaselineParams = @{
+ }]];
+ [codecs addObject: [[RTCVideoCodecInfo alloc] initWithName:kRTCVideoCodecH264Name parameters: @{
@"profile-level-id" : kRTCMaxSupportedH264ProfileLevelConstrainedBaseline,
@"level-asymmetry-allowed" : @"1",
@"packetization-mode" : @"1",
- };
- RTCVideoCodecInfo *constrainedBaselineInfo =
- [[RTCVideoCodecInfo alloc] initWithName:kRTCVideoCodecH264Name
- parameters:constrainedBaselineParams];
-
- RTCVideoCodecInfo *vp8Info = [[RTCVideoCodecInfo alloc] initWithName:kRTCVideoCodecVp8Name];
-
- NSMutableArray<RTCVideoCodecInfo *> *codecs = [[NSMutableArray alloc] initWithCapacity:5];
+ }]];
+ [codecs addObject: [[RTCVideoCodecInfo alloc] initWithName:kRTCVideoCodecH264Name parameters: @{
+ @"profile-level-id" : kRTCMaxSupportedH264ProfileLevelConstrainedHigh,
+ @"level-asymmetry-allowed" : @"1",
+ @"packetization-mode" : @"0",
+ }]];
+ [codecs addObject: [[RTCVideoCodecInfo alloc] initWithName:kRTCVideoCodecH264Name parameters: @{
+ @"profile-level-id" : kRTCMaxSupportedH264ProfileLevelConstrainedBaseline,
+ @"level-asymmetry-allowed" : @"1",
+ @"packetization-mode" : @"0",
+ }]];
- [codecs addObject:constrainedHighInfo];
- [codecs addObject:constrainedBaselineInfo];
#if !defined(RTC_DISABLE_H265)
if (_supportsH265) {
RTCVideoCodecInfo *h265Info = [[RTCVideoCodecInfo alloc] initWithName:kRTCVideoCodecH265Name];
[codecs addObject:h265Info];
}
#endif
+
+ RTCVideoCodecInfo *vp8Info = [[RTCVideoCodecInfo alloc] initWithName:kRTCVideoCodecVp8Name];
[codecs addObject:vp8Info];
+
#if defined(RTC_ENABLE_VP9)
if (_supportsVP9) {
[codecs addObject:[[RTCVideoCodecInfo alloc] initWithName:kRTCVideoCodecVp9Name parameters: @{
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/components/video_codec/RTCDefaultVideoEncoderFactory.m b/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/components/video_codec/RTCDefaultVideoEncoderFactory.m
index f01447045053..ed3ced3fb0b2 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/components/video_codec/RTCDefaultVideoEncoderFactory.m
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/components/video_codec/RTCDefaultVideoEncoderFactory.m
@@ -45,28 +45,30 @@ - (id)initWithH265:(bool)supportsH265 vp9:(bool)supportsVP9 lowLatencyH264:(bool
}
+ (NSArray<RTCVideoCodecInfo *> *)supportedCodecsWithH265:(bool)supportsH265 vp9:(bool)supportsVP9 {
- NSDictionary<NSString *, NSString *> *constrainedHighParams = @{
+
+ NSMutableArray<RTCVideoCodecInfo *> *codecs = [[NSMutableArray alloc] initWithCapacity:8];
+
+ [codecs addObject: [[RTCVideoCodecInfo alloc] initWithName:kRTCVideoCodecH264Name parameters: @{
@"profile-level-id" : kRTCMaxSupportedH264ProfileLevelConstrainedHigh,
@"level-asymmetry-allowed" : @"1",
@"packetization-mode" : @"1",
- };
- RTCVideoCodecInfo *constrainedHighInfo =
- [[RTCVideoCodecInfo alloc] initWithName:kRTCVideoCodecH264Name
- parameters:constrainedHighParams];
-
- NSDictionary<NSString *, NSString *> *constrainedBaselineParams = @{
+ }]];
+ [codecs addObject: [[RTCVideoCodecInfo alloc] initWithName:kRTCVideoCodecH264Name parameters: @{
@"profile-level-id" : kRTCMaxSupportedH264ProfileLevelConstrainedBaseline,
@"level-asymmetry-allowed" : @"1",
@"packetization-mode" : @"1",
- };
- RTCVideoCodecInfo *constrainedBaselineInfo =
- [[RTCVideoCodecInfo alloc] initWithName:kRTCVideoCodecH264Name
- parameters:constrainedBaselineParams];
-
- NSMutableArray<RTCVideoCodecInfo *> *codecs = [[NSMutableArray alloc] initWithCapacity:5];
+ }]];
+ [codecs addObject: [[RTCVideoCodecInfo alloc] initWithName:kRTCVideoCodecH264Name parameters: @{
+ @"profile-level-id" : kRTCMaxSupportedH264ProfileLevelConstrainedHigh,
+ @"level-asymmetry-allowed" : @"1",
+ @"packetization-mode" : @"0",
+ }]];
+ [codecs addObject: [[RTCVideoCodecInfo alloc] initWithName:kRTCVideoCodecH264Name parameters: @{
+ @"profile-level-id" : kRTCMaxSupportedH264ProfileLevelConstrainedBaseline,
+ @"level-asymmetry-allowed" : @"1",
+ @"packetization-mode" : @"0",
+ }]];
- [codecs addObject:constrainedHighInfo];
- [codecs addObject:constrainedBaselineInfo];
#if !defined(RTC_DISABLE_H265)
if (supportsH265) {
RTCVideoCodecInfo *h265Info = [[RTCVideoCodecInfo alloc] initWithName:kRTCVideoCodecH265Name];
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/components/video_codec/RTCVideoEncoderH264.mm b/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/components/video_codec/RTCVideoEncoderH264.mm
index 57bedb7f29bd..551318f76d4e 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/components/video_codec/RTCVideoEncoderH264.mm
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/components/video_codec/RTCVideoEncoderH264.mm
@@ -19,7 +19,6 @@
#endif
#import "RTCCodecSpecificInfoH264.h"
#import "RTCH264ProfileLevelId.h"
-#import "api/peerconnection/RTCRtpFragmentationHeader+Private.h"
#import "api/peerconnection/RTCVideoCodecInfo+Private.h"
#import "base/RTCCodecSpecificInfo.h"
#import "base/RTCI420Buffer.h"
@@ -997,15 +996,8 @@ NSUInteger GetMaxSampleRate(const webrtc::H264::ProfileLevelId &profile_level_id
}
__block std::unique_ptr<rtc::Buffer> buffer = std::make_unique<rtc::Buffer>();
- RTCRtpFragmentationHeader *header;
- {
- std::unique_ptr<webrtc::RTPFragmentationHeader> header_cpp;
- bool result =
- H264CMSampleBufferToAnnexBBuffer(sampleBuffer, isKeyframe, buffer.get(), &header_cpp);
- header = [[RTCRtpFragmentationHeader alloc] initWithNativeFragmentationHeader:header_cpp.get()];
- if (!result) {
- return;
- }
+ if (!webrtc::H264CMSampleBufferToAnnexBBuffer(sampleBuffer, isKeyframe, buffer.get())) {
+ return;
}
RTCEncodedImage *frame = [[RTCEncodedImage alloc] init];
@@ -1031,7 +1023,7 @@ NSUInteger GetMaxSampleRate(const webrtc::H264::ProfileLevelId &profile_level_id
_h264BitstreamParser.GetLastSliceQp(&qp);
frame.qp = @(qp);
- BOOL res = _callback(frame, codecSpecificInfo, header);
+ BOOL res = _callback(frame, codecSpecificInfo, nullptr);
if (!res) {
RTC_LOG(LS_ERROR) << "Encode callback failed";
if (isKeyFrameRequired)
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/components/video_codec/RTCVideoEncoderH265.mm b/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/components/video_codec/RTCVideoEncoderH265.mm
index 457c57077ac7..655fbd0f4c1c 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/components/video_codec/RTCVideoEncoderH265.mm
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/components/video_codec/RTCVideoEncoderH265.mm
@@ -15,7 +15,7 @@
#include <vector>
#import "RTCCodecSpecificInfoH265.h"
-#import "api/peerconnection/RTCRtpFragmentationHeader+Private.h"
+//#import "api/peerconnection/RTCRtpFragmentationHeader+Private.h"
#import "api/peerconnection/RTCVideoCodecInfo+Private.h"
#import "base/RTCI420Buffer.h"
#import "base/RTCVideoFrame.h"
@@ -540,20 +540,9 @@ void compressionOutputCallback(void* encoder,
RTC_LOG(LS_INFO) << "Generated keyframe";
}
- // Convert the sample buffer into a buffer suitable for RTP packetization.
- // TODO(tkchin): Allocate buffers through a pool.
std::unique_ptr<rtc::Buffer> buffer(new rtc::Buffer());
- RTCRtpFragmentationHeader* header;
- {
- std::unique_ptr<webrtc::RTPFragmentationHeader> header_cpp;
- bool result = H265CMSampleBufferToAnnexBBuffer(sampleBuffer, isKeyframe,
- buffer.get(), &header_cpp);
- header = [[RTCRtpFragmentationHeader alloc]
- initWithNativeFragmentationHeader:header_cpp.get()];
- if (!result) {
- RTC_LOG(LS_ERROR) << "Failed to convert sample buffer.";
- return;
- }
+ if (!webrtc::H265CMSampleBufferToAnnexBBuffer(sampleBuffer, isKeyframe, buffer.get())) {
+ RTC_LOG(LS_INFO) << "Unable to parse H265 encoded buffer";
}
RTCEncodedImage* frame = [[RTCEncodedImage alloc] init];
@@ -575,7 +564,7 @@ void compressionOutputCallback(void* encoder,
// FIXME: QP is ignored because there is no H.265 bitstream parser.
- BOOL res = _callback(frame, [[RTCCodecSpecificInfoH265 alloc] init], header);
+ BOOL res = _callback(frame, [[RTCCodecSpecificInfoH265 alloc] init], nullptr);
if (!res) {
RTC_LOG(LS_ERROR) << "Encode callback failed.";
return;
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/components/video_codec/nalu_rewriter.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/components/video_codec/nalu_rewriter.cc
index ddf734605115..a2822b583c6b 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/components/video_codec/nalu_rewriter.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/components/video_codec/nalu_rewriter.cc
@@ -29,14 +29,10 @@ using H264::ParseNaluType;
const char kAnnexBHeaderBytes[4] = {0, 0, 0, 1};
const size_t kAvccHeaderByteSize = sizeof(uint32_t);
-bool H264CMSampleBufferToAnnexBBuffer(
- CMSampleBufferRef avcc_sample_buffer,
- bool is_keyframe,
- rtc::Buffer* annexb_buffer,
- std::unique_ptr<RTPFragmentationHeader>* out_header) {
+bool H264CMSampleBufferToAnnexBBuffer(CMSampleBufferRef avcc_sample_buffer,
+ bool is_keyframe,
+ rtc::Buffer* annexb_buffer) {
RTC_DCHECK(avcc_sample_buffer);
- RTC_DCHECK(out_header);
- out_header->reset(nullptr);
// Get format description from the sample buffer.
CMVideoFormatDescriptionRef description =
@@ -61,10 +57,6 @@ bool H264CMSampleBufferToAnnexBBuffer(
// Truncate any previous data in the buffer without changing its capacity.
annexb_buffer->SetSize(0);
- size_t nalu_offset = 0;
- std::vector<size_t> frag_offsets;
- std::vector<size_t> frag_lengths;
-
// Place all parameter sets at the front of buffer.
if (is_keyframe) {
size_t param_set_size = 0;
@@ -80,10 +72,6 @@ bool H264CMSampleBufferToAnnexBBuffer(
annexb_buffer->AppendData(kAnnexBHeaderBytes, sizeof(kAnnexBHeaderBytes));
annexb_buffer->AppendData(reinterpret_cast<const char*>(param_set),
param_set_size);
- // Update fragmentation.
- frag_offsets.push_back(nalu_offset + sizeof(kAnnexBHeaderBytes));
- frag_lengths.push_back(param_set_size);
- nalu_offset += sizeof(kAnnexBHeaderBytes) + param_set_size;
}
}
@@ -132,10 +120,6 @@ bool H264CMSampleBufferToAnnexBBuffer(
// Update buffer.
annexb_buffer->AppendData(kAnnexBHeaderBytes, sizeof(kAnnexBHeaderBytes));
annexb_buffer->AppendData(data_ptr + nalu_header_size, packet_size);
- // Update fragmentation.
- frag_offsets.push_back(nalu_offset + sizeof(kAnnexBHeaderBytes));
- frag_lengths.push_back(packet_size);
- nalu_offset += sizeof(kAnnexBHeaderBytes) + packet_size;
size_t bytes_written = packet_size + sizeof(kAnnexBHeaderBytes);
bytes_remaining -= bytes_written;
@@ -143,14 +127,6 @@ bool H264CMSampleBufferToAnnexBBuffer(
}
RTC_DCHECK_EQ(bytes_remaining, (size_t)0);
- std::unique_ptr<RTPFragmentationHeader> header(new RTPFragmentationHeader());
- header->VerifyAndAllocateFragmentationHeader(frag_offsets.size());
- RTC_DCHECK_EQ(frag_lengths.size(), frag_offsets.size());
- for (size_t i = 0; i < frag_offsets.size(); ++i) {
- header->fragmentationOffset[i] = frag_offsets[i];
- header->fragmentationLength[i] = frag_lengths[i];
- }
- *out_header = std::move(header);
CFRelease(contiguous_buffer);
return true;
}
@@ -252,11 +228,8 @@ bool H264AnnexBBufferToCMSampleBuffer(const uint8_t* annexb_buffer,
bool H265CMSampleBufferToAnnexBBuffer(
CMSampleBufferRef hvcc_sample_buffer,
bool is_keyframe,
- rtc::Buffer* annexb_buffer,
- std::unique_ptr<RTPFragmentationHeader> *out_header) {
+ rtc::Buffer* annexb_buffer) {
RTC_DCHECK(hvcc_sample_buffer);
- RTC_DCHECK(out_header);
- out_header->reset(nullptr);
// Get format description from the sample buffer.
CMVideoFormatDescriptionRef description =
@@ -363,15 +336,8 @@ bool H265CMSampleBufferToAnnexBBuffer(
}
RTC_DCHECK_EQ(bytes_remaining, (size_t)0);
- std::unique_ptr<RTPFragmentationHeader> header(new RTPFragmentationHeader());
- header->VerifyAndAllocateFragmentationHeader(frag_offsets.size());
- RTC_DCHECK_EQ(frag_lengths.size(), frag_offsets.size());
- for (size_t i = 0; i < frag_offsets.size(); ++i) {
- header->fragmentationOffset[i] = frag_offsets[i];
- header->fragmentationLength[i] = frag_lengths[i];
- }
- *out_header = std::move(header);
CFRelease(contiguous_buffer);
+
return true;
}
@@ -384,7 +350,7 @@ bool H265AnnexBBufferToCMSampleBuffer(const uint8_t* annexb_buffer,
RTC_DCHECK(video_format);
*out_sample_buffer = nullptr;
- AnnexBBufferReader reader(annexb_buffer, annexb_buffer_size);
+ AnnexBBufferReader reader(annexb_buffer, annexb_buffer_size, false);
if (reader.SeekToNextNaluOfType(H265::kVps)) {
// Buffer contains an SPS NALU - skip it and the following PPS
const uint8_t* data;
@@ -507,7 +473,7 @@ CMVideoFormatDescriptionRef CreateH265VideoFormatDescription(
size_t annexb_buffer_size) {
const uint8_t* param_set_ptrs[3] = {};
size_t param_set_sizes[3] = {};
- AnnexBBufferReader reader(annexb_buffer, annexb_buffer_size);
+ AnnexBBufferReader reader(annexb_buffer, annexb_buffer_size, false);
// Skip everyting before the VPS, then read the VPS, SPS and PPS
if (!reader.SeekToNextNaluOfType(H265::kVps)) {
return nullptr;
@@ -539,10 +505,11 @@ CMVideoFormatDescriptionRef CreateH265VideoFormatDescription(
#endif
AnnexBBufferReader::AnnexBBufferReader(const uint8_t* annexb_buffer,
- size_t length)
+ size_t length, bool isH264)
: start_(annexb_buffer), length_(length) {
RTC_DCHECK(annexb_buffer);
- offsets_ = H264::FindNaluIndices(annexb_buffer, length);
+
+ offsets_ = isH264 ? H264::FindNaluIndices(annexb_buffer, length) : H265::FindNaluIndices(annexb_buffer, length);
offset_ = offsets_.begin();
}
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/components/video_codec/nalu_rewriter.h b/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/components/video_codec/nalu_rewriter.h
index 4da1cc57c7d1..2ed560f98615 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/components/video_codec/nalu_rewriter.h
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/components/video_codec/nalu_rewriter.h
@@ -18,10 +18,7 @@
#include <vector>
#include "common_video/h264/h264_common.h"
-#ifndef DISABLE_H265
#include "common_video/h265/h265_common.h"
-#endif
-#include "modules/include/module_common_types.h"
#include "rtc_base/buffer.h"
using webrtc::H264::NaluIndex;
@@ -30,13 +27,10 @@ namespace webrtc {
// Converts a sample buffer emitted from the VideoToolbox encoder into a buffer
// suitable for RTP. The sample buffer is in avcc format whereas the rtp buffer
-// needs to be in Annex B format. Data is written directly to |annexb_buffer|
-// and a new RTPFragmentationHeader is returned in |out_header|.
-bool H264CMSampleBufferToAnnexBBuffer(
- CMSampleBufferRef avcc_sample_buffer,
- bool is_keyframe,
- rtc::Buffer* annexb_buffer,
- std::unique_ptr<RTPFragmentationHeader>* out_header);
+// needs to be in Annex B format. Data is written directly to |annexb_buffer|.
+bool H264CMSampleBufferToAnnexBBuffer(CMSampleBufferRef avcc_sample_buffer,
+ bool is_keyframe,
+ rtc::Buffer* annexb_buffer);
// Converts a buffer received from RTP into a sample buffer suitable for the
// VideoToolbox decoder. The RTP buffer is in annex b format whereas the sample
@@ -52,17 +46,13 @@ bool H264AnnexBBufferToCMSampleBuffer(const uint8_t* annexb_buffer,
#ifndef DISABLE_H265
// Converts a sample buffer emitted from the VideoToolbox encoder into a buffer
-// suitable for RTP. The sample buffer is in hvcc format whereas the rtp buffer
-// needs to be in Annex B format. Data is written directly to |annexb_buffer|
-// and a new RTPFragmentationHeader is returned in |out_header|.
-bool H265CMSampleBufferToAnnexBBuffer(
- CMSampleBufferRef hvcc_sample_buffer,
- bool is_keyframe,
- rtc::Buffer* annexb_buffer,
- std::unique_ptr<RTPFragmentationHeader> *out_header)
- __OSX_AVAILABLE_STARTING(__MAC_10_12, __IPHONE_11_0);
+// suitable for RTP. The sample buffer is in avcc format whereas the rtp buffer
+// needs to be in Annex B format. Data is written directly to |annexb_buffer|.
+bool H265CMSampleBufferToAnnexBBuffer(CMSampleBufferRef avcc_sample_buffer,
+ bool is_keyframe,
+ rtc::Buffer* annexb_buffer);
- // Converts a buffer received from RTP into a sample buffer suitable for the
+// Converts a buffer received from RTP into a sample buffer suitable for the
// VideoToolbox decoder. The RTP buffer is in annex b format whereas the sample
// buffer is in hvcc format.
// If |is_keyframe| is true then |video_format| is ignored since the format will
@@ -73,6 +63,10 @@ bool H265AnnexBBufferToCMSampleBuffer(const uint8_t* annexb_buffer,
CMVideoFormatDescriptionRef video_format,
CMSampleBufferRef* out_sample_buffer)
__OSX_AVAILABLE_STARTING(__MAC_10_12, __IPHONE_11_0);
+
+CMVideoFormatDescriptionRef CreateH265VideoFormatDescription(
+ const uint8_t* annexb_buffer,
+ size_t annexb_buffer_size);
#endif
// Returns a video format description created from the sps/pps information in
@@ -82,17 +76,10 @@ CMVideoFormatDescriptionRef CreateVideoFormatDescription(
const uint8_t* annexb_buffer,
size_t annexb_buffer_size);
-#ifndef DISABLE_H265
-CMVideoFormatDescriptionRef CreateH265VideoFormatDescription(
- const uint8_t* annexb_buffer,
- size_t annexb_buffer_size)
- __OSX_AVAILABLE_STARTING(__MAC_10_12, __IPHONE_11_0);
-#endif
-
// Helper class for reading NALUs from an RTP Annex B buffer.
class AnnexBBufferReader final {
public:
- AnnexBBufferReader(const uint8_t* annexb_buffer, size_t length);
+ AnnexBBufferReader(const uint8_t* annexb_buffer, size_t length, bool isH264 = true);
~AnnexBBufferReader();
AnnexBBufferReader(const AnnexBBufferReader& other) = delete;
void operator=(const AnnexBBufferReader& other) = delete;
@@ -113,9 +100,7 @@ class AnnexBBufferReader final {
// Return true if a NALU of the desired type is found, false if we
// reached the end instead
bool SeekToNextNaluOfType(H264::NaluType type);
-#ifndef DISABLE_H265
bool SeekToNextNaluOfType(H265::NaluType type);
-#endif
private:
// Returns the the next offset that contains NALU data.
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/native/src/objc_video_encoder_factory.mm b/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/native/src/objc_video_encoder_factory.mm
index 33469813af34..fef97f1fca28 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/native/src/objc_video_encoder_factory.mm
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/sdk/objc/native/src/objc_video_encoder_factory.mm
@@ -19,7 +19,6 @@
#import "components/video_codec/RTCCodecSpecificInfoH265+Private.h"
#endif
#import "sdk/objc/api/peerconnection/RTCEncodedImage+Private.h"
-#import "sdk/objc/api/peerconnection/RTCRtpFragmentationHeader+Private.h"
#import "sdk/objc/api/peerconnection/RTCVideoCodecInfo+Private.h"
#import "sdk/objc/api/peerconnection/RTCVideoEncoderSettings+Private.h"
#import "sdk/objc/api/video_codec/RTCVideoCodecConstants.h"
@@ -80,10 +79,8 @@ class ObjCVideoEncoder : public VideoEncoder {
#endif
}
- std::unique_ptr<RTPFragmentationHeader> fragmentationHeader =
- [header createNativeFragmentationHeader];
EncodedImageCallback::Result res =
- callback->OnEncodedImage(encodedImage, &codecSpecificInfo, fragmentationHeader.get());
+ callback->OnEncodedImage(encodedImage, &codecSpecificInfo);
return res.error == EncodedImageCallback::Result::OK;
}];
@@ -163,13 +160,8 @@ std::vector<SdpVideoFormat> ObjCVideoEncoderFactory::GetImplementations() const
VideoEncoderFactory::CodecInfo ObjCVideoEncoderFactory::QueryVideoEncoder(
const SdpVideoFormat &format) const {
- // TODO(andersc): This is a hack until we figure out how this should be done properly.
- NSString *formatName = [NSString stringForStdString:format.name];
- NSSet *wrappedSoftwareFormats =
- [NSSet setWithObjects:kRTCVideoCodecVp8Name, kRTCVideoCodecVp9Name, nil];
- CodecInfo codec_info;
- codec_info.is_hardware_accelerated = ![wrappedSoftwareFormats containsObject:formatName];
+ VideoEncoderFactory::CodecInfo codec_info;
codec_info.has_internal_source = false;
return codec_info;
}
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/video/rtp_video_stream_receiver.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/video/rtp_video_stream_receiver.cc
index 1b8828be2cee..935a61bf4c4e 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/video/rtp_video_stream_receiver.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/video/rtp_video_stream_receiver.cc
@@ -628,7 +628,24 @@ void RtpVideoStreamReceiver::OnReceivedPayloadData(
packet->video_payload = std::move(fixed.bitstream);
break;
}
-
+#ifndef DISABLE_H265
+ } else if (packet->codec() == kVideoCodecH265) {
+ video_coding::H265VpsSpsPpsTracker::FixedBitstream fixed =
+ h265_tracker_.CopyAndFixBitstream(
+ rtc::MakeArrayView(codec_payload.cdata(), codec_payload.size()),
+ &packet->video_header);
+ switch (fixed.action) {
+ case video_coding::H265VpsSpsPpsTracker::kRequestKeyframe:
+ rtcp_feedback_buffer_.RequestKeyFrame();
+ rtcp_feedback_buffer_.SendBufferedRtcpFeedback();
+ ABSL_FALLTHROUGH_INTENDED;
+ case video_coding::H265VpsSpsPpsTracker::kDrop:
+ return;
+ case video_coding::H265VpsSpsPpsTracker::kInsert:
+ packet->video_payload = std::move(fixed.bitstream);
+ break;
+ }
+#endif
} else {
packet->video_payload = std::move(codec_payload);
}
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/video/rtp_video_stream_receiver.h b/Source/ThirdParty/libwebrtc/Source/webrtc/video/rtp_video_stream_receiver.h
index 40958c48ecfb..67e69962de5c 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/video/rtp_video_stream_receiver.h
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/video/rtp_video_stream_receiver.h
@@ -37,6 +37,9 @@
#include "modules/rtp_rtcp/source/rtp_video_header.h"
#include "modules/rtp_rtcp/source/video_rtp_depacketizer.h"
#include "modules/video_coding/h264_sps_pps_tracker.h"
+#ifndef DISABLE_H265
+#include "modules/video_coding/h265_vps_sps_pps_tracker.h"
+#endif
#include "modules/video_coding/loss_notification_controller.h"
#include "modules/video_coding/packet_buffer.h"
#include "modules/video_coding/rtp_frame_reference_finder.h"
@@ -366,6 +369,10 @@ class RtpVideoStreamReceiver : public LossNotificationSender,
// Maps payload id to the depacketizer.
std::map<uint8_t, std::unique_ptr<VideoRtpDepacketizer>> payload_type_map_;
+#ifndef DISABLE_H265
+ video_coding::H265VpsSpsPpsTracker h265_tracker_;
+#endif
+
// TODO(johan): Remove pt_codec_params_ once
// https://bugs.chromium.org/p/webrtc/issues/detail?id=6883 is resolved.
// Maps a payload type to a map of out-of-band supplied codec parameters.
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/video/rtp_video_stream_receiver2.cc b/Source/ThirdParty/libwebrtc/Source/webrtc/video/rtp_video_stream_receiver2.cc
index f3345597ea2d..281dbde1a2e1 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/video/rtp_video_stream_receiver2.cc
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/video/rtp_video_stream_receiver2.cc
@@ -596,7 +596,24 @@ void RtpVideoStreamReceiver2::OnReceivedPayloadData(
packet->video_payload = std::move(fixed.bitstream);
break;
}
-
+#ifndef DISABLE_H265
+ } else if (packet->codec() == kVideoCodecH265) {
+ video_coding::H265VpsSpsPpsTracker::FixedBitstream fixed =
+ h265_tracker_.CopyAndFixBitstream(
+ rtc::MakeArrayView(codec_payload.cdata(), codec_payload.size()),
+ &packet->video_header);
+ switch (fixed.action) {
+ case video_coding::H265VpsSpsPpsTracker::kRequestKeyframe:
+ rtcp_feedback_buffer_.RequestKeyFrame();
+ rtcp_feedback_buffer_.SendBufferedRtcpFeedback();
+ ABSL_FALLTHROUGH_INTENDED;
+ case video_coding::H265VpsSpsPpsTracker::kDrop:
+ return;
+ case video_coding::H265VpsSpsPpsTracker::kInsert:
+ packet->video_payload = std::move(fixed.bitstream);
+ break;
+ }
+#endif
} else {
packet->video_payload = std::move(codec_payload);
}
diff --git a/Source/ThirdParty/libwebrtc/Source/webrtc/video/rtp_video_stream_receiver2.h b/Source/ThirdParty/libwebrtc/Source/webrtc/video/rtp_video_stream_receiver2.h
index 40e7ef6f1b53..f36293ad44b2 100644
--- a/Source/ThirdParty/libwebrtc/Source/webrtc/video/rtp_video_stream_receiver2.h
+++ b/Source/ThirdParty/libwebrtc/Source/webrtc/video/rtp_video_stream_receiver2.h
@@ -35,6 +35,9 @@
#include "modules/rtp_rtcp/source/rtp_video_header.h"
#include "modules/rtp_rtcp/source/video_rtp_depacketizer.h"
#include "modules/video_coding/h264_sps_pps_tracker.h"
+#ifndef DISABLE_H265
+#include "modules/video_coding/h265_vps_sps_pps_tracker.h"
+#endif
#include "modules/video_coding/loss_notification_controller.h"
#include "modules/video_coding/packet_buffer.h"
#include "modules/video_coding/rtp_frame_reference_finder.h"
@@ -330,6 +333,10 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
std::map<uint8_t, std::unique_ptr<VideoRtpDepacketizer>> payload_type_map_
RTC_GUARDED_BY(worker_task_checker_);
+#ifndef DISABLE_H265
+ video_coding::H265VpsSpsPpsTracker h265_tracker_;
+#endif
+
// TODO(johan): Remove pt_codec_params_ once
// https://bugs.chromium.org/p/webrtc/issues/detail?id=6883 is resolved.
// Maps a payload type to a map of out-of-band supplied codec parameters.