/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef CODEC_CONFIG_H_
#define CODEC_CONFIG_H_
#include <string>
#include <vector>
#include "common/EncodingConstraints.h"
#include "jsep/JsepCodecDescription.h"
namespace mozilla {
/**
* Minimalistic Audio Codec Config Params
*/
struct AudioCodecConfig {
/*
* The data-types for these properties mimic the
* corresponding webrtc::CodecInst data-types.
*/
int mType;
std::string mName;
int mFreq;
int mChannels;
bool mFECEnabled;
bool mDtmfEnabled;
uint32_t mFrameSizeMs;
uint32_t mMaxFrameSizeMs;
uint32_t mMinFrameSizeMs;
// OPUS-specific
bool mDTXEnabled;
uint32_t mMaxAverageBitrate;
int mMaxPlaybackRate;
bool mCbrEnabled;
AudioCodecConfig(
int type, std::string name,
int freq,
int channels,
bool FECEnabled)
: mType(type),
mName(name),
mFreq(freq),
mChannels(channels),
mFECEnabled(FECEnabled),
mDtmfEnabled(
false),
mFrameSizeMs(0),
mMaxFrameSizeMs(0),
mMinFrameSizeMs(0),
mDTXEnabled(
false),
mMaxAverageBitrate(0),
mMaxPlaybackRate(0),
mCbrEnabled(
false) {}
bool operator==(
const AudioCodecConfig& aOther)
const {
return mType == aOther.mType && mName == aOther.mName &&
mFreq == aOther.mFreq && mChannels == aOther.mChannels &&
mFECEnabled == aOther.mFECEnabled &&
mDtmfEnabled == aOther.mDtmfEnabled &&
mFrameSizeMs == aOther.mFrameSizeMs &&
mMaxFrameSizeMs == aOther.mMaxFrameSizeMs &&
mMinFrameSizeMs == aOther.mMinFrameSizeMs &&
mDTXEnabled == aOther.mDTXEnabled &&
mMaxAverageBitrate == aOther.mMaxAverageBitrate &&
mMaxPlaybackRate == aOther.mMaxPlaybackRate &&
mCbrEnabled == aOther.mCbrEnabled;
}
};
/*
* Minimalistic video codec configuration
* More to be added later depending on the use-case
*/
#define MAX_SPROP_LEN 128
// used for holding SDP negotiation results
struct VideoCodecConfigH264 {
char sprop_parameter_sets[MAX_SPROP_LEN];
int packetization_mode;
int profile_level_id;
int tias_bw;
bool operator==(
const VideoCodecConfigH264& aOther)
const {
return strncmp(sprop_parameter_sets, aOther.sprop_parameter_sets,
MAX_SPROP_LEN) == 0 &&
packetization_mode == aOther.packetization_mode &&
profile_level_id == aOther.profile_level_id &&
tias_bw == aOther.tias_bw;
}
};
// class so the std::strings can get freed more easily/reliably
class VideoCodecConfig {
public:
/*
* The data-types for these properties mimic the
* corresponding webrtc::VideoCodec data-types.
*/
int mType;
// payload type
std::string mName;
std::vector<std::string> mAckFbTypes;
std::vector<std::string> mNackFbTypes;
std::vector<std::string> mCcmFbTypes;
// Don't pass mOtherFbTypes from JsepVideoCodecDescription because we'd have
// to drag SdpRtcpFbAttributeList::Feedback along too.
bool mRembFbSet =
false;
bool mFECFbSet =
false;
bool mTransportCCFbSet =
false;
// TODO Bug 1920249 maybe types for these?
int mULPFECPayloadType = -1;
int mREDPayloadType = -1;
int mREDRTXPayloadType = -1;
int mRTXPayloadType = -1;
uint32_t mTias = 0;
EncodingConstraints mEncodingConstraints;
struct Encoding {
std::string rid;
EncodingConstraints constraints;
bool active =
true;
// TODO(bug 1744116): Use = default here
bool operator==(
const Encoding& aOther)
const {
return rid == aOther.rid && constraints == aOther.constraints &&
active == aOther.active;
}
};
std::vector<Encoding> mEncodings;
std::string mSpropParameterSets;
// Bug 1920249 stick these in a struct
uint8_t mProfile = 0x42;
uint8_t mConstraints = 0xE0;
uint8_t mLevel = 0x0C;
uint8_t mPacketizationMode = 1;
// Bug 1920249 have the codec-specific stuff in a std::variant or something
Maybe<JsepVideoCodecDescription::Av1Config> mAv1Config;
// TODO: add external negotiated SPS/PPS
// TODO(bug 1744116): Use = default here
bool operator==(
const VideoCodecConfig& aRhs)
const {
return mType == aRhs.mType && mName == aRhs.mName &&
mAckFbTypes == aRhs.mAckFbTypes &&
mNackFbTypes == aRhs.mNackFbTypes &&
mCcmFbTypes == aRhs.mCcmFbTypes && mRembFbSet == aRhs.mRembFbSet &&
mFECFbSet == aRhs.mFECFbSet &&
mTransportCCFbSet == aRhs.mTransportCCFbSet &&
mULPFECPayloadType == aRhs.mULPFECPayloadType &&
mREDPayloadType == aRhs.mREDPayloadType &&
mREDRTXPayloadType == aRhs.mREDRTXPayloadType &&
mRTXPayloadType == aRhs.mRTXPayloadType && mTias == aRhs.mTias &&
mEncodingConstraints == aRhs.mEncodingConstraints &&
mEncodings == aRhs.mEncodings &&
mSpropParameterSets == aRhs.mSpropParameterSets &&
mProfile == aRhs.mProfile && mConstraints == aRhs.mConstraints &&
mLevel == aRhs.mLevel &&
mPacketizationMode == aRhs.mPacketizationMode &&
mAv1Config == aRhs.mAv1Config;
}
static VideoCodecConfig CreateAv1Config(
int pt,
const EncodingConstraints& constraints,
const JsepVideoCodecDescription::Av1Config& av1) {
VideoCodecConfig config(pt,
"AV1", constraints);
config.mAv1Config = Some(av1);
return config;
}
static auto CreateH264Config(
int pt,
const EncodingConstraints& constraints,
const VideoCodecConfigH264& h264)
-> VideoCodecConfig {
VideoCodecConfig config(pt,
"H264", constraints);
// Bug 1920249 don't store these computed values which are used 1 time.
config.mProfile = (h264.profile_level_id & 0x00FF0000) >> 16;
config.mConstraints = (h264.profile_level_id & 0x0000FF00) >> 8;
config.mLevel = (h264.profile_level_id & 0x000000FF);
config.mPacketizationMode = h264.packetization_mode;
config.mSpropParameterSets = h264.sprop_parameter_sets;
return config;
}
VideoCodecConfig(
int type, std::string name,
const EncodingConstraints& constraints)
: mType(type),
mName(std::move(name)),
mEncodingConstraints(constraints) {}
bool ResolutionEquals(
const VideoCodecConfig& aConfig)
const {
if (mEncodings.size() != aConfig.mEncodings.size()) {
return false;
}
for (size_t i = 0; i < mEncodings.size(); ++i) {
if (!mEncodings[i].constraints.ResolutionEquals(
aConfig.mEncodings[i].constraints)) {
return false;
}
}
return true;
}
// Nothing seems to use this right now. Do we intend to support this
// someday?
bool RtcpFbAckIsSet(
const std::string& type)
const {
for (
auto i = mAckFbTypes.begin(); i != mAckFbTypes.end(); ++i) {
if (*i == type) {
return true;
}
}
return false;
}
bool RtcpFbNackIsSet(
const std::string& type)
const {
for (
auto i = mNackFbTypes.begin(); i != mNackFbTypes.end(); ++i) {
if (*i == type) {
return true;
}
}
return false;
}
bool RtcpFbCcmIsSet(
const std::string& type)
const {
for (
auto i = mCcmFbTypes.begin(); i != mCcmFbTypes.end(); ++i) {
if (*i == type) {
return true;
}
}
return false;
}
bool RtcpFbRembIsSet()
const {
return mRembFbSet; }
bool RtcpFbFECIsSet()
const {
return mFECFbSet; }
bool RtcpFbTransportCCIsSet()
const {
return mTransportCCFbSet; }
bool RtxPayloadTypeIsSet()
const {
return mRTXPayloadType != -1; }
};
}
// namespace mozilla
#endif
