zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove media/base/h264_profile_level_id.* and media/base/vp9_profile.h

Browse Source 
The content of these files was moved to api/video_codecs in
https://webrtc.googlesource.com/src.git/+/c3fcee7c3a7714afc3e37d4753b40f4fdbc3653e
but the original files could not be removed due to dependencies
in downstream projects.

Bug: chromium:1187565
Change-Id: I414efa22102bfdea0765fa72a8cf8b0bd5c090db
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/229303
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Commit-Queue: Johannes Kron <kron@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#34869}
This commit is contained in:
Johannes Kron
2021-08-19 12:13:06 +02:00
committed by WebRTC LUCI CQ
parent 9ad972d4fb
commit 3cd7a0ffdd
15 changed files with 25 additions and 296 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
api/BUILD.gn
View File

@ -802,7 +802,6 @@ if (rtc_include_tests) {
"test/videocodec_test_stats.h",
]
deps = [
"../media:rtc_h264_profile_id",
"../modules/video_coding:video_codec_interface",
"../rtc_base:stringutils",
"video:video_frame_type",

2
api/test/videocodec_test_fixture.h
View File

@ -15,9 +15,9 @@
#include <vector>
#include "api/test/videocodec_test_stats.h"
#include "api/video_codecs/h264_profile_level_id.h"
#include "api/video_codecs/video_decoder_factory.h"
#include "api/video_codecs/video_encoder_factory.h"
#include "media/base/h264_profile_level_id.h"
#include "modules/video_coding/include/video_codec_interface.h"
namespace webrtc {

1
api/video_codecs/test/BUILD.gn
View File

@ -26,6 +26,7 @@ if (rtc_include_tests) {
"../..:fec_controller_api",
"../..:mock_video_encoder",
"../../../api:scoped_refptr",
"../../../media:rtc_media_base",
"../../../modules/video_coding:video_codec_interface",
"../../../modules/video_coding:video_coding_utility",
"../../../modules/video_coding:webrtc_vp8",

15
api/video_codecs/test/sdp_video_format_unittest.cc
View File

@ -12,6 +12,7 @@
#include <stdint.h>
#include "media/base/media_constants.h"
#include "test/gtest.h"
namespace webrtc {
@ -25,11 +26,13 @@ TEST(SdpVideoFormatTest, SameCodecNameNoParameters) {
EXPECT_TRUE(Sdp("Vp9").IsSameCodec(Sdp("vp9")));
EXPECT_TRUE(Sdp("AV1").IsSameCodec(Sdp("Av1")));
}
TEST(SdpVideoFormatTest, DifferentCodecNameNoParameters) {
EXPECT_FALSE(Sdp("H264").IsSameCodec(Sdp("VP8")));
EXPECT_FALSE(Sdp("VP8").IsSameCodec(Sdp("VP9")));
EXPECT_FALSE(Sdp("AV1").IsSameCodec(Sdp("")));
}
TEST(SdpVideoFormatTest, SameCodecNameSameParameters) {
EXPECT_TRUE(Sdp("VP9").IsSameCodec(Sdp("VP9", Params{{"profile-id", "0"}})));
EXPECT_TRUE(Sdp("VP9", Params{{"profile-id", "0"}})
@ -71,4 +74,16 @@ TEST(SdpVideoFormatTest, DifferentCodecNameSameParameters) {
.IsSameCodec(Sdp("VP8", Params{{"profile-level-id", "640c34"}})));
}
TEST(SdpVideoFormatTest, H264PacketizationMode) {
// The default packetization mode is 0.
EXPECT_TRUE(Sdp("H264", Params{{cricket::kH264FmtpPacketizationMode, "0"}})
.IsSameCodec(Sdp("H264")));
EXPECT_FALSE(Sdp("H264", Params{{cricket::kH264FmtpPacketizationMode, "1"}})
.IsSameCodec(Sdp("H264")));
EXPECT_TRUE(
Sdp("H264", Params{{cricket::kH264FmtpPacketizationMode, "1"}})
.IsSameCodec(
Sdp("H264", Params{{cricket::kH264FmtpPacketizationMode, "1"}})));
}
} // namespace webrtc

19
media/BUILD.gn
View File

@ -23,30 +23,11 @@ config("rtc_media_defines_config") {
defines = [ "HAVE_WEBRTC_VIDEO" ]
}
# Remove once downstream projects stop depend on this.
rtc_source_set("rtc_h264_profile_id") {
visibility = [ "*" ]
sources = [
"base/h264_profile_level_id.cc",
"base/h264_profile_level_id.h",
]
public_deps = # no-presubmit-check TODO(webrtc:8603)
[ "../api/video_codecs:video_codecs_api" ]
}
rtc_source_set("rtc_media_config") {
visibility = [ "*" ]
sources = [ "base/media_config.h" ]
}
# Remove once downstream projects stop depend on this.
rtc_source_set("rtc_vp9_profile") {
visibility = [ "*" ]
sources = [ "base/vp9_profile.h" ]
public_deps = # no-presubmit-check TODO(webrtc:8603)
[ "../api/video_codecs:video_codecs_api" ]
}
rtc_library("rtc_sdp_video_format_utils") {
visibility = [ "*" ]
sources = [

17
media/base/codec.cc
View File

@ -412,27 +412,16 @@ bool HasTransportCc(const Codec& codec) {
const VideoCodec* FindMatchingCodec(
const std::vector<VideoCodec>& supported_codecs,
const VideoCodec& codec) {
webrtc::SdpVideoFormat sdp_video_format{codec.name, codec.params};
for (const VideoCodec& supported_codec : supported_codecs) {
if (IsSameCodec(codec.name, codec.params, supported_codec.name,
supported_codec.params)) {
if (sdp_video_format.IsSameCodec(
{supported_codec.name, supported_codec.params})) {
return &supported_codec;
}
}
return nullptr;
}
// TODO(crbug.com/1187565): Remove once downstream projects stopped using this
// method in favor of SdpVideoFormat::IsSameCodec().
bool IsSameCodec(const std::string& name1,
const CodecParameterMap& params1,
const std::string& name2,
const CodecParameterMap& params2) {
// Two codecs are considered the same if the name matches (case insensitive)
// and certain codec-specific parameters match.
return absl::EqualsIgnoreCase(name1, name2) &&
IsSameCodecSpecific(name1, params1, name2, params2);
}
// If a decoder supports any H264 profile, it is implicitly assumed to also
// support constrained base line even though it's not explicitly listed.
void AddH264ConstrainedBaselineProfileToSupportedFormats(

4
media/base/codec.h
View File

@ -223,10 +223,6 @@ bool HasTransportCc(const Codec& codec);
const VideoCodec* FindMatchingCodec(
const std::vector<VideoCodec>& supported_codecs,
const VideoCodec& codec);
RTC_EXPORT bool IsSameCodec(const std::string& name1,
const CodecParameterMap& params1,
const std::string& name2,
const CodecParameterMap& params2);
RTC_EXPORT void AddH264ConstrainedBaselineProfileToSupportedFormats(
std::vector<webrtc::SdpVideoFormat>* supported_formats);

91
media/base/codec_unittest.cc
View File

@ -496,94 +496,3 @@ TEST(CodecTest, H264CostrainedBaselineNotAddedIfAlreadySpecified) {
EXPECT_EQ(supported_formats[3], kExplicitlySupportedFormats[3]);
EXPECT_EQ(supported_formats.size(), kExplicitlySupportedFormats.size());
}
// Tests that the helper IsSameCodec returns the correct value for codecs that
// must also be matched on particular parameter values.
using IsSameCodecParamsTestCase =
std::tuple<cricket::CodecParameterMap, cricket::CodecParameterMap>;
class IsSameCodecParamsTest
: public ::testing::TestWithParam<
std::tuple<std::string, bool, IsSameCodecParamsTestCase>> {
protected:
IsSameCodecParamsTest() {
name_ = std::get<0>(GetParam());
expected_ = std::get<1>(GetParam());
const auto& test_case = std::get<2>(GetParam());
params_left_ = std::get<0>(test_case);
params_right_ = std::get<1>(test_case);
}
std::string name_;
bool expected_;
cricket::CodecParameterMap params_left_;
cricket::CodecParameterMap params_right_;
};
TEST_P(IsSameCodecParamsTest, Expected) {
EXPECT_EQ(expected_,
cricket::IsSameCodec(name_, params_left_, name_, params_right_));
}
TEST_P(IsSameCodecParamsTest, Commutative) {
EXPECT_EQ(expected_,
cricket::IsSameCodec(name_, params_right_, name_, params_left_));
}
IsSameCodecParamsTestCase MakeTestCase(cricket::CodecParameterMap left,
cricket::CodecParameterMap right) {
return std::make_tuple(left, right);
}
const IsSameCodecParamsTestCase kH264ParamsSameTestCases[] = {
// Both have the same defaults.
MakeTestCase({}, {}),
// packetization-mode: 0 is the default.
MakeTestCase({{cricket::kH264FmtpPacketizationMode, "0"}}, {}),
// Non-default packetization-mode matches.
MakeTestCase({{cricket::kH264FmtpPacketizationMode, "1"}},
{{cricket::kH264FmtpPacketizationMode, "1"}}),
};
INSTANTIATE_TEST_SUITE_P(
H264_Same,
IsSameCodecParamsTest,
::testing::Combine(::testing::Values("H264"),
::testing::Values(true),
::testing::ValuesIn(kH264ParamsSameTestCases)));
const IsSameCodecParamsTestCase kH264ParamsNotSameTestCases[] = {
// packetization-mode does not match the default of "0".
MakeTestCase({{cricket::kH264FmtpPacketizationMode, "1"}}, {}),
};
INSTANTIATE_TEST_SUITE_P(
H264_NotSame,
IsSameCodecParamsTest,
::testing::Combine(::testing::Values("H264"),
::testing::Values(false),
::testing::ValuesIn(kH264ParamsNotSameTestCases)));
const IsSameCodecParamsTestCase kVP9ParamsSameTestCases[] = {
// Both have the same defaults.
MakeTestCase({}, {}),
// profile-id: 0 is the default.
MakeTestCase({{webrtc::kVP9FmtpProfileId, "0"}}, {}),
// Non-default profile-id matches.
MakeTestCase({{webrtc::kVP9FmtpProfileId, "2"}},
{{webrtc::kVP9FmtpProfileId, "2"}}),
};
INSTANTIATE_TEST_SUITE_P(
VP9_Same,
IsSameCodecParamsTest,
::testing::Combine(::testing::Values("VP9"),
::testing::Values(true),
::testing::ValuesIn(kVP9ParamsSameTestCases)));
const IsSameCodecParamsTestCase kVP9ParamsNotSameTestCases[] = {
// profile-id missing from right.
MakeTestCase({{webrtc::kVP9FmtpProfileId, "2"}}, {}),
};
INSTANTIATE_TEST_SUITE_P(
VP9_NotSame,
IsSameCodecParamsTest,
::testing::Combine(::testing::Values("VP9"),
::testing::Values(false),
::testing::ValuesIn(kVP9ParamsNotSameTestCases)));

43
media/base/h264_profile_level_id.cc
View File

@ -1,43 +0,0 @@
/*
* Copyright (c) 2017 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 "media/base/h264_profile_level_id.h"
// TODO(crbug.com/1187565): Remove this file once downstream projects stop
// depend on it.
namespace webrtc {
namespace H264 {
absl::optional<ProfileLevelId> ParseProfileLevelId(const char* str) {
return webrtc::ParseH264ProfileLevelId(str);
}
absl::optional<ProfileLevelId> ParseSdpProfileLevelId(
const SdpVideoFormat::Parameters& params) {
return webrtc::ParseSdpForH264ProfileLevelId(params);
}
absl::optional<Level> SupportedLevel(int max_frame_pixel_count, float max_fps) {
return webrtc::H264SupportedLevel(max_frame_pixel_count, max_fps);
}
absl::optional<std::string> ProfileLevelIdToString(
const ProfileLevelId& profile_level_id) {
return webrtc::H264ProfileLevelIdToString(profile_level_id);
}
bool IsSameH264Profile(const SdpVideoFormat::Parameters& params1,
const SdpVideoFormat::Parameters& params2) {
return webrtc::H264IsSameProfile(params1, params2);
}
} // namespace H264
} // namespace webrtc

85
media/base/h264_profile_level_id.h
View File

@ -1,85 +0,0 @@
/*
* Copyright (c) 2017 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 MEDIA_BASE_H264_PROFILE_LEVEL_ID_H_
#define MEDIA_BASE_H264_PROFILE_LEVEL_ID_H_
#include <string>
#include "api/video_codecs/h264_profile_level_id.h"
// TODO(crbug.com/1187565): Remove this file once downstream projects stop
// depend on it.
namespace webrtc {
namespace H264 {
typedef H264Profile Profile;
typedef H264Level Level;
typedef H264ProfileLevelId ProfileLevelId;
constexpr H264Profile kProfileConstrainedBaseline =
H264Profile::kProfileConstrainedBaseline;
constexpr H264Profile kProfileBaseline = H264Profile::kProfileBaseline;
constexpr H264Profile kProfileMain = H264Profile::kProfileMain;
constexpr H264Profile kProfileConstrainedHigh =
H264Profile::kProfileConstrainedHigh;
constexpr H264Profile kProfileHigh = H264Profile::kProfileHigh;
constexpr H264Level kLevel1_b = H264Level::kLevel1_b;
constexpr H264Level kLevel1 = H264Level::kLevel1;
constexpr H264Level kLevel1_1 = H264Level::kLevel1_1;
constexpr H264Level kLevel1_2 = H264Level::kLevel1_2;
constexpr H264Level kLevel1_3 = H264Level::kLevel1_3;
constexpr H264Level kLevel2 = H264Level::kLevel2;
constexpr H264Level kLevel2_1 = H264Level::kLevel2_1;
constexpr H264Level kLevel2_2 = H264Level::kLevel2_2;
constexpr H264Level kLevel3 = H264Level::kLevel3;
constexpr H264Level kLevel3_1 = H264Level::kLevel3_1;
constexpr H264Level kLevel3_2 = H264Level::kLevel3_2;
constexpr H264Level kLevel4 = H264Level::kLevel4;
constexpr H264Level kLevel4_1 = H264Level::kLevel4_1;
constexpr H264Level kLevel4_2 = H264Level::kLevel4_2;
constexpr H264Level kLevel5 = H264Level::kLevel5;
constexpr H264Level kLevel5_1 = H264Level::kLevel5_1;
constexpr H264Level kLevel5_2 = H264Level::kLevel5_2;
// Parse profile level id that is represented as a string of 3 hex bytes.
// Nothing will be returned if the string is not a recognized H264
// profile level id.
absl::optional<ProfileLevelId> ParseProfileLevelId(const char* str);
// Parse profile level id that is represented as a string of 3 hex bytes
// contained in an SDP key-value map. A default profile level id will be
// returned if the profile-level-id key is missing. Nothing will be returned if
// the key is present but the string is invalid.
RTC_EXPORT absl::optional<ProfileLevelId> ParseSdpProfileLevelId(
const SdpVideoFormat::Parameters& params);
// Given that a decoder supports up to a given frame size (in pixels) at up to a
// given number of frames per second, return the highest H.264 level where it
// can guarantee that it will be able to support all valid encoded streams that
// are within that level.
RTC_EXPORT absl::optional<Level> SupportedLevel(int max_frame_pixel_count,
float max_fps);
// Returns canonical string representation as three hex bytes of the profile
// level id, or returns nothing for invalid profile level ids.
RTC_EXPORT absl::optional<std::string> ProfileLevelIdToString(
const ProfileLevelId& profile_level_id);
// Returns true if the parameters have the same H264 profile, i.e. the same
// H264::Profile (Baseline, High, etc).
RTC_EXPORT bool IsSameH264Profile(const SdpVideoFormat::Parameters& params1,
const SdpVideoFormat::Parameters& params2);
} // namespace H264
} // namespace webrtc
#endif // MEDIA_BASE_H264_PROFILE_LEVEL_ID_H_

19
media/base/vp9_profile.h
View File

@ -1,19 +0,0 @@
/*
* 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 MEDIA_BASE_VP9_PROFILE_H_
#define MEDIA_BASE_VP9_PROFILE_H_
#include "api/video_codecs/vp9_profile.h"
// TODO(crbug.com/1187565): Remove this file once downstream projects stop
// depend on it.
#endif // MEDIA_BASE_VP9_PROFILE_H_

20
media/engine/fake_webrtc_video_engine.cc
View File

@ -26,18 +26,6 @@ namespace {
static const int kEventTimeoutMs = 10000;
bool IsFormatSupported(
const std::vector<webrtc::SdpVideoFormat>& supported_formats,
const webrtc::SdpVideoFormat& format) {
for (const webrtc::SdpVideoFormat& supported_format : supported_formats) {
if (IsSameCodec(format.name, format.parameters, supported_format.name,
supported_format.parameters)) {
return true;
}
}
return false;
}
} // namespace
// Decoder.
@ -85,7 +73,7 @@ FakeWebRtcVideoDecoderFactory::GetSupportedFormats() const {
for (const webrtc::SdpVideoFormat& format : supported_codec_formats_) {
// Don't add same codec twice.
if (!IsFormatSupported(formats, format))
if (!format.IsCodecInList(formats))
formats.push_back(format);
}
@ -95,7 +83,7 @@ FakeWebRtcVideoDecoderFactory::GetSupportedFormats() const {
std::unique_ptr<webrtc::VideoDecoder>
FakeWebRtcVideoDecoderFactory::CreateVideoDecoder(
const webrtc::SdpVideoFormat& format) {
if (IsFormatSupported(supported_codec_formats_, format)) {
if (format.IsCodecInList(supported_codec_formats_)) {
num_created_decoders_++;
std::unique_ptr<FakeWebRtcVideoDecoder> decoder =
std::make_unique<FakeWebRtcVideoDecoder>(this);
@ -209,7 +197,7 @@ FakeWebRtcVideoEncoderFactory::GetSupportedFormats() const {
for (const webrtc::SdpVideoFormat& format : formats_) {
// Don't add same codec twice.
if (!IsFormatSupported(formats, format))
if (!format.IsCodecInList(formats))
formats.push_back(format);
}
@ -221,7 +209,7 @@ FakeWebRtcVideoEncoderFactory::CreateVideoEncoder(
const webrtc::SdpVideoFormat& format) {
webrtc::MutexLock lock(&mutex_);
std::unique_ptr<webrtc::VideoEncoder> encoder;
if (IsFormatSupported(formats_, format)) {
if (format.IsCodecInList(formats_)) {
if (absl::EqualsIgnoreCase(format.name, kVp8CodecName) &&
!vp8_factory_mode_) {
// The simulcast adapter will ask this factory for multiple VP8

1
modules/video_coding/BUILD.gn
View File

@ -401,7 +401,6 @@ rtc_library("webrtc_h264") {
"../../api/video:video_rtp_headers",
"../../api/video_codecs:video_codecs_api",
"../../common_video",
"../../media:rtc_h264_profile_id",
"../../media:rtc_media_base",
"../../rtc_base",
"../../rtc_base:checks",

2
modules/video_coding/codecs/h264/include/h264.h
View File

@ -16,8 +16,8 @@
#include <string>
#include <vector>
#include "api/video_codecs/h264_profile_level_id.h"
#include "media/base/codec.h"
#include "media/base/h264_profile_level_id.h"
#include "modules/video_coding/include/video_codec_interface.h"
#include "rtc_base/system/rtc_export.h"

1
sdk/BUILD.gn
View File

@ -638,7 +638,6 @@ if (is_ios || is_mac) {
":helpers_objc",
"../api/video_codecs:video_codecs_api",
"../common_video",
"../media:rtc_h264_profile_id",
"../media:rtc_media_base",
"../modules/video_coding:video_codec_interface",
"../rtc_base:checks",