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

Audio codec implementations: Take optional codec ID argument

Browse Source 
None of the built-in codecs do anything with the ID, but callers will
soon require them to accept it.

Bug: webrtc:8941
Change-Id: I0eb77db82d72c7d34cff639fecb67c1e6ec421bf
Reviewed-on: https://webrtc-review.googlesource.com/58089
Commit-Queue: Karl Wiberg <kwiberg@webrtc.org>
Reviewed-by: Oskar Sundbom <ossu@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#22259}
This commit is contained in:
Karl Wiberg
2018-03-01 15:13:27 +01:00
committed by Commit Bot
parent cb415b2a84
commit 17668ec4a5
33 changed files with 110 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
api/audio_codecs/L16/audio_decoder_L16.cc
View File

@ -34,7 +34,8 @@ void AudioDecoderL16::AppendSupportedDecoders(
} }
std::unique_ptr<AudioDecoder> AudioDecoderL16::MakeAudioDecoder( std::unique_ptr<AudioDecoder> AudioDecoderL16::MakeAudioDecoder(
const Config& config) { const Config& config,
rtc::Optional<AudioCodecPairId> /*codec_pair_id*/) {
return config.IsOk() ? rtc::MakeUnique<AudioDecoderPcm16B>( return config.IsOk() ? rtc::MakeUnique<AudioDecoderPcm16B>(
config.sample_rate_hz, config.num_channels) config.sample_rate_hz, config.num_channels)
: nullptr; : nullptr;

5
api/audio_codecs/L16/audio_decoder_L16.h
View File

@ -14,6 +14,7 @@
#include <memory> #include <memory>
#include <vector> #include <vector>
#include "api/audio_codecs/audio_codec_pair_id.h"
#include "api/audio_codecs/audio_decoder.h" #include "api/audio_codecs/audio_decoder.h"
#include "api/audio_codecs/audio_format.h" #include "api/audio_codecs/audio_format.h"
#include "api/optional.h" #include "api/optional.h"
@ -36,7 +37,9 @@ struct AudioDecoderL16 {
}; };
static rtc::Optional<Config> SdpToConfig(const SdpAudioFormat& audio_format); static rtc::Optional<Config> SdpToConfig(const SdpAudioFormat& audio_format);
static void AppendSupportedDecoders(std::vector<AudioCodecSpec>* specs); static void AppendSupportedDecoders(std::vector<AudioCodecSpec>* specs);
static std::unique_ptr<AudioDecoder> MakeAudioDecoder(const Config& config); static std::unique_ptr<AudioDecoder> MakeAudioDecoder(
const Config& config,
rtc::Optional<AudioCodecPairId> codec_pair_id = rtc::nullopt);
}; };
} // namespace webrtc } // namespace webrtc

3
api/audio_codecs/L16/audio_encoder_L16.cc
View File

@ -46,7 +46,8 @@ AudioCodecInfo AudioEncoderL16::QueryAudioEncoder(
std::unique_ptr<AudioEncoder> AudioEncoderL16::MakeAudioEncoder( std::unique_ptr<AudioEncoder> AudioEncoderL16::MakeAudioEncoder(
const AudioEncoderL16::Config& config, const AudioEncoderL16::Config& config,
int payload_type) { int payload_type,
rtc::Optional<AudioCodecPairId> /*codec_pair_id*/) {
RTC_DCHECK(config.IsOk()); RTC_DCHECK(config.IsOk());
AudioEncoderPcm16B::Config c; AudioEncoderPcm16B::Config c;
c.sample_rate_hz = config.sample_rate_hz; c.sample_rate_hz = config.sample_rate_hz;

7
api/audio_codecs/L16/audio_encoder_L16.h
View File

@ -14,6 +14,7 @@
#include <memory> #include <memory>
#include <vector> #include <vector>
#include "api/audio_codecs/audio_codec_pair_id.h"
#include "api/audio_codecs/audio_encoder.h" #include "api/audio_codecs/audio_encoder.h"
#include "api/audio_codecs/audio_format.h" #include "api/audio_codecs/audio_format.h"
#include "api/optional.h" #include "api/optional.h"
@ -39,8 +40,10 @@ struct AudioEncoderL16 {
static rtc::Optional<Config> SdpToConfig(const SdpAudioFormat& audio_format); static rtc::Optional<Config> SdpToConfig(const SdpAudioFormat& audio_format);
static void AppendSupportedEncoders(std::vector<AudioCodecSpec>* specs); static void AppendSupportedEncoders(std::vector<AudioCodecSpec>* specs);
static AudioCodecInfo QueryAudioEncoder(const Config& config); static AudioCodecInfo QueryAudioEncoder(const Config& config);
static std::unique_ptr<AudioEncoder> MakeAudioEncoder(const Config& config, static std::unique_ptr<AudioEncoder> MakeAudioEncoder(
int payload_type); const Config& config,
int payload_type,
rtc::Optional<AudioCodecPairId> codec_pair_id = rtc::nullopt);
}; };
} // namespace webrtc } // namespace webrtc

6
api/audio_codecs/builtin_audio_decoder_factory.cc
View File

@ -39,8 +39,10 @@ struct NotAdvertised {
static void AppendSupportedDecoders(std::vector<AudioCodecSpec>* specs) { static void AppendSupportedDecoders(std::vector<AudioCodecSpec>* specs) {
// Don't advertise support for anything. // Don't advertise support for anything.
} }
static std::unique_ptr<AudioDecoder> MakeAudioDecoder(const Config& config) { static std::unique_ptr<AudioDecoder> MakeAudioDecoder(
return T::MakeAudioDecoder(config); const Config& config,
rtc::Optional<AudioCodecPairId> codec_pair_id = rtc::nullopt) {
return T::MakeAudioDecoder(config, codec_pair_id);
} }
}; };

8
api/audio_codecs/builtin_audio_encoder_factory.cc
View File

@ -42,9 +42,11 @@ struct NotAdvertised {
static AudioCodecInfo QueryAudioEncoder(const Config& config) { static AudioCodecInfo QueryAudioEncoder(const Config& config) {
return T::QueryAudioEncoder(config); return T::QueryAudioEncoder(config);
} }
static std::unique_ptr<AudioEncoder> MakeAudioEncoder(const Config& config, static std::unique_ptr<AudioEncoder> MakeAudioEncoder(
int payload_type) { const Config& config,
return T::MakeAudioEncoder(config, payload_type); int payload_type,
rtc::Optional<AudioCodecPairId> codec_pair_id = rtc::nullopt) {
return T::MakeAudioEncoder(config, payload_type, codec_pair_id);
} }
}; };

3
api/audio_codecs/g711/audio_decoder_g711.cc
View File

@ -44,7 +44,8 @@ void AudioDecoderG711::AppendSupportedDecoders(
} }
std::unique_ptr<AudioDecoder> AudioDecoderG711::MakeAudioDecoder( std::unique_ptr<AudioDecoder> AudioDecoderG711::MakeAudioDecoder(
const Config& config) { const Config& config,
rtc::Optional<AudioCodecPairId> /*codec_pair_id*/) {
RTC_DCHECK(config.IsOk()); RTC_DCHECK(config.IsOk());
switch (config.type) { switch (config.type) {
case Config::Type::kPcmU: case Config::Type::kPcmU:

5
api/audio_codecs/g711/audio_decoder_g711.h
View File

@ -14,6 +14,7 @@
#include <memory> #include <memory>
#include <vector> #include <vector>
#include "api/audio_codecs/audio_codec_pair_id.h"
#include "api/audio_codecs/audio_decoder.h" #include "api/audio_codecs/audio_decoder.h"
#include "api/audio_codecs/audio_format.h" #include "api/audio_codecs/audio_format.h"
#include "api/optional.h" #include "api/optional.h"
@ -35,7 +36,9 @@ struct AudioDecoderG711 {
}; };
static rtc::Optional<Config> SdpToConfig(const SdpAudioFormat& audio_format); static rtc::Optional<Config> SdpToConfig(const SdpAudioFormat& audio_format);
static void AppendSupportedDecoders(std::vector<AudioCodecSpec>* specs); static void AppendSupportedDecoders(std::vector<AudioCodecSpec>* specs);
static std::unique_ptr<AudioDecoder> MakeAudioDecoder(const Config& config); static std::unique_ptr<AudioDecoder> MakeAudioDecoder(
const Config& config,
rtc::Optional<AudioCodecPairId> codec_pair_id = rtc::nullopt);
}; };
} // namespace webrtc } // namespace webrtc

3
api/audio_codecs/g711/audio_encoder_g711.cc
View File

@ -61,7 +61,8 @@ AudioCodecInfo AudioEncoderG711::QueryAudioEncoder(const Config& config) {
std::unique_ptr<AudioEncoder> AudioEncoderG711::MakeAudioEncoder( std::unique_ptr<AudioEncoder> AudioEncoderG711::MakeAudioEncoder(
const Config& config, const Config& config,
int payload_type) { int payload_type,
rtc::Optional<AudioCodecPairId> /*codec_pair_id*/) {
RTC_DCHECK(config.IsOk()); RTC_DCHECK(config.IsOk());
switch (config.type) { switch (config.type) {
case Config::Type::kPcmU: { case Config::Type::kPcmU: {

7
api/audio_codecs/g711/audio_encoder_g711.h
View File

@ -14,6 +14,7 @@
#include <memory> #include <memory>
#include <vector> #include <vector>
#include "api/audio_codecs/audio_codec_pair_id.h"
#include "api/audio_codecs/audio_encoder.h" #include "api/audio_codecs/audio_encoder.h"
#include "api/audio_codecs/audio_format.h" #include "api/audio_codecs/audio_format.h"
#include "api/optional.h" #include "api/optional.h"
@ -39,8 +40,10 @@ struct AudioEncoderG711 {
const SdpAudioFormat& audio_format); const SdpAudioFormat& audio_format);
static void AppendSupportedEncoders(std::vector<AudioCodecSpec>* specs); static void AppendSupportedEncoders(std::vector<AudioCodecSpec>* specs);
static AudioCodecInfo QueryAudioEncoder(const Config& config); static AudioCodecInfo QueryAudioEncoder(const Config& config);
static std::unique_ptr<AudioEncoder> MakeAudioEncoder(const Config& config, static std::unique_ptr<AudioEncoder> MakeAudioEncoder(
int payload_type); const Config& config,
int payload_type,
rtc::Optional<AudioCodecPairId> codec_pair_id = rtc::nullopt);
}; };
} // namespace webrtc } // namespace webrtc

3
api/audio_codecs/g722/audio_decoder_g722.cc
View File

@ -36,7 +36,8 @@ void AudioDecoderG722::AppendSupportedDecoders(
} }
std::unique_ptr<AudioDecoder> AudioDecoderG722::MakeAudioDecoder( std::unique_ptr<AudioDecoder> AudioDecoderG722::MakeAudioDecoder(
Config config) { Config config,
rtc::Optional<AudioCodecPairId> /*codec_pair_id*/) {
switch (config.num_channels) { switch (config.num_channels) {
case 1: case 1:
return rtc::MakeUnique<AudioDecoderG722Impl>(); return rtc::MakeUnique<AudioDecoderG722Impl>();

5
api/audio_codecs/g722/audio_decoder_g722.h
View File

@ -14,6 +14,7 @@
#include <memory> #include <memory>
#include <vector> #include <vector>
#include "api/audio_codecs/audio_codec_pair_id.h"
#include "api/audio_codecs/audio_decoder.h" #include "api/audio_codecs/audio_decoder.h"
#include "api/audio_codecs/audio_format.h" #include "api/audio_codecs/audio_format.h"
#include "api/optional.h" #include "api/optional.h"
@ -31,7 +32,9 @@ struct AudioDecoderG722 {
}; };
static rtc::Optional<Config> SdpToConfig(const SdpAudioFormat& audio_format); static rtc::Optional<Config> SdpToConfig(const SdpAudioFormat& audio_format);
static void AppendSupportedDecoders(std::vector<AudioCodecSpec>* specs); static void AppendSupportedDecoders(std::vector<AudioCodecSpec>* specs);
static std::unique_ptr<AudioDecoder> MakeAudioDecoder(Config config); static std::unique_ptr<AudioDecoder> MakeAudioDecoder(
Config config,
rtc::Optional<AudioCodecPairId> codec_pair_id = rtc::nullopt);
}; };
} // namespace webrtc } // namespace webrtc

3
api/audio_codecs/g722/audio_encoder_g722.cc
View File

@ -59,7 +59,8 @@ AudioCodecInfo AudioEncoderG722::QueryAudioEncoder(
std::unique_ptr<AudioEncoder> AudioEncoderG722::MakeAudioEncoder( std::unique_ptr<AudioEncoder> AudioEncoderG722::MakeAudioEncoder(
const AudioEncoderG722Config& config, const AudioEncoderG722Config& config,
int payload_type) { int payload_type,
rtc::Optional<AudioCodecPairId> /*codec_pair_id*/) {
RTC_DCHECK(config.IsOk()); RTC_DCHECK(config.IsOk());
return rtc::MakeUnique<AudioEncoderG722Impl>(config, payload_type); return rtc::MakeUnique<AudioEncoderG722Impl>(config, payload_type);
} }

4
api/audio_codecs/g722/audio_encoder_g722.h
View File

@ -14,6 +14,7 @@
#include <memory> #include <memory>
#include <vector> #include <vector>
#include "api/audio_codecs/audio_codec_pair_id.h"
#include "api/audio_codecs/audio_encoder.h" #include "api/audio_codecs/audio_encoder.h"
#include "api/audio_codecs/audio_format.h" #include "api/audio_codecs/audio_format.h"
#include "api/audio_codecs/g722/audio_encoder_g722_config.h" #include "api/audio_codecs/g722/audio_encoder_g722_config.h"
@ -33,7 +34,8 @@ struct AudioEncoderG722 {
static AudioCodecInfo QueryAudioEncoder(const AudioEncoderG722Config& config); static AudioCodecInfo QueryAudioEncoder(const AudioEncoderG722Config& config);
static std::unique_ptr<AudioEncoder> MakeAudioEncoder( static std::unique_ptr<AudioEncoder> MakeAudioEncoder(
const AudioEncoderG722Config& config, const AudioEncoderG722Config& config,
int payload_type); int payload_type,
rtc::Optional<AudioCodecPairId> codec_pair_id = rtc::nullopt);
}; };
} // namespace webrtc } // namespace webrtc

3
api/audio_codecs/ilbc/audio_decoder_ilbc.cc
View File

@ -33,7 +33,8 @@ void AudioDecoderIlbc::AppendSupportedDecoders(
} }
std::unique_ptr<AudioDecoder> AudioDecoderIlbc::MakeAudioDecoder( std::unique_ptr<AudioDecoder> AudioDecoderIlbc::MakeAudioDecoder(
Config config) { Config config,
rtc::Optional<AudioCodecPairId> /*codec_pair_id*/) {
return rtc::MakeUnique<AudioDecoderIlbcImpl>(); return rtc::MakeUnique<AudioDecoderIlbcImpl>();
} }

5
api/audio_codecs/ilbc/audio_decoder_ilbc.h
View File

@ -14,6 +14,7 @@
#include <memory> #include <memory>
#include <vector> #include <vector>
#include "api/audio_codecs/audio_codec_pair_id.h"
#include "api/audio_codecs/audio_decoder.h" #include "api/audio_codecs/audio_decoder.h"
#include "api/audio_codecs/audio_format.h" #include "api/audio_codecs/audio_format.h"
#include "api/optional.h" #include "api/optional.h"
@ -28,7 +29,9 @@ struct AudioDecoderIlbc {
struct Config {}; // Empty---no config values needed! struct Config {}; // Empty---no config values needed!
static rtc::Optional<Config> SdpToConfig(const SdpAudioFormat& audio_format); static rtc::Optional<Config> SdpToConfig(const SdpAudioFormat& audio_format);
static void AppendSupportedDecoders(std::vector<AudioCodecSpec>* specs); static void AppendSupportedDecoders(std::vector<AudioCodecSpec>* specs);
static std::unique_ptr<AudioDecoder> MakeAudioDecoder(Config config); static std::unique_ptr<AudioDecoder> MakeAudioDecoder(
Config config,
rtc::Optional<AudioCodecPairId> codec_pair_id = rtc::nullopt);
}; };
} // namespace webrtc } // namespace webrtc

3
api/audio_codecs/ilbc/audio_encoder_ilbc.cc
View File

@ -73,7 +73,8 @@ AudioCodecInfo AudioEncoderIlbc::QueryAudioEncoder(
std::unique_ptr<AudioEncoder> AudioEncoderIlbc::MakeAudioEncoder( std::unique_ptr<AudioEncoder> AudioEncoderIlbc::MakeAudioEncoder(
const AudioEncoderIlbcConfig& config, const AudioEncoderIlbcConfig& config,
int payload_type) { int payload_type,
rtc::Optional<AudioCodecPairId> /*codec_pair_id*/) {
RTC_DCHECK(config.IsOk()); RTC_DCHECK(config.IsOk());
return rtc::MakeUnique<AudioEncoderIlbcImpl>(config, payload_type); return rtc::MakeUnique<AudioEncoderIlbcImpl>(config, payload_type);
} }

4
api/audio_codecs/ilbc/audio_encoder_ilbc.h
View File

@ -14,6 +14,7 @@
#include <memory> #include <memory>
#include <vector> #include <vector>
#include "api/audio_codecs/audio_codec_pair_id.h"
#include "api/audio_codecs/audio_encoder.h" #include "api/audio_codecs/audio_encoder.h"
#include "api/audio_codecs/audio_format.h" #include "api/audio_codecs/audio_format.h"
#include "api/audio_codecs/ilbc/audio_encoder_ilbc_config.h" #include "api/audio_codecs/ilbc/audio_encoder_ilbc_config.h"
@ -33,7 +34,8 @@ struct AudioEncoderIlbc {
static AudioCodecInfo QueryAudioEncoder(const AudioEncoderIlbcConfig& config); static AudioCodecInfo QueryAudioEncoder(const AudioEncoderIlbcConfig& config);
static std::unique_ptr<AudioEncoder> MakeAudioEncoder( static std::unique_ptr<AudioEncoder> MakeAudioEncoder(
const AudioEncoderIlbcConfig& config, const AudioEncoderIlbcConfig& config,
int payload_type); int payload_type,
rtc::Optional<AudioCodecPairId> codec_pair_id = rtc::nullopt);
}; };
} // namespace webrtc } // namespace webrtc

3
api/audio_codecs/isac/audio_decoder_isac_fix.cc
View File

@ -30,7 +30,8 @@ void AudioDecoderIsacFix::AppendSupportedDecoders(
} }
std::unique_ptr<AudioDecoder> AudioDecoderIsacFix::MakeAudioDecoder( std::unique_ptr<AudioDecoder> AudioDecoderIsacFix::MakeAudioDecoder(
Config config) { Config config,
rtc::Optional<AudioCodecPairId> /*codec_pair_id*/) {
return rtc::MakeUnique<AudioDecoderIsacFixImpl>(16000); return rtc::MakeUnique<AudioDecoderIsacFixImpl>(16000);
} }

5
api/audio_codecs/isac/audio_decoder_isac_fix.h
View File

@ -14,6 +14,7 @@
#include <memory> #include <memory>
#include <vector> #include <vector>
#include "api/audio_codecs/audio_codec_pair_id.h"
#include "api/audio_codecs/audio_decoder.h" #include "api/audio_codecs/audio_decoder.h"
#include "api/audio_codecs/audio_format.h" #include "api/audio_codecs/audio_format.h"
#include "api/optional.h" #include "api/optional.h"
@ -28,7 +29,9 @@ struct AudioDecoderIsacFix {
struct Config {}; // Empty---no config values needed! struct Config {}; // Empty---no config values needed!
static rtc::Optional<Config> SdpToConfig(const SdpAudioFormat& audio_format); static rtc::Optional<Config> SdpToConfig(const SdpAudioFormat& audio_format);
static void AppendSupportedDecoders(std::vector<AudioCodecSpec>* specs); static void AppendSupportedDecoders(std::vector<AudioCodecSpec>* specs);
static std::unique_ptr<AudioDecoder> MakeAudioDecoder(Config config); static std::unique_ptr<AudioDecoder> MakeAudioDecoder(
Config config,
rtc::Optional<AudioCodecPairId> codec_pair_id = rtc::nullopt);
}; };
} // namespace webrtc } // namespace webrtc

3
api/audio_codecs/isac/audio_decoder_isac_float.cc
View File

@ -36,7 +36,8 @@ void AudioDecoderIsacFloat::AppendSupportedDecoders(
} }
std::unique_ptr<AudioDecoder> AudioDecoderIsacFloat::MakeAudioDecoder( std::unique_ptr<AudioDecoder> AudioDecoderIsacFloat::MakeAudioDecoder(
Config config) { Config config,
rtc::Optional<AudioCodecPairId> /*codec_pair_id*/) {
RTC_DCHECK(config.IsOk()); RTC_DCHECK(config.IsOk());
return rtc::MakeUnique<AudioDecoderIsacFloatImpl>(config.sample_rate_hz); return rtc::MakeUnique<AudioDecoderIsacFloatImpl>(config.sample_rate_hz);
} }

5
api/audio_codecs/isac/audio_decoder_isac_float.h
View File

@ -14,6 +14,7 @@
#include <memory> #include <memory>
#include <vector> #include <vector>
#include "api/audio_codecs/audio_codec_pair_id.h"
#include "api/audio_codecs/audio_decoder.h" #include "api/audio_codecs/audio_decoder.h"
#include "api/audio_codecs/audio_format.h" #include "api/audio_codecs/audio_format.h"
#include "api/optional.h" #include "api/optional.h"
@ -33,7 +34,9 @@ struct AudioDecoderIsacFloat {
}; };
static rtc::Optional<Config> SdpToConfig(const SdpAudioFormat& audio_format); static rtc::Optional<Config> SdpToConfig(const SdpAudioFormat& audio_format);
static void AppendSupportedDecoders(std::vector<AudioCodecSpec>* specs); static void AppendSupportedDecoders(std::vector<AudioCodecSpec>* specs);
static std::unique_ptr<AudioDecoder> MakeAudioDecoder(Config config); static std::unique_ptr<AudioDecoder> MakeAudioDecoder(
Config config,
rtc::Optional<AudioCodecPairId> codec_pair_id = rtc::nullopt);
}; };
} // namespace webrtc } // namespace webrtc

3
api/audio_codecs/isac/audio_encoder_isac_fix.cc
View File

@ -50,7 +50,8 @@ AudioCodecInfo AudioEncoderIsacFix::QueryAudioEncoder(
std::unique_ptr<AudioEncoder> AudioEncoderIsacFix::MakeAudioEncoder( std::unique_ptr<AudioEncoder> AudioEncoderIsacFix::MakeAudioEncoder(
AudioEncoderIsacFix::Config config, AudioEncoderIsacFix::Config config,
int payload_type) { int payload_type,
rtc::Optional<AudioCodecPairId> /*codec_pair_id*/) {
RTC_DCHECK(config.IsOk()); RTC_DCHECK(config.IsOk());
AudioEncoderIsacFixImpl::Config c; AudioEncoderIsacFixImpl::Config c;
c.frame_size_ms = config.frame_size_ms; c.frame_size_ms = config.frame_size_ms;

7
api/audio_codecs/isac/audio_encoder_isac_fix.h
View File

@ -14,6 +14,7 @@
#include <memory> #include <memory>
#include <vector> #include <vector>
#include "api/audio_codecs/audio_codec_pair_id.h"
#include "api/audio_codecs/audio_encoder.h" #include "api/audio_codecs/audio_encoder.h"
#include "api/audio_codecs/audio_format.h" #include "api/audio_codecs/audio_format.h"
#include "api/optional.h" #include "api/optional.h"
@ -32,8 +33,10 @@ struct AudioEncoderIsacFix {
static rtc::Optional<Config> SdpToConfig(const SdpAudioFormat& audio_format); static rtc::Optional<Config> SdpToConfig(const SdpAudioFormat& audio_format);
static void AppendSupportedEncoders(std::vector<AudioCodecSpec>* specs); static void AppendSupportedEncoders(std::vector<AudioCodecSpec>* specs);
static AudioCodecInfo QueryAudioEncoder(Config config); static AudioCodecInfo QueryAudioEncoder(Config config);
static std::unique_ptr<AudioEncoder> MakeAudioEncoder(Config config, static std::unique_ptr<AudioEncoder> MakeAudioEncoder(
int payload_type); Config config,
int payload_type,
rtc::Optional<AudioCodecPairId> codec_pair_id = rtc::nullopt);
}; };
} // namespace webrtc } // namespace webrtc

3
api/audio_codecs/isac/audio_encoder_isac_float.cc
View File

@ -61,7 +61,8 @@ AudioCodecInfo AudioEncoderIsacFloat::QueryAudioEncoder(
std::unique_ptr<AudioEncoder> AudioEncoderIsacFloat::MakeAudioEncoder( std::unique_ptr<AudioEncoder> AudioEncoderIsacFloat::MakeAudioEncoder(
const AudioEncoderIsacFloat::Config& config, const AudioEncoderIsacFloat::Config& config,
int payload_type) { int payload_type,
rtc::Optional<AudioCodecPairId> /*codec_pair_id*/) {
RTC_DCHECK(config.IsOk()); RTC_DCHECK(config.IsOk());
AudioEncoderIsacFloatImpl::Config c; AudioEncoderIsacFloatImpl::Config c;
c.sample_rate_hz = config.sample_rate_hz; c.sample_rate_hz = config.sample_rate_hz;

7
api/audio_codecs/isac/audio_encoder_isac_float.h
View File

@ -14,6 +14,7 @@
#include <memory> #include <memory>
#include <vector> #include <vector>
#include "api/audio_codecs/audio_codec_pair_id.h"
#include "api/audio_codecs/audio_encoder.h" #include "api/audio_codecs/audio_encoder.h"
#include "api/audio_codecs/audio_format.h" #include "api/audio_codecs/audio_format.h"
#include "api/optional.h" #include "api/optional.h"
@ -37,8 +38,10 @@ struct AudioEncoderIsacFloat {
static rtc::Optional<Config> SdpToConfig(const SdpAudioFormat& audio_format); static rtc::Optional<Config> SdpToConfig(const SdpAudioFormat& audio_format);
static void AppendSupportedEncoders(std::vector<AudioCodecSpec>* specs); static void AppendSupportedEncoders(std::vector<AudioCodecSpec>* specs);
static AudioCodecInfo QueryAudioEncoder(const Config& config); static AudioCodecInfo QueryAudioEncoder(const Config& config);
static std::unique_ptr<AudioEncoder> MakeAudioEncoder(const Config& config, static std::unique_ptr<AudioEncoder> MakeAudioEncoder(
int payload_type); const Config& config,
int payload_type,
rtc::Optional<AudioCodecPairId> codec_pair_id = rtc::nullopt);
}; };
} // namespace webrtc } // namespace webrtc

3
api/audio_codecs/opus/audio_decoder_opus.cc
View File

@ -55,7 +55,8 @@ void AudioDecoderOpus::AppendSupportedDecoders(
} }
std::unique_ptr<AudioDecoder> AudioDecoderOpus::MakeAudioDecoder( std::unique_ptr<AudioDecoder> AudioDecoderOpus::MakeAudioDecoder(
Config config) { Config config,
rtc::Optional<AudioCodecPairId> /*codec_pair_id*/) {
return rtc::MakeUnique<AudioDecoderOpusImpl>(config.num_channels); return rtc::MakeUnique<AudioDecoderOpusImpl>(config.num_channels);
} }

5
api/audio_codecs/opus/audio_decoder_opus.h
View File

@ -14,6 +14,7 @@
#include <memory> #include <memory>
#include <vector> #include <vector>
#include "api/audio_codecs/audio_codec_pair_id.h"
#include "api/audio_codecs/audio_decoder.h" #include "api/audio_codecs/audio_decoder.h"
#include "api/audio_codecs/audio_format.h" #include "api/audio_codecs/audio_format.h"
#include "api/optional.h" #include "api/optional.h"
@ -30,7 +31,9 @@ struct AudioDecoderOpus {
}; };
static rtc::Optional<Config> SdpToConfig(const SdpAudioFormat& audio_format); static rtc::Optional<Config> SdpToConfig(const SdpAudioFormat& audio_format);
static void AppendSupportedDecoders(std::vector<AudioCodecSpec>* specs); static void AppendSupportedDecoders(std::vector<AudioCodecSpec>* specs);
static std::unique_ptr<AudioDecoder> MakeAudioDecoder(Config config); static std::unique_ptr<AudioDecoder> MakeAudioDecoder(
Config config,
rtc::Optional<AudioCodecPairId> codec_pair_id = rtc::nullopt);
}; };
} // namespace webrtc } // namespace webrtc

3
api/audio_codecs/opus/audio_encoder_opus.cc
View File

@ -31,7 +31,8 @@ AudioCodecInfo AudioEncoderOpus::QueryAudioEncoder(
std::unique_ptr<AudioEncoder> AudioEncoderOpus::MakeAudioEncoder( std::unique_ptr<AudioEncoder> AudioEncoderOpus::MakeAudioEncoder(
const AudioEncoderOpusConfig& config, const AudioEncoderOpusConfig& config,
int payload_type) { int payload_type,
rtc::Optional<AudioCodecPairId> /*codec_pair_id*/) {
return AudioEncoderOpusImpl::MakeAudioEncoder(config, payload_type); return AudioEncoderOpusImpl::MakeAudioEncoder(config, payload_type);
} }

6
api/audio_codecs/opus/audio_encoder_opus.h
View File

@ -14,6 +14,7 @@
#include <memory> #include <memory>
#include <vector> #include <vector>
#include "api/audio_codecs/audio_codec_pair_id.h"
#include "api/audio_codecs/audio_encoder.h" #include "api/audio_codecs/audio_encoder.h"
#include "api/audio_codecs/audio_format.h" #include "api/audio_codecs/audio_format.h"
#include "api/audio_codecs/opus/audio_encoder_opus_config.h" #include "api/audio_codecs/opus/audio_encoder_opus_config.h"
@ -32,8 +33,9 @@ struct AudioEncoderOpus {
static void AppendSupportedEncoders(std::vector<AudioCodecSpec>* specs); static void AppendSupportedEncoders(std::vector<AudioCodecSpec>* specs);
static AudioCodecInfo QueryAudioEncoder(const AudioEncoderOpusConfig& config); static AudioCodecInfo QueryAudioEncoder(const AudioEncoderOpusConfig& config);
static std::unique_ptr<AudioEncoder> MakeAudioEncoder( static std::unique_ptr<AudioEncoder> MakeAudioEncoder(
const AudioEncoderOpusConfig&, const AudioEncoderOpusConfig& config,
int payload_type); int payload_type,
rtc::Optional<AudioCodecPairId> codec_pair_id = rtc::nullopt);
}; };
} // namespace webrtc } // namespace webrtc

4
api/audio_codecs/test/audio_decoder_factory_template_unittest.cc
View File

@ -60,7 +60,9 @@ struct AudioDecoderFakeApi {
return Params::CodecInfo(); return Params::CodecInfo();
} }
static std::unique_ptr<AudioDecoder> MakeAudioDecoder(const Config&) { static std::unique_ptr<AudioDecoder> MakeAudioDecoder(
const Config&,
rtc::Optional<AudioCodecPairId> /*codec_pair_id*/ = rtc::nullopt) {
auto dec = rtc::MakeUnique<testing::StrictMock<MockAudioDecoder>>(); auto dec = rtc::MakeUnique<testing::StrictMock<MockAudioDecoder>>();
EXPECT_CALL(*dec, SampleRateHz()) EXPECT_CALL(*dec, SampleRateHz())
.WillOnce(testing::Return(Params::CodecInfo().sample_rate_hz)); .WillOnce(testing::Return(Params::CodecInfo().sample_rate_hz));

6
api/audio_codecs/test/audio_encoder_factory_template_unittest.cc
View File

@ -60,8 +60,10 @@ struct AudioEncoderFakeApi {
return Params::CodecInfo(); return Params::CodecInfo();
} }
static std::unique_ptr<AudioEncoder> MakeAudioEncoder(const Config&, static std::unique_ptr<AudioEncoder> MakeAudioEncoder(
int payload_type) { const Config&,
int payload_type,
rtc::Optional<AudioCodecPairId> /*codec_pair_id*/ = rtc::nullopt) {
auto enc = rtc::MakeUnique<testing::StrictMock<MockAudioEncoder>>(); auto enc = rtc::MakeUnique<testing::StrictMock<MockAudioEncoder>>();
EXPECT_CALL(*enc, SampleRateHz()) EXPECT_CALL(*enc, SampleRateHz())
.WillOnce(testing::Return(Params::CodecInfo().sample_rate_hz)); .WillOnce(testing::Return(Params::CodecInfo().sample_rate_hz));

12
pc/peerconnectionendtoend_unittest.cc
View File

@ -12,6 +12,7 @@
#include "api/audio_codecs/L16/audio_decoder_L16.h" #include "api/audio_codecs/L16/audio_decoder_L16.h"
#include "api/audio_codecs/L16/audio_encoder_L16.h" #include "api/audio_codecs/L16/audio_encoder_L16.h"
#include "api/audio_codecs/audio_codec_pair_id.h"
#include "api/audio_codecs/audio_decoder_factory_template.h" #include "api/audio_codecs/audio_decoder_factory_template.h"
#include "api/audio_codecs/audio_encoder_factory_template.h" #include "api/audio_codecs/audio_encoder_factory_template.h"
#include "api/audio_codecs/builtin_audio_decoder_factory.h" #include "api/audio_codecs/builtin_audio_decoder_factory.h"
@ -305,8 +306,10 @@ struct AudioEncoderUnicornSparklesRainbow {
} }
static std::unique_ptr<webrtc::AudioEncoder> MakeAudioEncoder( static std::unique_ptr<webrtc::AudioEncoder> MakeAudioEncoder(
const Config& config, const Config& config,
int payload_type) { int payload_type,
return webrtc::AudioEncoderL16::MakeAudioEncoder(config, payload_type); rtc::Optional<webrtc::AudioCodecPairId> codec_pair_id = rtc::nullopt) {
return webrtc::AudioEncoderL16::MakeAudioEncoder(config, payload_type,
codec_pair_id);
} }
}; };
@ -336,8 +339,9 @@ struct AudioDecoderUnicornSparklesRainbow {
} }
} }
static std::unique_ptr<webrtc::AudioDecoder> MakeAudioDecoder( static std::unique_ptr<webrtc::AudioDecoder> MakeAudioDecoder(
const Config& config) { const Config& config,
return webrtc::AudioDecoderL16::MakeAudioDecoder(config); rtc::Optional<webrtc::AudioCodecPairId> codec_pair_id = rtc::nullopt) {
return webrtc::AudioDecoderL16::MakeAudioDecoder(config, codec_pair_id);
} }
}; };