public/rtphone
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Compare commits

base: public/rtphone:master
Branches Tags
public/rtphone:master
..
compare: public/rtphone:e342abe2f57646bcdb287a8dba23b9f200261639
Branches Tags
public/rtphone:master

4 Commits
master .. e342abe2f5

Author SHA1 Message Date
Dmytro Bogovych e342abe2f5 - format + fix invalid memory access 2022-06-18 22:24:41 +03:00
dmytro.bogovych 9d79c01be0 - fix extra \r\n in logs 2022-06-18 13:03:30 +03:00
dmytro.bogovych fa705e141b - add dependency on ice stack for media library to resolve linking problem 2022-06-15 11:32:30 +03:00
dmytro.bogovych 17e17d3d79 - work to move Sevana specific parts to corresponding project (PVQA server and PVQA RTP library) 2022-06-14 18:36:22 +03:00
12152 changed files with 419446 additions and 2333370 deletions
Expand all files Collapse all files
.clang-format
-69
View File
@@ -1,69 +0,0 @@
# Formatting rules for rtphone's own C++ sources (src/engine, src/libs/ice, test).
# Third-party code under src/libs/ is excluded via .clang-format-ignore.
---
Language: Cpp
BasedOnStyle: LLVM
Standard: c++20
# Indentation: 4 columns, spaces only.
IndentWidth: 4
TabWidth: 4
UseTab: Never
AccessModifierOffset: -4
NamespaceIndentation: None
IndentCaseLabels: false
ColumnLimit: 120
# Allman braces, as used throughout the codebase.
BreakBeforeBraces: Allman
PointerAlignment: Left
ReferenceAlignment: Left
DerivePointerAlignment: false
AllowShortFunctionsOnASingleLine: Inline
AllowShortIfStatementsOnASingleLine: Never
AllowShortLoopsOnASingleLine: false
AllowShortCaseLabelsOnASingleLine: false
AllowShortBlocksOnASingleLine: Empty
# Include order matters here (platform headers, windows.h, vendored libs),
# so never reorder them.
SortIncludes: Never
IndentPPDirectives: None
KeepEmptyLinesAtTheStartOfBlocks: false
MaxEmptyLinesToKeep: 2
FixNamespaceComments: true
SpaceAfterTemplateKeyword: false
AlwaysBreakTemplateDeclarations: Yes
AlignConsecutiveDeclarations: AcrossEmptyLinesAndComments
# Objective-C++ (src/libs/ice/ICEIosSupport.mm) — same rules as C++.
---
Language: ObjC
BasedOnStyle: LLVM
IndentWidth: 4
TabWidth: 4
UseTab: Never
AccessModifierOffset: -4
NamespaceIndentation: None
IndentCaseLabels: false
ColumnLimit: 120
BreakBeforeBraces: Allman
PointerAlignment: Left
ReferenceAlignment: Left
DerivePointerAlignment: false
AllowShortFunctionsOnASingleLine: Inline
AllowShortIfStatementsOnASingleLine: Never
AllowShortLoopsOnASingleLine: false
AllowShortCaseLabelsOnASingleLine: false
AllowShortBlocksOnASingleLine: Empty
SortIncludes: Never
IndentPPDirectives: None
KeepEmptyLinesAtTheStartOfBlocks: false
MaxEmptyLinesToKeep: 2
FixNamespaceComments: true
AlignConsecutiveDeclarations: AcrossEmptyLinesAndComments
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true
.clang-format-ignore
-2
View File
@@ -1,2 +0,0 @@
src/libs/**
!src/libs/ice/ICE*
.gitignore
-89
View File
@@ -1,89 +0,0 @@
# Build directories
build/
build_*/
out/
bin/
lib/
Release/
Debug/
x64/
x86/
# CMake generated files
CMakeCache.txt
CMakeFiles/
cmake_install.cmake
Makefile
*.cmake
!CMakeLists.txt
compile_commands.json
CTestTestfile.cmake
_deps/
# QtCreator
*.user
*.user.*
*.qmlproject.user
*.creator.user
.qmake.stash
# Visual Studio
*.suo
*.user
*.userosscache
*.sln.docstates
.vs/
*.vcxproj.user
*.ncb
*.sdf
*.opensdf
*.VC.db
*.VC.VC.opendb
ipch/
# Compiled object files
*.o
*.obj
*.ko
*.elf
# Precompiled headers
*.gch
*.pch
# Compiled libraries
# *.lib
# *.a
*.la
*.lo
*.so
*.so.*
*.dylib
# Executables
*.exe
*.out
*.app
# IDE caches
.cache/
.idea/
.vscode/
*.swp
*.swo
*~
# Downloaded archives
*.tar.gz
*.tar.bz2
*.tar.xz
*.zip
# OS specific
.DS_Store
Thumbs.db
# Logs and temp files
*.log
*.tmp
*.temp
.gitlab-ci.yml
+8
View File
@@ -0,0 +1,8 @@
build_exe:
script:
- mkdir -p build
- cd build
- git clone https://gitlab.com/dmytro.bogovych/libraries.git
- cmake -D LIB_PLATFORM=libraries ../src
- cmake --build .
AGENTS.md
-366
View File
@@ -1,366 +0,0 @@
# RTPhone Platform - Agent Guide
## Project Overview
RTPhone is a comprehensive real-time communication (RTC) platform developed by VoIP Objects (Sevana) that provides a complete software stack for building VoIP/SIP-based communication applications. It delivers production-ready voice communication capabilities with extensive codec support and cross-platform compatibility.
The project produces a static library (`librtphone.a`) that can be integrated into larger telephony and communication systems. It provides a JSON-based command interface for easy integration and control.
## Technology Stack
- **Language**: C++20
- **Build System**: CMake 3.20+
- **License**: Mozilla Public License Version 2.0 (see LICENSE_MPL.txt)
- **Primary Platforms**: Linux (x64, ARM/Raspberry Pi), Windows (32/64-bit), macOS, Android, iOS
## Project Structure
```
/home/anand/works/sevana/platform/rtphone/
├── src/ # Main source code
│ ├── CMakeLists.txt # Main CMake configuration
│ ├── engine/ # Core engine modules
│ │ ├── agent/ # JSON-based command interface
│ │ ├── audio/ # Cross-platform audio I/O handling
│ │ ├── endpoint/ # SIP user agent implementation
│ │ ├── helper/ # Utility functions (networking, logging, threading)
│ │ ├── media/ # Audio codec management and processing
│ │ └── engine_config.h # Compile-time configuration
│ └── libs/ # Third-party libraries
│ ├── resiprocate/ # SIP stack (git submodule)
│ ├── libsrtp/ # SRTP library (git submodule)
│ ├── libraries/ # Prebuilt platform libraries (git submodule)
│ ├── ice/ # ICE (Interactive Connectivity Establishment)
│ ├── jrtplib/ # RTP library
│ ├── opus/ # Opus codec
│ ├── webrtc/ # WebRTC components
│ ├── libg729/ # G.729 codec
│ ├── libgsm/ # GSM codec
│ ├── gsmhr/ # GSM HR codec
│ ├── g722/ # G.722 codec
│ ├── speexdsp/ # Speex DSP
│ ├── libevs/ # EVS codec (optional)
│ ├── opencore-amr/ # AMR codec (optional)
│ ├── oboe/ # Android low-latency audio
│ └── fmt/ # Format library
├── build_linux.py # Linux build script
├── build_android.py # Android build script
├── build_android.sh # Android build script (shell)
├── run_ci.sh # CI build script
└── README.txt # Human-readable README
```
## Build Instructions
### Prerequisites
- CMake 3.20+
- C++20 compatible compiler (GCC, Clang, MSVC)
- Python 3 (for build scripts)
- Ninja (recommended, used by build scripts)
- OpenSSL 1.1+ development libraries
- Platform-specific audio libraries
### Linux Build
```bash
python3 build_linux.py
```
This creates a `build_linux/` directory and outputs `librtphone.a`.
### Android Build
```bash
# Ensure ANDROID_NDK_HOME environment variable is set
export ANDROID_NDK_HOME=/path/to/android-ndk
python3 build_android.py
```
Or use the shell script:
```bash
./build_android.sh
```
This creates a `build_android/` directory with ARM64 libraries by default.
### Manual CMake Build
```bash
mkdir build && cd build
cmake ../src -G Ninja
cmake --build . -j$(nproc)
```
### Build Options
The following CMake options are available (defined in `src/CMakeLists.txt`):
- `USE_AMR_CODEC` (ON/OFF): Include AMR-NB/AMR-WB codec support. Default: ON
- `USE_EVS_CODEC` (ON/OFF): Include EVS codec support. Default: ON
- `USE_MUSL` (ON/OFF): Build with MUSL library. Default: OFF
## Module Architecture
### 1. Agent Module (`src/engine/agent/`)
Provides a JSON-based command interface for controlling the engine.
**Key Classes:**
- `AgentImpl`: Main agent implementation, processes JSON commands
- `Agent_AudioManager`: Manages audio devices and streams
**Interface Pattern:**
Commands are sent as JSON strings and responses are returned as JSON.
### 2. Endpoint Module (`src/engine/endpoint/`)
SIP user agent implementation based on reSIProcate.
**Key Classes:**
- `UserAgent` (in EP_Engine.h): Main SIP stack wrapper, handles registration, sessions, presence
- `Account` (EP_Account): SIP account management
- `Session` (EP_Session): Call/session management
- `EP_AudioProvider`: Audio data provider for sessions
- `EP_DataProvider`: Generic data provider interface
**Key Concepts:**
- Implements resiprocate handlers: `ClientRegistrationHandler`, `InviteSessionHandler`, etc.
- Supports multiple transport types: UDP, TCP, TLS
- ICE integration for NAT traversal
### 3. Media Module (`src/engine/media/`)
Audio codec management, RTP/RTCP handling, and media processing.
**Key Classes:**
- `MT::AudioCodec`: Codec management
- `MT::AudioStream`: Audio streaming
- `MT::AudioReceiver`: RTP packet receiving
- `MT::CodecList`: Codec negotiation
- `MT::SrtpHelper`: SRTP encryption
- `MT::Dtmf`: DTMF tone handling
- `MT::AmrCodec`: AMR codec wrapper
- `MT::EvsCodec`: EVS codec wrapper
### 4. Audio Module (`src/engine/audio/`)
Cross-platform audio I/O abstraction.
**Key Classes:**
- `Audio::Interface`: Audio interface abstraction
- `Audio::DevicePair`: Input/output device pair
- `Audio::Resampler`: Audio resampling
- `Audio::Mixer`: Multi-channel audio mixing
- `Audio::CoreAudio`: macOS/iOS implementation
- `Audio::DirectSound`: Windows DirectSound implementation
- `Audio::AndroidOboe`: Android Oboe implementation
- `Audio::Null`: Null/no-op implementation for testing
### 5. Helper Module (`src/engine/helper/`)
Utility classes and platform abstractions.
**Key Classes:**
- `HL::Types`: Type definitions and BiMap template
- `HL::Sync`: Threading primitives (Mutex, Event, etc.)
- `HL::ByteBuffer`: Binary data buffer
- `HL::VariantMap`: Key-value configuration storage
- `HL::Rtp`: RTP packet utilities
- `HL::IuUP`: Iu User Plane protocol (3G)
- `HL::NetworkSocket`: Network socket abstraction
- `HL::ThreadPool`: Thread pool implementation
## Code Style Guidelines
### Naming Conventions
1. **Classes**: PascalCase with module prefix
- `AgentImpl`, `UserAgent`, `MT::AudioCodec`, `HL::Sync`
2. **Files**: Prefix indicates module
- `Agent_*.cpp/h` - Agent module
- `EP_*.cpp/h` - Endpoint module
- `MT_*.cpp/h` - Media module
- `Audio_*.cpp/h` - Audio module
- `HL_*.cpp/h` - Helper module
3. **Member Variables**: Hungarian notation with `m` prefix
- `mAgentMutex`, `mSessionMap`, `mShutdown`
4. **Type Aliases**: `P` prefix for smart pointers
- `PAccount`, `PSession`, `PVariantMap`
### File Header Template
All source files must include the MPL license header:
```cpp
/* Copyright(C) 2007-YYYY VoIP objects (voipobjects.com)
* 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/. */
```
### Include Order
1. Corresponding header file (for .cpp files)
2. Project headers (using `"..."`)
3. Third-party library headers
4. Standard library headers
5. System headers
### Platform Abstraction
Use preprocessor defines for platform-specific code:
- `TARGET_WIN` - Windows
- `TARGET_LINUX` - Linux
- `TARGET_OSX` - macOS
- `TARGET_ANDROID` - Android
- `TARGET_MUSL` - MUSL libc
## Configuration
### Compile-Time Configuration (`src/engine/engine_config.h`)
Key configuration constants:
```cpp
// Audio settings
#define AUDIO_SAMPLE_WIDTH 16
#define AUDIO_CHANNELS 1
#define AUDIO_SAMPLERATE 48000
#define AUDIO_RESAMPLER_QUALITY 1
// SIP settings
#define UA_REGISTRATION_TIME 3600
#define UA_MEDIA_PORT_START 20000
#define UA_MEDIA_PORT_FINISH 30000
// Codec payload types
#define MT_AMRNB_PAYLOADTYPE 112
#define MT_AMRWB_PAYLOADTYPE 96
#define MT_EVS_PAYLOADTYPE 127
#define MT_OPUS_CODEC_PT 106
```
### Runtime Configuration
Configuration is passed via `VariantMap` objects to the UserAgent:
```cpp
enum
{
CONFIG_IPV4 = 0, // Use IP4
CONFIG_IPV6, // Use IP6
CONFIG_USERNAME, // Username
CONFIG_DOMAIN, // Domain
CONFIG_PASSWORD, // Password
CONFIG_STUNSERVER_NAME, // STUN server hostname
CONFIG_STUNSERVER_PORT, // STUN server port
CONFIG_TRANSPORT, // 0=all, 1=UDP, 2=TCP, 3=TLS
// ... see EP_Engine.h for full list
};
```
## Dependencies
### Git Submodules
The project uses Git submodules for some dependencies:
- `src/libs/resiprocate` - SIP stack (sevana branch)
- `src/libs/libsrtp` - SRTP library
- `src/libs/libraries` - Prebuilt platform libraries
To initialize:
```bash
git submodule update --init --recursive
```
### Third-Party Libraries
Prebuilt libraries are provided in `src/libs/libraries/`:
- OpenSSL 1.1 (crypto, SSL)
- Opus codec
- Opencore AMR (NB/WB)
- Boost (headers)
- PortAudio
- libevent2
## Testing
There is no dedicated test suite in the main project. Testing is typically done through:
1. Integration with the final application
2. The `run_ci.sh` script for build verification
3. Unit tests in individual library submodules (e.g., oboe)
### CI Build
```bash
./run_ci.sh
```
This configures with CMake and builds with make (2 parallel jobs).
## Security Considerations
1. **OpenSSL Integration**: Uses OpenSSL 1.1+ for TLS and certificate handling
2. **SRTP Support**: Media encryption via libsrtp
3. **Certificate Management**: Root certificates can be added at runtime via `addRootCert()`
4. **AMR/EVS Patents**: The project does NOT include patent licenses for AMR and EVS codecs. Users must acquire these independently.
## Integration Guide
### Basic Usage Pattern
1. Create `AgentImpl` instance
2. Send JSON commands via `command()` method
3. Poll for events via `waitForData()` and `read()`
4. Process JSON event responses
### Example Commands
- `config` - Configure the engine
- `start` - Start the engine
- `createAccount` - Create SIP account
- `startAccount` - Register account
- `createSession` - Create call session
- `startSession` - Make/accept call
- `waitForEvent` - Poll for events
## Development Workflow
1. **Making Changes**: Edit files in appropriate `src/engine/<module>/` directory
2. **Building**: Use `build_linux.py` for quick Linux builds
3. **Testing**: Integrate with test application or use existing CI
4. **Commits**: Follow existing commit message style (visible in git log)
## Common Tasks
### Adding a New Codec
1. Create `MT_<Codec>Codec.cpp/h` in `src/engine/media/`
2. Derive from `MT::Codec` base class
3. Register in `MT_CodecList.cpp`
4. Add to `src/CMakeLists.txt` if external library needed
### Adding Platform Audio Support
1. Create `Audio_<Platform>.cpp/h` in `src/engine/audio/`
2. Implement `Audio::Interface` methods
3. Add platform detection in `src/CMakeLists.txt`
4. Include in build conditionally
### Modifying Build Configuration
- Edit `src/CMakeLists.txt` for main build changes
- Edit `src/libs/libraries/platform_libs.cmake` for platform library paths
- Edit `src/engine/engine_config.h` for compile-time constants
## Notes
- The codebase uses C++20 features - ensure compiler compatibility
- Thread safety: Use `std::recursive_mutex` (e.g., `mAgentMutex`) for thread-safe access
- Memory management: Uses smart pointers (`std::shared_ptr`) extensively
- The JSON library is embedded in `src/libs/json/`
CLAUDE.md
-79
View File
@@ -1,79 +0,0 @@
# CLAUDE.md
This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
A more detailed agent reference (style guide, JSON command list, integration notes, full module class listings) is in `AGENTS.md`. Read that for deeper context; this file only captures what is needed to be productive quickly.
## What this repo produces
A single C++20 static library, `librtphone.a`, that implements a SIP/RTP softphone stack (codecs, media transport, SIP user agent, cross-platform audio I/O). It is consumed by other applications via a JSON command interface (`AgentImpl`). There is no executable target in `src/` — only the library.
## Build and run
The Python scripts wipe and recreate their build directory each invocation, so they are clean configure+build runs, not incremental.
```bash
python3 build_linux.py # wipes build_linux/, configures with Ninja, outputs build_linux/librtphone.a
python3 build_android.py # needs ANDROID_NDK_HOME and VCPKG_ROOT; arm64-v8a, API 24
python3 build_windows.py # needs VCPKG_ROOT (defaults to C:\tools\vcpkg); VS 2022 x64
./run_ci.sh # Make-based CI build into ./build (used by Jenkins; pings Telegram on failure)
```
For incremental work, configure once and rebuild manually instead of re-running the wrapper:
```bash
mkdir -p build && cd build
cmake ../src -G Ninja -D OPUS_X86_MAY_HAVE_SSE4_1=ON
cmake --build . -j$(nproc)
```
CMake options (in `src/CMakeLists.txt`): `USE_AMR_CODEC` (default ON, force-OFF on Android), `USE_EVS_CODEC` (default ON), `USE_MUSL` (default OFF).
## Tests
There is no unit test suite for the library itself. The only first-party test is `test/rtp_decode/` — a standalone CMake project that links the library and exercises RTP decoding from a capture file. Build and run it via:
```bash
mkdir -p test/rtp_decode/build && cd test/rtp_decode/build
cmake .. && cmake --build . -j$(nproc)
./rtp_decode <args>
```
Note: `test/rtp_decode/CMakeLists.txt` does `add_subdirectory(../../src ...)`, so it rebuilds the whole library inside its own build tree. Don't expect to share artifacts with `build_linux/`.
## Submodules and external paths
The `src/libs/` directory mixes vendored sources with three git submodules: `resiprocate` (SIP stack, sevana branch), `libsrtp`, and `libraries` (prebuilt platform binaries — OpenSSL 1.1, Boost headers, etc.). After clone:
```bash
git submodule update --init --recursive
```
## Architecture: how a call flows through the modules
The five modules under `src/engine/` form a vertical stack. Understanding the flow matters more than the file list (which is in `AGENTS.md`):
1. **`agent/`** — Public API surface. Hosts apps create one `AgentImpl`, push JSON command strings into `command()`, and pull JSON event strings out via `waitForData()`/`read()`. This is the only thing external code should touch.
2. **`endpoint/`** — Wraps reSIProcate. `UserAgent` (in `EP_Engine.h`) owns the SIP transports, registrations, and session lifecycle; `EP_Account` and `EP_Session` are the SIP-side objects the agent manipulates. `EP_AudioProvider`/`EP_DataProvider` bridge SIP sessions to media streams.
3. **`media/`** (`MT::` namespace) — Codec registry (`MT_CodecList`), per-call audio pipeline (`MT_AudioStream`, `MT_AudioReceiver`), RTP send (`MT_NativeRtpSender`), SRTP (`MT_SrtpHelper`), DTMF (`MT_Dtmf`). Codec wrappers like `MT_AmrCodec`/`MT_EvsCodec` adapt vendored libraries in `src/libs/` to the `MT::Codec` base.
4. **`audio/`** (`Audio::` namespace) — Cross-platform device I/O. `Audio::Interface` is the abstraction; concrete implementations are picked at compile time: `Audio_DirectSound` (Windows), `Audio_CoreAudio` (macOS/iOS), `Audio_AndroidOboe` (Android, via `libs/oboe`), `Audio_Null` (testing). Also hosts mixing, resampling, WAV I/O, AEC integration.
5. **`helper/`** (`HL::` namespace) — Cross-cutting primitives used by every other module: `HL_Sync` (mutex/event), `HL_NetworkSocket`, `HL_Log`, `HL_VariantMap` (used as the runtime config bag passed to `UserAgent`), `HL_Rtp`, `HL_IuUP` (3G Iu-UP framing), `HL_ThreadPool`, `HL_ByteBuffer`.
ICE/STUN lives separately under `src/libs/ice/` (it is compiled directly into the library, not as a subproject) and is wired into the media path for NAT traversal.
Compile-time tunables — sample rate (48 kHz), buffer sizes, RTP/codec payload types, media port range — are all in `src/engine/engine_config.h`. Runtime configuration flows through `HL::VariantMap` keyed by the `CONFIG_*` enum in `EP_Engine.h`.
Per-stream call-quality metrics (RTT, jitter per RFC 3550 §A.8, packet-loss timeline, RFC 2833 DTMF events, network MOS) are collected in `MT::Statistics` / `MT::JitterStatistics` in `src/engine/media/MT_Statistics.{h,cpp}` and surfaced through the agent's JSON event stream.
## Conventions worth knowing before editing
- **File prefixes encode the module**: `Agent_*`, `EP_*`, `MT_*`, `Audio_*`, `HL_*`. Match this when adding files.
- **Members use `m` prefix** (`mAgentMutex`, `mSessionMap`); smart-pointer typedefs use `P` prefix (`PSession`, `PVariantMap`).
- **Platform code is gated by `TARGET_WIN` / `TARGET_LINUX` / `TARGET_OSX` / `TARGET_ANDROID` / `TARGET_MUSL`**, set in `src/CMakeLists.txt`. Don't sniff `_WIN32`/`__linux__` directly.
- **Every source file carries the MPL 2.0 header** (see top of any existing `.cpp`). New files need the same block.
- **Thread safety is via `std::recursive_mutex`** (e.g. `mAgentMutex` guards the agent's public surface). Memory uses `std::shared_ptr` extensively — prefer the existing `P*` typedefs over raw pointers.
- The codebase recently migrated to **C++20 and `std::chrono`**; avoid reintroducing older idioms or hand-rolled time math.
## Patent caveat
AMR-NB/AMR-WB and EVS sources are included but no patent licenses are bundled. If a change touches `MT_AmrCodec`/`MT_EvsCodec` or their build flags, keep in mind users are expected to license these codecs themselves — don't enable them by default in contexts where that hasn't been arranged.
LICENSE_MPL.txt
-373
View File
@@ -1,373 +0,0 @@
Mozilla Public License Version 2.0
==================================
1. Definitions
--------------
1.1. "Contributor"
means each individual or legal entity that creates, contributes to
the creation of, or owns Covered Software.
1.2. "Contributor Version"
means the combination of the Contributions of others (if any) used
by a Contributor and that particular Contributor's Contribution.
1.3. "Contribution"
means Covered Software of a particular Contributor.
1.4. "Covered Software"
means Source Code Form to which the initial Contributor has attached
the notice in Exhibit A, the Executable Form of such Source Code
Form, and Modifications of such Source Code Form, in each case
including portions thereof.
1.5. "Incompatible With Secondary Licenses"
means
(a) that the initial Contributor has attached the notice described
in Exhibit B to the Covered Software; or
(b) that the Covered Software was made available under the terms of
version 1.1 or earlier of the License, but not also under the
terms of a Secondary License.
1.6. "Executable Form"
means any form of the work other than Source Code Form.
1.7. "Larger Work"
means a work that combines Covered Software with other material, in
a separate file or files, that is not Covered Software.
1.8. "License"
means this document.
1.9. "Licensable"
means having the right to grant, to the maximum extent possible,
whether at the time of the initial grant or subsequently, any and
all of the rights conveyed by this License.
1.10. "Modifications"
means any of the following:
(a) any file in Source Code Form that results from an addition to,
deletion from, or modification of the contents of Covered
Software; or
(b) any new file in Source Code Form that contains any Covered
Software.
1.11. "Patent Claims" of a Contributor
means any patent claim(s), including without limitation, method,
process, and apparatus claims, in any patent Licensable by such
Contributor that would be infringed, but for the grant of the
License, by the making, using, selling, offering for sale, having
made, import, or transfer of either its Contributions or its
Contributor Version.
1.12. "Secondary License"
means either the GNU General Public License, Version 2.0, the GNU
Lesser General Public License, Version 2.1, the GNU Affero General
Public License, Version 3.0, or any later versions of those
licenses.
1.13. "Source Code Form"
means the form of the work preferred for making modifications.
1.14. "You" (or "Your")
means an individual or a legal entity exercising rights under this
License. For legal entities, "You" includes any entity that
controls, is controlled by, or is under common control with You. For
purposes of this definition, "control" means (a) the power, direct
or indirect, to cause the direction or management of such entity,
whether by contract or otherwise, or (b) ownership of more than
fifty percent (50%) of the outstanding shares or beneficial
ownership of such entity.
2. License Grants and Conditions
--------------------------------
2.1. Grants
Each Contributor hereby grants You a world-wide, royalty-free,
non-exclusive license:
(a) under intellectual property rights (other than patent or trademark)
Licensable by such Contributor to use, reproduce, make available,
modify, display, perform, distribute, and otherwise exploit its
Contributions, either on an unmodified basis, with Modifications, or
as part of a Larger Work; and
(b) under Patent Claims of such Contributor to make, use, sell, offer
for sale, have made, import, and otherwise transfer either its
Contributions or its Contributor Version.
2.2. Effective Date
The licenses granted in Section 2.1 with respect to any Contribution
become effective for each Contribution on the date the Contributor first
distributes such Contribution.
2.3. Limitations on Grant Scope
The licenses granted in this Section 2 are the only rights granted under
this License. No additional rights or licenses will be implied from the
distribution or licensing of Covered Software under this License.
Notwithstanding Section 2.1(b) above, no patent license is granted by a
Contributor:
(a) for any code that a Contributor has removed from Covered Software;
or
(b) for infringements caused by: (i) Your and any other third party's
modifications of Covered Software, or (ii) the combination of its
Contributions with other software (except as part of its Contributor
Version); or
(c) under Patent Claims infringed by Covered Software in the absence of
its Contributions.
This License does not grant any rights in the trademarks, service marks,
or logos of any Contributor (except as may be necessary to comply with
the notice requirements in Section 3.4).
2.4. Subsequent Licenses
No Contributor makes additional grants as a result of Your choice to
distribute the Covered Software under a subsequent version of this
License (see Section 10.2) or under the terms of a Secondary License (if
permitted under the terms of Section 3.3).
2.5. Representation
Each Contributor represents that the Contributor believes its
Contributions are its original creation(s) or it has sufficient rights
to grant the rights to its Contributions conveyed by this License.
2.6. Fair Use
This License is not intended to limit any rights You have under
applicable copyright doctrines of fair use, fair dealing, or other
equivalents.
2.7. Conditions
Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
in Section 2.1.
3. Responsibilities
-------------------
3.1. Distribution of Source Form
All distribution of Covered Software in Source Code Form, including any
Modifications that You create or to which You contribute, must be under
the terms of this License. You must inform recipients that the Source
Code Form of the Covered Software is governed by the terms of this
License, and how they can obtain a copy of this License. You may not
attempt to alter or restrict the recipients' rights in the Source Code
Form.
3.2. Distribution of Executable Form
If You distribute Covered Software in Executable Form then:
(a) such Covered Software must also be made available in Source Code
Form, as described in Section 3.1, and You must inform recipients of
the Executable Form how they can obtain a copy of such Source Code
Form by reasonable means in a timely manner, at a charge no more
than the cost of distribution to the recipient; and
(b) You may distribute such Executable Form under the terms of this
License, or sublicense it under different terms, provided that the
license for the Executable Form does not attempt to limit or alter
the recipients' rights in the Source Code Form under this License.
3.3. Distribution of a Larger Work
You may create and distribute a Larger Work under terms of Your choice,
provided that You also comply with the requirements of this License for
the Covered Software. If the Larger Work is a combination of Covered
Software with a work governed by one or more Secondary Licenses, and the
Covered Software is not Incompatible With Secondary Licenses, this
License permits You to additionally distribute such Covered Software
under the terms of such Secondary License(s), so that the recipient of
the Larger Work may, at their option, further distribute the Covered
Software under the terms of either this License or such Secondary
License(s).
3.4. Notices
You may not remove or alter the substance of any license notices
(including copyright notices, patent notices, disclaimers of warranty,
or limitations of liability) contained within the Source Code Form of
the Covered Software, except that You may alter any license notices to
the extent required to remedy known factual inaccuracies.
3.5. Application of Additional Terms
You may choose to offer, and to charge a fee for, warranty, support,
indemnity or liability obligations to one or more recipients of Covered
Software. However, You may do so only on Your own behalf, and not on
behalf of any Contributor. You must make it absolutely clear that any
such warranty, support, indemnity, or liability obligation is offered by
You alone, and You hereby agree to indemnify every Contributor for any
liability incurred by such Contributor as a result of warranty, support,
indemnity or liability terms You offer. You may include additional
disclaimers of warranty and limitations of liability specific to any
jurisdiction.
4. Inability to Comply Due to Statute or Regulation
---------------------------------------------------
If it is impossible for You to comply with any of the terms of this
License with respect to some or all of the Covered Software due to
statute, judicial order, or regulation then You must: (a) comply with
the terms of this License to the maximum extent possible; and (b)
describe the limitations and the code they affect. Such description must
be placed in a text file included with all distributions of the Covered
Software under this License. Except to the extent prohibited by statute
or regulation, such description must be sufficiently detailed for a
recipient of ordinary skill to be able to understand it.
5. Termination
--------------
5.1. The rights granted under this License will terminate automatically
if You fail to comply with any of its terms. However, if You become
compliant, then the rights granted under this License from a particular
Contributor are reinstated (a) provisionally, unless and until such
Contributor explicitly and finally terminates Your grants, and (b) on an
ongoing basis, if such Contributor fails to notify You of the
non-compliance by some reasonable means prior to 60 days after You have
come back into compliance. Moreover, Your grants from a particular
Contributor are reinstated on an ongoing basis if such Contributor
notifies You of the non-compliance by some reasonable means, this is the
first time You have received notice of non-compliance with this License
from such Contributor, and You become compliant prior to 30 days after
Your receipt of the notice.
5.2. If You initiate litigation against any entity by asserting a patent
infringement claim (excluding declaratory judgment actions,
counter-claims, and cross-claims) alleging that a Contributor Version
directly or indirectly infringes any patent, then the rights granted to
You by any and all Contributors for the Covered Software under Section
2.1 of this License shall terminate.
5.3. In the event of termination under Sections 5.1 or 5.2 above, all
end user license agreements (excluding distributors and resellers) which
have been validly granted by You or Your distributors under this License
prior to termination shall survive termination.
************************************************************************
* *
* 6. Disclaimer of Warranty *
* ------------------------- *
* *
* Covered Software is provided under this License on an "as is" *
* basis, without warranty of any kind, either expressed, implied, or *
* statutory, including, without limitation, warranties that the *
* Covered Software is free of defects, merchantable, fit for a *
* particular purpose or non-infringing. The entire risk as to the *
* quality and performance of the Covered Software is with You. *
* Should any Covered Software prove defective in any respect, You *
* (not any Contributor) assume the cost of any necessary servicing, *
* repair, or correction. This disclaimer of warranty constitutes an *
* essential part of this License. No use of any Covered Software is *
* authorized under this License except under this disclaimer. *
* *
************************************************************************
************************************************************************
* *
* 7. Limitation of Liability *
* -------------------------- *
* *
* Under no circumstances and under no legal theory, whether tort *
* (including negligence), contract, or otherwise, shall any *
* Contributor, or anyone who distributes Covered Software as *
* permitted above, be liable to You for any direct, indirect, *
* special, incidental, or consequential damages of any character *
* including, without limitation, damages for lost profits, loss of *
* goodwill, work stoppage, computer failure or malfunction, or any *
* and all other commercial damages or losses, even if such party *
* shall have been informed of the possibility of such damages. This *
* limitation of liability shall not apply to liability for death or *
* personal injury resulting from such party's negligence to the *
* extent applicable law prohibits such limitation. Some *
* jurisdictions do not allow the exclusion or limitation of *
* incidental or consequential damages, so this exclusion and *
* limitation may not apply to You. *
* *
************************************************************************
8. Litigation
-------------
Any litigation relating to this License may be brought only in the
courts of a jurisdiction where the defendant maintains its principal
place of business and such litigation shall be governed by laws of that
jurisdiction, without reference to its conflict-of-law provisions.
Nothing in this Section shall prevent a party's ability to bring
cross-claims or counter-claims.
9. Miscellaneous
----------------
This License represents the complete agreement concerning the subject
matter hereof. If any provision of this License is held to be
unenforceable, such provision shall be reformed only to the extent
necessary to make it enforceable. Any law or regulation which provides
that the language of a contract shall be construed against the drafter
shall not be used to construe this License against a Contributor.
10. Versions of the License
---------------------------
10.1. New Versions
Mozilla Foundation is the license steward. Except as provided in Section
10.3, no one other than the license steward has the right to modify or
publish new versions of this License. Each version will be given a
distinguishing version number.
10.2. Effect of New Versions
You may distribute the Covered Software under the terms of the version
of the License under which You originally received the Covered Software,
or under the terms of any subsequent version published by the license
steward.
10.3. Modified Versions
If you create software not governed by this License, and you want to
create a new license for such software, you may create and use a
modified version of this License if you rename the license and remove
any references to the name of the license steward (except to note that
such modified license differs from this License).
10.4. Distributing Source Code Form that is Incompatible With Secondary
Licenses
If You choose to distribute Source Code Form that is Incompatible With
Secondary Licenses under the terms of this version of the License, the
notice described in Exhibit B of this License must be attached.
Exhibit A - Source Code Form License Notice
-------------------------------------------
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/.
If it is not possible or desirable to put the notice in a particular
file, then You may include the notice in a location (such as a LICENSE
file in a relevant directory) where a recipient would be likely to look
for such a notice.
You may add additional accurate notices of copyright ownership.
Exhibit B - "Incompatible With Secondary Licenses" Notice
---------------------------------------------------------
This Source Code Form is "Incompatible With Secondary Licenses", as
defined by the Mozilla Public License, v. 2.0.
README.md
-141
View File
@@ -1,141 +0,0 @@
# RTPhone Platform
RTPhone is a comprehensive real-time communication (RTC) platform that provides a complete software stack for building VoIP/SIP-based communication applications. Developed by VoIP Objects (Sevana), RTPhone delivers production-ready voice communication capabilities with extensive codec support and cross-platform compatibility.
## Overview
RTPhone serves as a static library (`librtphone.a`) that can be integrated into larger telephony and communication systems. It provides a JSON-based command interface for easy integration and control, making it suitable for building softphones, PBX systems, WebRTC gateways, and carrier-grade voice solutions.
## Key Features
### Audio Codec Support
RTPhone supports an extensive range of audio codecs:
**Standard Codecs:**
- G.711 (A-law/¼-law)
- G.722 (16kHz wideband)
- G.729
- GSM (Full Rate, Half Rate, Enhanced Full Rate)
- iLBC (20ms/30ms)
- ISAC (16kHz/32kHz)
**Advanced Codecs:**
- AMR-NB/AMR-WB (Adaptive Multi-Rate Narrowband/Wideband) - please be aware - there is no patents for AMR codecs usage included ! You should acquire them on your own.
- EVS (Enhanced Voice Services) - 3GPP's latest codec. Again - please be aware - there is no patents for EVS codec usage included ! You should acquire them on your own.
- Opus - Modern low-latency codec
- Speex (with acoustic echo cancellation)
**Codec Features:**
- Bandwidth-efficient and octet-aligned modes
- IuUP (Iu User Plane) protocol support for 3G networks
- Dynamic codec switching
- Packet loss concealment (PLC)
- Comfort noise generation (CNG)
### Network & Protocol Support
**SIP Features:**
- Full SIP 2.0 implementation via reSIProcate
- Multiple transport protocols (UDP, TCP, TLS)
- Registration, authentication, and session management
- SIP MESSAGE, presence, and REFER support
**Media Transport:**
- RTP/RTCP for media streaming
- SRTP for secure media
- ICE for NAT traversal with STUN/TURN support
- WebRTC integration components
- IPv4 and IPv6 support
### Cross-Platform Audio Support
- DirectSound/WMME (Windows)
- Core Audio (macOS/iOS)
- ALSA/PulseAudio (Linux)
- Oboe (Android) for low-latency audio
- PortAudio fallback support
### Audio Quality Features
- 48kHz sample rate support
- Acoustic Echo Cancellation (AEC)
- Audio resampling and format conversion
- Multi-channel audio mixing
- Perceptual Voice Quality Assessment (PVQA)
## Architecture
The platform is organized into several core modules:
- **Engine/Agent**: JSON-based command interface
- **Engine/Endpoint**: SIP user agent implementation
- **Engine/Media**: Audio codec management and processing
- **Engine/Audio**: Cross-platform audio I/O handling
- **Engine/Helper**: Utility functions (networking, logging, threading)
## Supported Platforms
- Linux (x64, ARM/Raspberry Pi)
- Windows (32/64-bit)
- macOS
- Android (with Oboe integration)
- iOS
## Building
RTPhone uses a CMake-based build system with cross-compilation support:
### Linux
```bash
python3 build_linux.py
```
### Android
```bash
python3 build_android.py
# or
./build_android.sh
```
### Dependencies
- CMake 3.10+
- OpenSSL 1.1+
- Boost libraries
- Platform-specific audio libraries
## Recent Updates
Recent development has focused on:
- AMR codec parsing and decoding improvements
- Octet-aligned mode fixes for AMR-WB
- RTP SSRC handling enhancements
- Build system optimizations
- Code modernization to C++20
## Use Cases
RTPhone is good for building:
- VoIP softphones and mobile applications
- PBX and telephony server systems
- RTP proxies
- Carrier-grade voice communication platforms
- 3GPP/IMS-compliant systems
## Security
RTPhone includes comprehensive security features:
- OpenSSL 1.1 integration for encryption
- TLS transport layer security
- SRTP media encryption
- Certificate management support
## Integration
The platform provides a developer-friendly interface with:
- Event-driven architecture
- Comprehensive logging system
- Modern C++20 codebase
For detailed integration instructions and API documentation, please refer to the source code and header files in the `/src/engine/` directory.
## License
Our source code is licensed under the MPL license. Naturally, any third-party components we use are subject to their respective licenses.
build_android.py
-45
View File
@@ -1,45 +0,0 @@
#!/usr/bin/python3
from pathlib import Path
import os
import multiprocessing
import shutil
# Temporary build directory
DIR_BUILD = 'build_android'
# Android NDK home directory
NDK_HOME = os.environ['ANDROID_NDK_HOME']
VCPKG_ROOT = os.environ['VCPKG_ROOT']
# CMake toolchain file
TOOLCHAIN_FILE = f'{NDK_HOME}/build/cmake/android.toolchain.cmake'
TOOLCHAIN_FILE_VCPKG=f'{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake'
# This directory
DIR_THIS = Path(__file__).parent.resolve()
# Path to app
DIR_SOURCE = (DIR_THIS / '../src').resolve()
def make_build() -> Path:
if Path(DIR_BUILD).exists():
shutil.rmtree(DIR_BUILD)
os.mkdir(DIR_BUILD)
os.chdir(DIR_BUILD)
cmd = f'cmake -DCMAKE_TOOLCHAIN_FILE={TOOLCHAIN_FILE} -DCMAKE_TOOLCHAIN_FILE={TOOLCHAIN_FILE_VCPKG} '
cmd += f'-DANDROID_NDK=$NDK_HOME '
cmd += f'-DANDROID_PLATFORM=24 '
cmd += f'-DCMAKE_BUILD=Release '
cmd += f'-DANDROID_ABI="arm64-v8a" '
cmd += '../src'
retcode = os.system(cmd)
if retcode != 0:
raise RuntimeError('Problem when configuring the project')
cmd = f'cmake --build . -j {multiprocessing.cpu_count()}'
retcode = os.system(cmd)
if retcode != 0:
raise RuntimeError('Problem when building the project')
if __name__ == '__main__':
make_build()
build_linux.py
-38
View File
@@ -1,38 +0,0 @@
#!/usr/bin/env python3
from pathlib import Path
import os
import multiprocessing
import shutil
# Temporary build directory
DIR_BUILD = 'build_linux'
# This directory
DIR_THIS = Path(__file__).parent.resolve()
# Path to app
DIR_SOURCE = (DIR_THIS / '../src').resolve()
def make_build() -> Path:
if Path(DIR_BUILD).exists():
shutil.rmtree(DIR_BUILD)
os.mkdir(DIR_BUILD)
os.chdir(DIR_BUILD)
# OPUS_X86_MAY_HAVE_SSE4_1 is for clang builds
cmd = f'cmake ../src -G Ninja -D OPUS_X86_MAY_HAVE_SSE4_1=ON'
retcode = os.system(cmd)
if retcode != 0:
raise RuntimeError('Problem when configuring the project')
cmd = f'cmake --build . -j {multiprocessing.cpu_count()}'
retcode = os.system(cmd)
if retcode != 0:
raise RuntimeError('Problem when building the project')
os.chdir('..')
return Path(DIR_BUILD) / 'librtphone.a'
if __name__ == '__main__':
p = make_build()
print (f'Built: {p}')
build_windows.py
-55
View File
@@ -1,55 +0,0 @@
#!/usr/bin/env python3
# This script is just to check if the library is buildable
from pathlib import Path
import os
import multiprocessing
import shutil
# Temporary build directory
DIR_BUILD = 'build_windows'
# This directory
DIR_THIS = Path(__file__).parent.resolve()
# Path to app
DIR_SOURCE = (DIR_THIS / '../src').resolve()
CMAKE_GENERATOR = '-G "Visual Studio 17 2022" -A x64'
# Not used yet
CMAKE_BUILD_TYPE = 'Debug'
def make_build() -> Path:
if Path(DIR_BUILD).exists():
shutil.rmtree(DIR_BUILD)
os.mkdir(DIR_BUILD)
os.chdir(DIR_BUILD)
if os.environ['VCPKG_ROOT']:
vcpkg_root = os.environ['VCPKG_ROOT']
else:
vcpkg_root = 'C:\\tools\\vcpkg'
if not Path(vcpkg_root).exists():
print(f'Failed to find vcpkg (OpenSSL libraries needed)')
exit(1)
cmd = f'cmake ../src {CMAKE_GENERATOR} -D CMAKE_TOOLCHAIN_FILE="{vcpkg_root}\\scripts\\buildsystems\\vcpkg.cmake"'
print(cmd)
retcode = os.system(cmd)
if retcode != 0:
raise RuntimeError('Problem when configuring the project')
cmd = f'cmake --build . -j {multiprocessing.cpu_count()}'
retcode = os.system(cmd)
if retcode != 0:
raise RuntimeError('Problem when building the project')
os.chdir('..')
return Path(DIR_BUILD) / 'Debug' / 'rtphone.lib'
if __name__ == '__main__':
p = make_build()
print (f'Built: {p}')
count_cpp_stats.py
-123
View File
@@ -1,123 +0,0 @@
#!/usr/bin/env python3
"""
Count C/C++ files and lines in the project.
Works on both Linux and Windows.
"""
import os
import sys
from pathlib import Path
# C/C++ file extensions
CPP_EXTENSIONS = {'.c', '.cc', '.cpp', '.cxx', '.h', '.hh', '.hpp', '.hxx'}
def is_cpp_file(filepath: Path) -> bool:
"""Check if file has a C/C++ extension."""
return filepath.suffix.lower() in CPP_EXTENSIONS
def count_lines_in_file(filepath: Path) -> int:
"""Count lines in a single file."""
try:
with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
return sum(1 for _ in f)
except (IOError, OSError):
return 0
def collect_cpp_files(root_dir: Path) -> list[Path]:
"""Collect all C/C++ files recursively from root directory."""
cpp_files = []
for path in root_dir.rglob('*'):
if path.is_file() and is_cpp_file(path):
cpp_files.append(path)
return cpp_files
def get_directory_stats(root_dir: Path, cpp_files: list[Path]) -> dict[str, dict]:
"""Get statistics grouped by immediate subdirectories."""
stats = {}
# Initialize stats for immediate subdirectories
for item in root_dir.iterdir():
if item.is_dir():
stats[item.name] = {'files': 0, 'lines': 0}
# Also count files directly in root
stats['.'] = {'files': 0, 'lines': 0}
for filepath in cpp_files:
try:
# Get relative path from root
rel_path = filepath.relative_to(root_dir)
# Determine which immediate subdirectory this file belongs to
if len(rel_path.parts) == 1:
# File is directly in root
dir_key = '.'
else:
# File is in a subdirectory
dir_key = rel_path.parts[0]
if dir_key in stats:
line_count = count_lines_in_file(filepath)
stats[dir_key]['files'] += 1
stats[dir_key]['lines'] += line_count
except (ValueError, IndexError):
continue
return stats
def main():
# Use current directory as root, or accept a path argument
if len(sys.argv) > 1:
root_dir = Path(sys.argv[1]).resolve()
else:
root_dir = Path.cwd()
if not root_dir.exists():
print(f"Error: Directory '{root_dir}' does not exist.")
sys.exit(1)
print(f"Scanning C/C++ files in: {root_dir}")
print("=" * 60)
# Collect all C/C++ files
cpp_files = collect_cpp_files(root_dir)
if not cpp_files:
print("No C/C++ files found.")
sys.exit(0)
# Get directory statistics
dir_stats = get_directory_stats(root_dir, cpp_files)
# Print per-directory statistics
print("\nPer-directory C/C++ statistics:")
print("-" * 60)
print(f"{'Directory':<30} {'Files':>10} {'Lines':>15}")
print("-" * 60)
total_files = 0
total_lines = 0
# Sort directories: root first, then alphabetically
sorted_dirs = sorted(dir_stats.keys(), key=lambda x: (x != '.', x.lower()))
for dir_name in sorted_dirs:
stat = dir_stats[dir_name]
if stat['files'] > 0:
display_name = '(root)' if dir_name == '.' else dir_name
print(f"{display_name:<30} {stat['files']:>10} {stat['lines']:>15,}")
total_files += stat['files']
total_lines += stat['lines']
print("-" * 60)
print(f"{'TOTAL':<30} {total_files:>10} {total_lines:>15,}")
print("=" * 60)
if __name__ == '__main__':
main()
run_ci.sh
-23
View File
@@ -1,23 +0,0 @@
#!/bin/bash
SEND_MSG="/var/ci/conformance_ci/send_telegram_message.py"
mkdir -p build
cd build
# Configure
cmake ../src
if [ $? -ne 0 ]; then
/usr/bin/python3 $SEND_MSG "rtphone cmake failed. $BUILD_URL"
exit 1
fi
# Build
make -j2
if [ $? -ne 0 ]; then
/usr/bin/python3 $SEND_MSG "rtphone build failed. $BUILD_URL"
exit 1
fi
/usr/bin/python3 $SEND_MSG "rtphone builds ok. $BUILD_URL"
src/CMakeLists.txt
+192 -344
View File
@@ -1,381 +1,233 @@
cmake_minimum_required(VERSION 3.20)
project(rtphone)
# Rely on C++ 20
set (CMAKE_CXX_STANDARD 20)
cmake_minimum_required(VERSION 3.0)
macro(configure_msvc_runtime)
if(MSVC)
# Default to statically-linked runtime.
if("${MSVC_RUNTIME}" STREQUAL "")
set(MSVC_RUNTIME "static")
endif()
# Set compiler options.
set(variables
CMAKE_C_FLAGS_DEBUG
CMAKE_C_FLAGS_MINSIZEREL
CMAKE_C_FLAGS_RELEASE
CMAKE_C_FLAGS_RELWITHDEBINFO
CMAKE_CXX_FLAGS_DEBUG
CMAKE_CXX_FLAGS_MINSIZEREL
CMAKE_CXX_FLAGS_RELEASE
CMAKE_CXX_FLAGS_RELWITHDEBINFO
)
if(${MSVC_RUNTIME} STREQUAL "static")
message(STATUS
"rtphone: MSVC -> forcing use of statically-linked runtime."
)
foreach(variable ${variables})
if(${variable} MATCHES "/MD")
string(REGEX REPLACE "/MD" "/MT" ${variable} "${${variable}}")
endif()
endforeach()
else()
message(STATUS
"rtphone: MSVC -> forcing use of dynamically-linked runtime."
)
foreach(variable ${variables})
if(${variable} MATCHES "/MT")
string(REGEX REPLACE "/MT" "/MD" ${variable} "${${variable}}")
endif()
endforeach()
endif()
foreach(variable ${variables})
string(REGEX REPLACE "/Z[iI7]" ""
${variable}
"${${variable}}")
set(${variable} "${${variable}} /Zi /Oy-")
endforeach()
endif()
endmacro()
# Rely on C++ 11
set (CMAKE_CXX_STANDARD 11)
set (CMAKE_CXX_STANDARD_REQUIRED ON)
set (L libs)
set (E engine)
set (rtphone_libs libs)
set (rtphone_engine engine)
option (USE_AMR_CODEC "Use AMR codec. Requires libraries." ON)
option (USE_EVS_CODEC "Use EVS codec." ON)
option (USE_MUSL "Build with MUSL library" OFF)
set (USE_AMR_CODEC OFF CACHE BOOL "Use AMR codec. Requires libraries.")
set (USE_EVS_CODEC OFF CACHE BOOL "Use EVS codec." )
set (USE_OPUS_CODEC OFF CACHE BOOL "Use Opus codec." )
set (USE_PVQA_LIB OFF CACHE BOOL "Build with Sevana PVQA library" )
set (USE_AQUA_LIB OFF CACHE BOOL "Build with Sevana AQuA library" )
set (USE_MUSL OFF CACHE BOOL "Build with MUSL library" )
# PIC code by default
set (CMAKE_POSITION_INDEPENDENT_CODE ON)
set (RUNTIME_CPU_CAPABILITY_DETECTION ON)
set (CMAKE_WARN_DEPRECATED OFF)
find_package(OpenSSL REQUIRED)
set (OPENSSL_SSL OpenSSL::SSL)
set (OPENSSL_CRYPTO OpenSSL::Crypto)
if (NOT DEFINED LIB_PLATFORM)
set (LIB_PLATFORM ${CMAKE_CURRENT_SOURCE_DIR}/../../libraries)
endif()
message("Libraries: ${LIB_PLATFORM}")
set (OPENSSL_INCLUDE ${LIB_PLATFORM}/openssl/1.0/include)
message ("Using OpenSSL include files from ${OPENSSL_INCLUDE}")
message ("Using OpenSSL libs: ${OPENSSL_SSL} and ${OPENSSL_CRYPTO}")
# include_directories(${OPENSSL_INCLUDE})
# Used defines for our project
set (DEFINES -DUSE_OPENSSL)
# Libraries for our project
set (LIBS_STATIC "")
set (LIBS_DYNAMIC "")
# Try to prefer static libraries anyway
set (CMAKE_FIND_LIBRARY_SUFFIXES .a .so .dylib)
# Windows-specific definitions
if (CMAKE_SYSTEM MATCHES "Windows*")
set (DEFINES ${DEFINES} -DTARGET_WIN -D_SILENCE_STDEXT_HASH_DEPRECATION_WARNINGS -D_UNICODE -D_CRT_SECURE_NO_WARNINGS -DNOMINMAX)
set (TARGET_WIN ON)
add_definitions (-DTARGET_WIN -D_SILENCE_STDEXT_HASH_DEPRECATION_WARNINGS -D_UNICODE -D_CRT_SECURE_NO_WARNINGS)
endif()
# Linux-specific definitions
if (CMAKE_SYSTEM MATCHES "Linux*")
set (DEFINES ${DEFINES} -DTARGET_LINUX -DHAVE_NETINET_IN_H)
set (TARGET_LINUX ON)
set (LIBS_STATIC ${LIBS_STATIC} dl)
add_definitions (-DTARGET_LINUX)
endif()
# macOS-specific definitions
if (CMAKE_SYSTEM MATCHES "Darwin*")
set (DEFINES ${DEFINES} -DTARGET_OSX)
set (TARGET_OSX ON)
set (LIBS_STATIC ${LIBS_STATIC} dl)
add_definitions (-DTARGET_OSX)
endif()
if (CMAKE_SYSTEM MATCHES "Android")
# Disable opencore AMR codecs - there is no ready libraries in vcpkg right now
set (USE_AMR_CODEC OFF)
message("Adding the Oboe library")
set (OBOE_DIR libs/oboe)
add_subdirectory (${OBOE_DIR} build_oboe)
add_subdirectory (${OBOE_DIR} ./oboe)
include_directories (${OBOE_DIR}/include)
set (DEFINES ${DEFINES} -DTARGET_ANDROID -DHAVE_NETINET_IN_H)
set (TARGET_ANDROID ON)
set (LIBS_STATIC ${LIBS} oboe)
endif()
if (USE_MUSL)
set (DEFINES ${DEFINES} -DTARGET_MUSL)
set (TARGET_MUSL ON)
add_definitions(-DTARGET_MUSL)
endif()
if (USE_AQUA_LIB)
message("Use AQuA library")
add_definitions( -DUSE_AQUA_LIBRARY )
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/libs/pvqa/include)
endif()
if (USE_PVQA_LIBRARY)
message("Use PVQA libraries")
add_definitions( -DUSE_PVQA_LIBRARY )
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/libs/pvqa/include
${CMAKE_CURRENT_SOURCE_DIR}/libs/pvqa++/include)
endif()
set (RTPHONE_SOURCES
${E}/engine_config.h
${E}/media/MT_Statistics.cpp
${E}/media/MT_WebRtc.cpp
${E}/media/MT_Stream.cpp
${E}/media/MT_SrtpHelper.cpp
${E}/media/MT_SingleAudioStream.cpp
${E}/media/MT_NativeRtpSender.cpp
${E}/media/MT_Dtmf.cpp
${E}/media/MT_CodecList.cpp
${E}/media/MT_Codec.cpp
${E}/media/MT_Box.cpp
${E}/media/MT_AudioStream.cpp
${E}/media/MT_AudioReceiver.cpp
${E}/media/MT_AudioCodec.cpp
${E}/media/MT_CngHelper.cpp
${E}/agent/Agent_Impl.cpp
${E}/agent/Agent_Impl.h
${E}/agent/Agent_AudioManager.cpp
${E}/agent/Agent_AudioManager.h
${E}/endpoint/EP_Account.cpp
${E}/endpoint/EP_Account.h
${E}/endpoint/EP_AudioProvider.cpp
${E}/endpoint/EP_AudioProvider.h
${E}/endpoint/EP_DataProvider.cpp
${E}/endpoint/EP_DataProvider.h
${E}/endpoint/EP_Engine.cpp
${E}/endpoint/EP_Engine.h
${E}/endpoint/EP_NetworkQueue.cpp
${E}/endpoint/EP_NetworkQueue.h
${E}/endpoint/EP_Observer.cpp
${E}/endpoint/EP_Observer.h
${E}/endpoint/EP_Session.cpp
${E}/endpoint/EP_Session.h
${rtphone_engine}/media/MT_Statistics.cpp
${rtphone_engine}/media/MT_WebRtc.cpp
${rtphone_engine}/media/MT_Stream.cpp
${rtphone_engine}/media/MT_SrtpHelper.cpp
${rtphone_engine}/media/MT_SingleAudioStream.cpp
${rtphone_engine}/media/MT_NativeRtpSender.cpp
${rtphone_engine}/media/MT_Dtmf.cpp
${rtphone_engine}/media/MT_CodecList.cpp
${rtphone_engine}/media/MT_Codec.cpp
${rtphone_engine}/media/MT_Box.cpp
${rtphone_engine}/media/MT_AudioStream.cpp
${rtphone_engine}/media/MT_AudioReceiver.cpp
${rtphone_engine}/media/MT_AudioCodec.cpp
${rtphone_engine}/media/MT_CngHelper.cpp
${rtphone_engine}/agent/Agent_Impl.cpp
${rtphone_engine}/agent/Agent_AudioManager.cpp
${rtphone_engine}/endpoint/EP_Account.cpp
${rtphone_engine}/endpoint/EP_AudioProvider.cpp
${rtphone_engine}/endpoint/EP_DataProvider.cpp
${rtphone_engine}/endpoint/EP_Engine.cpp
${rtphone_engine}/endpoint/EP_NetworkQueue.cpp
${rtphone_engine}/endpoint/EP_Observer.cpp
${rtphone_engine}/endpoint/EP_Session.cpp
${E}/media/MT_Statistics.h
${E}/media/MT_WebRtc.h
${E}/media/MT_Stream.h
${E}/media/MT_SrtpHelper.h
${E}/media/MT_SingleAudioStream.h
${E}/media/MT_NativeRtpSender.h
${E}/media/MT_Dtmf.h
${E}/media/MT_CodecList.h
${E}/media/MT_Codec.h
${E}/media/MT_Box.h
${E}/media/MT_AudioStream.h
${E}/media/MT_AudioReceiver.h
${E}/media/MT_AudioCodec.h
${E}/media/MT_CngHelper.h
${rtphone_engine}/media/MT_Statistics.h
${rtphone_engine}/media/MT_WebRtc.h
${rtphone_engine}/media/MT_Stream.h
${rtphone_engine}/media/MT_SrtpHelper.h
${rtphone_engine}/media/MT_SingleAudioStream.h
${rtphone_engine}/media/MT_NativeRtpSender.h
${rtphone_engine}/media/MT_Dtmf.h
${rtphone_engine}/media/MT_CodecList.h
${rtphone_engine}/media/MT_Codec.h
${rtphone_engine}/media/MT_Box.h
${rtphone_engine}/media/MT_AudioStream.h
${rtphone_engine}/media/MT_AudioReceiver.h
${rtphone_engine}/media/MT_AudioCodec.h
${E}/media/MT_Statistics.cpp
${E}/media/MT_WebRtc.cpp
${E}/media/MT_Stream.cpp
${E}/media/MT_SrtpHelper.cpp
${E}/media/MT_SingleAudioStream.cpp
${E}/media/MT_NativeRtpSender.cpp
${E}/media/MT_Dtmf.cpp
${E}/media/MT_CodecList.cpp
${E}/media/MT_Codec.cpp
${E}/media/MT_Box.cpp
${E}/media/MT_AudioStream.cpp
${E}/media/MT_AudioReceiver.cpp
${E}/media/MT_AudioCodec.cpp
${E}/media/MT_CngHelper.cpp
${E}/media/MT_AmrCodec.cpp
${E}/media/MT_EvsCodec.cpp
${E}/media/MT_Statistics.h
${E}/media/MT_WebRtc.h
${E}/media/MT_Stream.h
${E}/media/MT_SrtpHelper.h
${E}/media/MT_SingleAudioStream.h
${E}/media/MT_NativeRtpSender.h
${E}/media/MT_Dtmf.h
${E}/media/MT_CodecList.h
${E}/media/MT_Codec.h
${E}/media/MT_Box.h
${E}/media/MT_AudioStream.h
${E}/media/MT_AudioReceiver.h
${E}/media/MT_AudioCodec.h
${E}/media/MT_CngHelper.h
${E}/media/MT_AmrCodec.h
${E}/media/MT_EvsCodec.h
${E}/helper/HL_AsyncCommand.cpp
${E}/helper/HL_AsyncCommand.h
${E}/helper/HL_Base64.h
${E}/helper/HL_ByteBuffer.h
${E}/helper/HL_Calculator.cpp
${E}/helper/HL_Calculator.h
${E}/helper/HL_CrashRpt.cpp
${E}/helper/HL_CrashRpt.h
${E}/helper/HL_CsvReader.cpp
${E}/helper/HL_CsvReader.h
${E}/helper/HL_Epoll.cpp
${E}/helper/HL_Epoll.h
${E}/helper/HL_Exception.h
${E}/helper/HL_File.cpp
${E}/helper/HL_File.h
${E}/helper/HL_HepSupport.cpp
${E}/helper/HL_HepSupport.h
${E}/helper/HL_InternetAddress.h
${E}/helper/HL_IuUP.cpp
${E}/helper/HL_IuUP.h
${E}/helper/HL_Log.cpp
${E}/helper/HL_Log.h
${E}/helper/HL_NetworkFrame.cpp
${E}/helper/HL_NetworkFrame.h
${E}/helper/HL_NetworkSocket.cpp
${E}/helper/HL_NetworkSocket.h
${E}/helper/HL_Optional.hpp
${E}/helper/HL_OsVersion.cpp
${E}/helper/HL_OsVersion.h
${E}/helper/HL_Pointer.cpp
${E}/helper/HL_Pointer.h
${E}/helper/HL_Process.cpp
${E}/helper/HL_Process.h
${E}/helper/HL_Rtp.cpp
${E}/helper/HL_Rtp.h
${E}/helper/HL_Singletone.cpp
${E}/helper/HL_Singletone.h
${E}/helper/HL_SocketHeap.cpp
${E}/helper/HL_SocketHeap.h
${E}/helper/HL_Statistics.cpp
${E}/helper/HL_Statistics.h
${E}/helper/HL_StreamState.h
${E}/helper/HL_String.cpp
${E}/helper/HL_String.h
${E}/helper/HL_Sync.cpp
${E}/helper/HL_Sync.h
${E}/helper/HL_ThreadPool.cpp
${E}/helper/HL_ThreadPool.h
${E}/helper/HL_Time.cpp
${E}/helper/HL_Time.h
${E}/helper/HL_Types.h
${E}/helper/HL_Types.cpp
${E}/helper/HL_Usb.cpp
${E}/helper/HL_Usb.h
${E}/helper/HL_Uuid.cpp
${E}/helper/HL_Uuid.h
${E}/helper/HL_VariantMap.cpp
${E}/helper/HL_VariantMap.h
${E}/helper/HL_Xcap.cpp
${E}/helper/HL_Xcap.h
${E}/audio/Audio_Resampler.cpp
${E}/audio/Audio_Resampler.h
${E}/audio/Audio_Quality.cpp
${E}/audio/Audio_Quality.h
${E}/audio/Audio_Mixer.cpp
${E}/audio/Audio_Mixer.h
${E}/audio/Audio_Interface.cpp
${E}/audio/Audio_Interface.h
${E}/audio/Audio_Helper.cpp
${E}/audio/Audio_Helper.h
${E}/audio/Audio_DataWindow.cpp
${E}/audio/Audio_DataWindow.h
${E}/audio/Audio_DevicePair.cpp
${E}/audio/Audio_DevicePair.h
${E}/audio/Audio_Player.cpp
${E}/audio/Audio_Player.h
${E}/audio/Audio_Null.cpp
${E}/audio/Audio_Null.h
${E}/audio/Audio_CoreAudio.cpp
${E}/audio/Audio_CoreAudio.h
${E}/audio/Audio_DirectSound.cpp
${E}/audio/Audio_DirectSound.h
${E}/audio/Audio_AndroidOboe.cpp
${E}/audio/Audio_AndroidOboe.h
${E}/audio/Audio_WavFile.cpp
${E}/audio/Audio_WavFile.h
${L}/ice/hmac_sha1_impl.cpp
${L}/ice/hmac_sha1_impl.h
${L}/ice/ICEAction.h
${L}/ice/ICEAddress.cpp
${L}/ice/ICEAddress.h
${L}/ice/ICEAuthTransaction.cpp
${L}/ice/ICEAuthTransaction.h
${L}/ice/ICEBinding.cpp
${L}/ice/ICEBinding.h
${L}/ice/ICEBox.cpp
${L}/ice/ICEBox.h
${L}/ice/ICEBoxImpl.cpp
${L}/ice/ICEBoxImpl.h
${L}/ice/ICEByteBuffer.cpp
${L}/ice/ICEByteBuffer.h
${L}/ice/ICECandidate.cpp
${L}/ice/ICECandidate.h
${L}/ice/ICECandidatePair.cpp
${L}/ice/ICECandidatePair.h
${L}/ice/ICECheckList.cpp
${L}/ice/ICECheckList.h
${L}/ice/ICECRC32.cpp
${L}/ice/ICECRC32.h
${L}/ice/ICEError.cpp
${L}/ice/ICEError.h
${L}/ice/ICEEvent.h
${L}/ice/ICELog.cpp
${L}/ice/ICELog.h
${L}/ice/ICEMD5.cpp
${L}/ice/ICEMD5.h
${L}/ice/ICENetworkHelper.cpp
${L}/ice/ICENetworkHelper.h
${L}/ice/ICEPacketTimer.cpp
${L}/ice/ICEPacketTimer.h
${L}/ice/ICEPlatform.cpp
${L}/ice/ICEPlatform.h
${L}/ice/ICERelaying.cpp
${L}/ice/ICERelaying.h
${L}/ice/ICESession.cpp
${L}/ice/ICESession.h
${L}/ice/ICESHA1.cpp
${L}/ice/ICESHA1.h
${L}/ice/ICESocket.h
${L}/ice/ICEStream.cpp
${L}/ice/ICEStream.h
${L}/ice/ICEStunAttributes.cpp
${L}/ice/ICEStunAttributes.h
${L}/ice/ICEStunConfig.cpp
${L}/ice/ICEStunConfig.h
${L}/ice/ICEStunMessage.cpp
${L}/ice/ICEStunMessage.h
${L}/ice/ICEStunTransaction.cpp
${L}/ice/ICEStunTransaction.h
${L}/ice/ICESync.cpp
${L}/ice/ICESync.h
${L}/ice/ICETime.cpp
${L}/ice/ICETime.h
${L}/ice/ICETransactionList.cpp
${L}/ice/ICETransactionList.h
${L}/ice/ICETypes.h
${L}/ice/md5_impl.cpp
${L}/ice/md5_impl.h
${rtphone_engine}/media/MT_CngHelper.h
${rtphone_engine}/agent/Agent_Impl.h
${rtphone_engine}/agent/Agent_AudioManager.h
${rtphone_engine}/endpoint/EP_Account.h
${rtphone_engine}/endpoint/EP_AudioProvider.h
${rtphone_engine}/endpoint/EP_DataProvider.h
${rtphone_engine}/endpoint/EP_Engine.h
${rtphone_engine}/endpoint/EP_NetworkQueue.h
${rtphone_engine}/endpoint/EP_Observer.h
${rtphone_engine}/endpoint/EP_Session.h
)
if (USE_AMR_CODEC)
add_definitions(-DUSE_AMR_CODEC)
set(RTPHONE_SOURCES ${RTPHONE_SOURCES} ${rtphone_engine}/media/MT_AmrCodec.cpp ${rtphone_engine}/media/MT_AmrCodec.h)
endif()
if (USE_EVS_CODEC)
add_definitions(-DUSE_EVS_CODEC)
set(RTPHONE_SOURCES ${RTPHONE_SOURCES} ${rtphone_engine}/media/MT_EvsCodec.cpp ${rtphone_engine}/media/MT_EvsCodec.h)
endif()
if (USE_OPUS_CODEC)
add_definitions(-DUSE_OPUS_CODEC)
endif()
add_library (rtphone STATIC ${RTPHONE_SOURCES})
add_subdirectory(${L}/resiprocate)
add_subdirectory(${L}/jrtplib/src)
add_subdirectory(${L}/libg729)
add_subdirectory(${rtphone_libs}/resiprocate)
add_subdirectory(${rtphone_libs}/ice)
add_subdirectory(${rtphone_libs}/jrtplib/src)
add_subdirectory(${rtphone_libs}/libg729)
if (USE_EVS_CODEC)
add_subdirectory(${L}/libevs)
add_subdirectory(${rtphone_libs}/libevs)
endif()
add_subdirectory(${L}/libgsm)
add_subdirectory(${L}/gsmhr)
add_subdirectory(${L}/g722)
add_subdirectory(${L}/speexdsp)
add_subdirectory(${L}/libsrtp)
add_subdirectory(${L}/webrtc)
add_subdirectory(${L}/opus)
add_subdirectory(${rtphone_libs}/libgsm)
add_subdirectory(${rtphone_libs}/gsmhr)
add_subdirectory(${rtphone_libs}/g722)
add_subdirectory(${rtphone_libs}/speexdsp)
add_subdirectory(${rtphone_libs}/srtp)
add_subdirectory(${rtphone_libs}/webrtc)
add_subdirectory(${rtphone_engine}/helper)
add_subdirectory(${rtphone_engine}/audio)
add_subdirectory(${rtphone_engine}/media)
# Suppose the subproject defines target "mylib"
if(MSVC)
# target_compile_options(opus PRIVATE /O2 /DNDEBUG)
# Optional: enable whole program optimization on MSVC
# target_compile_options(mylib PRIVATE /GL)
# target_link_options(mylib PRIVATE /LTCG)
else()
target_compile_options(opus PRIVATE -O3 -DNDEBUG)
set (LIBS ice_stack jrtplib g729_codec gsm_codec
gsmhr_codec g722_codec srtp resiprocate helper_lib audio_lib webrtc speexdsp
uuid)
if (CMAKE_SYSTEM MATCHES "Win*")
set (LIBS ${LIBS} )
else ()
set (LIBS ${LIBS} dl uuid)
endif ()
if (CMAKE_SYSTEM MATCHES "Android")
set (LIBS ${LIBS} oboe)
endif()
set (LIBS_STATIC ${LIBS_STATIC} jrtplib g729_codec gsm_codec opus
gsmhr_codec g722_codec srtp3 resiprocate webrtc speexdsp)
if (USE_AMR_CODEC)
message("Media: AMR NB and WB codecs will be included")
add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/libs/opencore-amr build_opencore)
set (OPENCORE_AMRWB opencore-amrwb)
set (OPENCORE_AMRNB opencore-amrnb)
set (LIBS ${LIBS})
endif (USE_AMR_CODEC)
set (DEFINES ${DEFINES} -DUSE_AMR_CODEC)
set (LIBS_STATIC ${LIBS_STATIC} ${OPENCORE_AMRNB} ${OPENCORE_AMRWB})
endif()
target_link_libraries(rtphone
ice_stack jrtplib g729_codec gsm_codec
gsmhr_codec g722_codec srtp resiprocate
helper_lib
audio_lib
webrtc
speexdsp
uuid
${OPENSSL_SSL}
${OPENSSL_CRYPTO}
${LIBS} )
if (USE_EVS_CODEC)
message("Media: EVS codec will be included.")
set (DEFINES ${DEFINES} -DUSE_EVS_CODEC)
set (LIBS_STATIC ${LIBS_STATIC} evs_codec)
endif()
target_compile_definitions(rtphone PUBLIC ${DEFINES} )
if (TARGET_LINUX)
# PRIVATE, not PUBLIC: rtphone is a STATIC library, so these link options are
# never used to build rtphone itself and must not propagate to consumers.
# As PUBLIC they leaked into every consumer's LINK_FLAGS as an adjacent
# "-Wl,-Bstatic -Wl,-Bdynamic" pair (the wrapped libraries land in a separate
# LINK_LIBRARIES section, so nothing is actually wrapped). The trailing
# -Bdynamic forced the linker back into dynamic-search mode, which broke
# fully-static consumers (e.g. vq-core built with SERVER_STATIC_LINKING=ON:
# "attempted static link of dynamic object libz.so").
target_link_options(rtphone PRIVATE -Wl,-Bstatic)
target_compile_options(rtphone PUBLIC -Wno-deprecated -Wno-deprecated-declarations)
endif()
target_link_libraries(rtphone PUBLIC ${LIBS_STATIC})
if (TARGET_LINUX)
target_link_options(rtphone PRIVATE -Wl,-Bdynamic)
endif()
target_include_directories(rtphone
PUBLIC
@@ -383,19 +235,15 @@ target_include_directories(rtphone
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/engine>
${CMAKE_CURRENT_SOURCE_DIR}/libs
${LIB_PLATFORM}/opus/include
${E}/helper
${E}/audio
${E}/media
${L}
${L}/ice
PRIVATE
${L}/libevs/lib_com
${L}/libevs/lib_enc
${L}/libevs/lib_dec
${L}/speex/include
${L}/libs/json
${CMAKE_CURRENT_SOURCE_DIR}/libs/
${CMAKE_CURRENT_SOURCE_DIR}/libs/libevs/lib_com
${CMAKE_CURRENT_SOURCE_DIR}/libs/libevs/lib_enc
${CMAKE_CURRENT_SOURCE_DIR}/libs/libevs/lib_dec
${CMAKE_CURRENT_SOURCE_DIR}/libs/speex/include
${CMAKE_CURRENT_SOURCE_DIR}/libs/opus/include/
${CMAKE_CURRENT_SOURCE_DIR}/libs/json
)
find_package(OpenSSL REQUIRED)
target_link_libraries(rtphone PUBLIC OpenSSL::SSL)
target_link_libraries(rtphone PUBLIC OpenSSL::Crypto)
# For MSVC static builds
configure_msvc_runtime()
src/engine/agent/Agent_AudioManager.cpp
+120 -133
View File
@@ -1,206 +1,193 @@
/* Copyright(C) 2007-2023 VoIP objects (voipobjects.com)
/* Copyright(C) 2007-2017 VoIP objects (voipobjects.com)
* 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/. */
#include "Agent_AudioManager.h"
#include "../engine/audio/Audio_WavFile.h"
#include "../engine/helper/HL_String.h"
#include "../engine/audio/Audio_Null.h"
#include "HL_String.h"
#if defined(TARGET_ANDROID)
#include "../engine/audio/Audio_Android.h"
# include "../engine/audio/Audio_Android.h"
#endif
#define LOG_SUBSYSTEM "audio"
#define LOG_SUBSYSTEM "AudioManager"
AudioManager::AudioManager() : mTerminal(nullptr), mAudioMonitoring(nullptr)
// ---------------- AudioManager -------------
//static AudioManager GAudioManager;
AudioManager::AudioManager()
:mTerminal(nullptr)
{
mPlayer.setDelegate(this);
mPlayer.setDelegate(this);
}
AudioManager::~AudioManager()
{
// stop();
//stop();
}
AudioManager& AudioManager::instance()
{
static std::shared_ptr<AudioManager> GAudioManager;
if (!GAudioManager)
GAudioManager = std::make_shared<AudioManager>();
return *GAudioManager;
}
void AudioManager::setTerminal(MT::Terminal* terminal)
{
mTerminal = terminal;
mTerminal = terminal;
}
MT::Terminal* AudioManager::terminal()
{
return mTerminal;
}
void AudioManager::setAudioMonitoring(Audio::DataConnection* monitoring)
{
mAudioMonitoring = monitoring;
}
Audio::DataConnection* AudioManager::audioMonitoring()
{
return mAudioMonitoring;
return mTerminal;
}
#define LOCK_MANAGER std::unique_lock<std::mutex> l(mGuard)
void AudioManager::start(int usageId)
{
assert(mTerminal);
LOCK_MANAGER;
assert(mTerminal);
LOCK_MANAGER;
ICELogInfo(<< "Start main audio with usage id " << usageId);
ICELogInfo(<< "Start main audio with usage id " << usageId);
if (mUsage.obtain(usageId) > 1)
return;
if (mUsage.obtain(usageId) > 1)
return;
// Maybe it is time to initialize global audio support
if (Audio::OsEngine::instance())
Audio::OsEngine::instance()->open();
if (Audio::OsEngine::instance())
Audio::OsEngine::instance()->open();
if (!mAudioInput || !mAudioOutput)
{
// Disable AEC for now - because PVQA conflicts with speex AEC.
std::shared_ptr<Audio::Enumerator> enumerator(Audio::Enumerator::make(usageId == atNull));
if (!mTerminal->audio())
{
auto audio = std::make_shared<Audio::DevicePair>();
audio->setAgc(true);
audio->setAec(false);
audio->setMonitoring(mAudioMonitoring);
if (!mAudioInput || !mAudioOutput)
{
// Disable AEC for now - because PVQA conflicts with speex AEC.
std::shared_ptr<Audio::Enumerator> enumerator(Audio::Enumerator::make(usageId == atNull));
if (!mTerminal->audio())
mTerminal->setAudio(std::make_shared<Audio::DevicePair>(false, true));
mTerminal->setAudio(audio);
}
if (!mAudioInput)
{
enumerator->open(Audio::myMicrophone);
int inputIndex = enumerator->indexOfDefaultDevice();
if (!mAudioInput)
{
enumerator->open(Audio::myMicrophone);
int inputIndex = enumerator->indexOfDefaultDevice();
// Construct and set to terminal's audio pair input device
if (usageId != atNull)
mAudioInput = Audio::PInputDevice(Audio::InputDevice::make(enumerator->idAt(inputIndex)));
else
mAudioInput = Audio::PInputDevice(new Audio::NullInputDevice());
// Construct default platform input device
if (usageId != atNull)
mAudioInput = Audio::PInputDevice(Audio::InputDevice::make(enumerator->idAt(inputIndex)));
else
mAudioInput = Audio::PInputDevice(new Audio::NullInputDevice());
}
// Bind input to the terminal's device pair regardless of whether it was
// just constructed or externally injected via setAudioInput().
mTerminal->audio()->setInput(mAudioInput);
mTerminal->audio()->setInput(mAudioInput);
}
if (!mAudioOutput)
{
Audio::Enumerator* enumerator = Audio::Enumerator::make(usageId == atNull);
enumerator->open(Audio::mySpeaker);
int outputIndex = enumerator->indexOfDefaultDevice();
if (!mAudioOutput)
{
Audio::Enumerator *enumerator = Audio::Enumerator::make(usageId == atNull);
enumerator->open(Audio::mySpeaker);
int outputIndex = enumerator->indexOfDefaultDevice();
// Construct default platform output device
if (usageId != atNull)
{
if (outputIndex >= enumerator->count())
outputIndex = 0;
// Construct and set terminal's audio pair output device
if (usageId != atNull)
{
if (outputIndex >= enumerator->count())
outputIndex = 0;
mAudioOutput = Audio::POutputDevice(Audio::OutputDevice::make(enumerator->idAt(outputIndex)));
}
else
mAudioOutput = Audio::POutputDevice(new Audio::NullOutputDevice());
}
mTerminal->audio()->setOutput(mAudioOutput);
}
mAudioOutput = Audio::POutputDevice(
Audio::OutputDevice::make(enumerator->idAt(outputIndex)));
}
else
mAudioOutput = Audio::POutputDevice(new Audio::NullOutputDevice());
// Open audio
if (mAudioInput)
mAudioInput->open();
if (mAudioOutput)
mAudioOutput->open();
mTerminal->audio()->setOutput(mAudioOutput);
}
}
// Open audio
if (mAudioInput)
mAudioInput->open();
if (mAudioOutput)
mAudioOutput->open();
}
void AudioManager::close()
{
mUsage.clear();
if (mAudioInput)
{
mAudioInput->close();
mAudioInput.reset();
}
mUsage.clear();
if (mAudioInput)
{
mAudioInput->close();
mAudioInput.reset();
}
if (mAudioOutput)
{
mAudioOutput->close();
mAudioOutput.reset();
}
mPlayer.setOutput(Audio::POutputDevice());
if (mAudioOutput)
{
mAudioOutput->close();
mAudioOutput.reset();
}
mPlayer.setOutput(Audio::POutputDevice());
}
void AudioManager::stop(int usageId)
{
LOCK_MANAGER;
LOCK_MANAGER;
ICELogInfo(<< "Stop main audio with usage id " << usageId);
if (mTerminal)
{
if (mTerminal->audio())
mTerminal->audio()->player().release(usageId);
}
ICELogInfo( << "Stop main audio with usage id " << usageId);
if (mTerminal)
{
if (mTerminal->audio())
mTerminal->audio()->player().release(usageId);
}
if (!mUsage.release(usageId))
{
close();
if (!mUsage.release(usageId))
{
close();
// Reset device pair on terminal side
mTerminal->setAudio(Audio::PDevicePair());
// Reset device pair on terminal side
mTerminal->setAudio(Audio::PDevicePair());
if (Audio::OsEngine::instance())
Audio::OsEngine::instance()->close();
}
}
void AudioManager::setAudioInput(Audio::PInputDevice input)
{
LOCK_MANAGER;
mAudioInput = std::move(input);
}
void AudioManager::setAudioOutput(Audio::POutputDevice output)
{
LOCK_MANAGER;
mAudioOutput = std::move(output);
if (Audio::OsEngine::instance())
Audio::OsEngine::instance()->close();
}
}
void AudioManager::startPlayFile(int usageId, const std::string& path, AudioTarget target, LoopMode lm, int timelimit)
{
// Check if file exists
Audio::PWavFileReader r = std::make_shared<Audio::WavFileReader>();
// Check if file exists
Audio::PWavFileReader r = std::make_shared<Audio::WavFileReader>();
#ifdef TARGET_WIN
r->open(strx::makeTstring(path));
r->open(StringHelper::makeTstring(path));
#else
r->open(path);
r->open(path);
#endif
if (!r->isOpened())
{
ICELogError(<< "Cannot open file to play");
return;
}
if (!r->isOpened())
{
ICELogError(<< "Cannot open file to play");
return;
}
// Delegate processing to existing audio device pair manager
mTerminal->audio()->player().add(usageId, r, lm == lmLoopAudio, timelimit);
start(usageId);
// Delegate processing to existing audio device pair manager
mTerminal->audio()->player().add(usageId, r, lm == lmLoopAudio, timelimit);
start(usageId);
}
void AudioManager::stopPlayFile(int usageId)
{
stop(usageId);
mPlayer.release(usageId);
stop(usageId);
mPlayer.release(usageId);
}
void AudioManager::onFilePlayed(Audio::Player::PlaylistItem& item) {}
void AudioManager::onFilePlayed(Audio::Player::PlaylistItem& item)
{
}
void AudioManager::process()
{
mPlayer.releasePlayed();
std::vector<int> ids;
mTerminal->audio()->player().retrieveUsageIds(ids);
for (int id : ids)
stop(id);
mPlayer.releasePlayed();
std::vector<int> ids;
mTerminal->audio()->player().retrieveUsageIds(ids);
for (unsigned i=0; i<ids.size(); i++)
stop(ids[i]);
}
src/engine/agent/Agent_AudioManager.h
+52 -59
View File
@@ -8,87 +8,80 @@
#include "../engine/audio/Audio_Interface.h"
#include "../engine/audio/Audio_Player.h"
#include "../engine/endpoint/EP_Engine.h"
#include "../engine/media/MT_Box.h"
#include "../engine/helper/HL_Log.h"
#include "../engine/helper/HL_Sync.h"
enum
{
AudioPrefix_Ring = 1,
AudioPrefix_Zero,
AudioPrefix_One,
AudioPrefix_Two,
AudioPrefix_Three,
AudioPrefix_Four,
AudioPrefix_Five,
AudioPrefix_Six,
AudioPrefix_Seven,
AudioPrefix_Eight,
AudioPrefix_Nine,
AudioPrefix_Asterisk,
AudioPrefix_Diez
AudioPrefix_Ring = 1,
AudioPrefix_Zero,
AudioPrefix_One,
AudioPrefix_Two,
AudioPrefix_Three,
AudioPrefix_Four,
AudioPrefix_Five,
AudioPrefix_Six,
AudioPrefix_Seven,
AudioPrefix_Eight,
AudioPrefix_Nine,
AudioPrefix_Asterisk,
AudioPrefix_Diez
};
#define AudioSessionCoeff 64
class AudioManager : public Audio::Player::EndOfAudioDelegate
class AudioManager: public Audio::Player::EndOfAudioDelegate
{
public:
AudioManager();
virtual ~AudioManager();
AudioManager();
virtual ~AudioManager();
// static AudioManager& instance();
static AudioManager& instance();
// Enforces to close audio devices. Used to shutdown AudioManager on exit from application
void close();
// Enforces to close audio devices. Used to shutdown AudioManager on exit from application
void close();
// Terminal and settings must be available for AudioManager
void setTerminal(MT::Terminal* terminal);
MT::Terminal* terminal();
// Terminal and settings must be available for AudioManager
void setTerminal(MT::Terminal* terminal);
MT::Terminal* terminal();
void setAudioMonitoring(Audio::DataConnection* monitoring);
Audio::DataConnection* audioMonitoring();
// Start/stop methods relies on usage counter; only first start and last stop opens/closes devices actually
void start(int usageId);
void stop(int usageId);
// Start/stop methods relies on usage counter; only first start and last stop opens/closes devices actually
void start(int usageId);
void stop(int usageId);
enum AudioTarget
{
atNull,
atReceiver,
atRinger
};
// Inject a custom input device. Must be called before start(): when set,
// start() skips construction of the default platform microphone. Pass an
// empty pointer to clear the override.
void setAudioInput(Audio::PInputDevice input);
void setAudioOutput(Audio::POutputDevice output);
enum LoopMode
{
lmLoopAudio,
lmNoloop
};
enum AudioTarget
{
atNull,
atReceiver,
atRinger
};
void startPlayFile(int usageId, const std::string& path, AudioTarget target, LoopMode lm, int timelimit = 0);
void stopPlayFile(int usageId);
enum LoopMode
{
lmLoopAudio,
lmNoloop
};
void onFilePlayed(Audio::Player::PlaylistItem& item);
void startPlayFile(int usageId, const std::string& path, AudioTarget target, LoopMode lm, int timelimit = 0);
void stopPlayFile(int usageId);
void onFilePlayed(Audio::Player::PlaylistItem& item);
// Must be called from main loop to release used audio devices
void process();
// Must be called from main loop to release used audio devices
void process();
protected:
Audio::PInputDevice mAudioInput;
Audio::POutputDevice mAudioOutput;
Audio::Player mPlayer;
MT::Terminal* mTerminal;
Audio::DataConnection* mAudioMonitoring;
Audio::PInputDevice mAudioInput;
Audio::POutputDevice mAudioOutput;
Audio::Player mPlayer;
MT::Terminal* mTerminal;
std::map<int, int> UsageMap;
UsageCounter mUsage;
std::mutex mGuard;
std::map<int, int> UsageMap;
UsageCounter mUsage;
std::mutex mGuard;
};
#endif
src/engine/agent/Agent_Impl.cpp
+324 -218
View File
@@ -3,12 +3,17 @@
#include "helper/HL_String.h"
#include "helper/HL_StreamState.h"
#include "helper/HL_VariantMap.h"
// #include "helper/HL_CsvReader.h"
// #include "helper/HL_Base64.h"
#include "media/MT_CodecList.h"
#include "audio/Audio_Null.h"
// #include <fstream>
#include "helper/HL_CsvReader.h"
#include "helper/HL_Base64.h"
#include <fstream>
#if defined(USE_PVQA_LIBRARY)
# include "pvqa++.h"
#endif
#if defined(USE_AQUA_LIBRARY)
# include "aqua++.h"
#endif
const std::string Status_Ok = "ok";
const std::string Status_SessionNotFound = "session not found";
@@ -17,11 +22,11 @@ const std::string Status_FailedToOpenFile = "failed to open file";
const std::string Status_NoActiveProvider = "no active provider";
const std::string Status_NoMediaAction = "no valid media action";
const std::string Status_NoCommand = "no valid command";
const std::string Status_NoAudioManager = "no audio manager";
#define LOG_SUBSYSTEM "agent"
#define LOG_SUBSYSTEM "Agent"
AgentImpl::AgentImpl() : mShutdown(false), mEventListChangeCondVar()
AgentImpl::AgentImpl()
:mShutdown(false), mEventListChangeCondVar()
{
#if defined(TARGET_ANDROID) || defined(TARGET_WIN)
ice::GLogger.useDebugWindow(true);
@@ -34,24 +39,6 @@ AgentImpl::~AgentImpl()
stopAgentAndThread();
}
// Get access to internal audio manager. Value can be nullptr.
const std::shared_ptr<AudioManager>& AgentImpl::audioManager() const
{
return mAudioManager;
}
void AgentImpl::setAudioMonitoring(Audio::DataConnection* monitoring)
{
mAudioMonitoring = monitoring;
if (mAudioManager)
mAudioManager->setAudioMonitoring(monitoring);
}
Audio::DataConnection* AgentImpl::monitoring() const
{
return mAudioMonitoring;
}
void AgentImpl::run()
{
while (!mShutdown)
@@ -77,71 +64,82 @@ std::string AgentImpl::command(const std::string& command)
return "";
std::string cmd = d["command"].asString();
if (cmd != "wait_for_event" && cmd != "agent_add_root_cert")
if (cmd != "wait_for_event")
{
ICELogInfo(<< command);
}
if (cmd == "config")
processConfig(d, answer);
else if (cmd == "start")
else
if (cmd == "start")
processStart(d, answer);
else if (cmd == "stop")
else
if (cmd == "stop")
processStop(d, answer);
else if (cmd == "account_create")
else
if (cmd == "account_create")
processCreateAccount(d, answer);
else if (cmd == "account_start")
else
if (cmd == "account_start")
processStartAccount(d, answer);
else if (cmd == "account_setuserinfo")
else
if (cmd == "account_setuserinfo")
processSetUserInfoToAccount(d, answer);
else if (cmd == "session_create")
{
// For Bugsnag test
// int* v = nullptr;
// *v = 0;
else
if (cmd == "session_create")
processCreateSession(d, answer);
}
else if (cmd == "session_start")
else
if (cmd == "session_start")
processStartSession(d, answer);
else if (cmd == "session_stop")
else
if (cmd == "session_stop")
processStopSession(d, answer);
else if (cmd == "session_accept")
else
if (cmd == "session_accept")
processAcceptSession(d, answer);
else if (cmd == "session_destroy")
else
if (cmd == "session_destroy")
processDestroySession(d, answer);
else if (cmd == "session_use_stream")
else
if (cmd == "session_use_stream")
processUseStreamForSession(d, answer);
else if (cmd == "wait_for_event")
else
if (cmd == "wait_for_event")
processWaitForEvent(d, answer);
else if (cmd == "session_get_media_stats")
else
if (cmd == "session_get_media_stats")
processGetMediaStats(d, answer);
else if (cmd == "agent_network_changed")
else
if (cmd == "agent_network_changed")
processNetworkChanged(d, answer);
else if (cmd == "agent_add_root_cert")
else
if (cmd == "agent_add_root_cert")
processAddRootCert(d, answer);
else if (cmd == "detach_log")
else
if (cmd == "detach_log")
{
GLogger.closeFile();
answer["status"] = Status_Ok;
}
else if (cmd == "attach_log")
else
if (cmd == "attach_log")
{
GLogger.openFile();
answer["status"] = Status_Ok;
}
else if (cmd == "log_message")
else
if (cmd == "log_message")
processLogMessage(d, answer);
else
{
answer["status"] = Status_NoCommand;
}
}
catch (std::exception& e)
catch(std::exception& e)
{
answer["status"] = e.what();
}
std::string result = answer.toStyledString();
return result;
return answer.toStyledString();
}
bool AgentImpl::waitForData(int /*milliseconds*/)
@@ -154,37 +152,49 @@ std::string AgentImpl::read()
return "";
}
void AgentImpl::processConfig(JsonCpp::Value& d, JsonCpp::Value& answer)
void AgentImpl::processConfig(JsonCpp::Value &d, JsonCpp::Value &answer)
{
std::unique_lock<std::recursive_mutex> l(mAgentMutex);
std::string transport = d["transport"].asString();
config()[CONFIG_TRANSPORT] =
(transport == "any")
? TransportType_Any
: (transport == "udp" ? TransportType_Udp : (transport == "tcp" ? TransportType_Tcp : TransportType_Tls));
#if !defined(TARGET_ANDROID) && defined(USE_PVQA_LIBRARY)
// It works for desktop OSes only
// Because Android requires special initializing procedure (valid JNI environment context)
std::string pvqaLicense = d["pvqa-license"].asString(), pvqaConfig = d["pvqa-config"].asString();
if (!pvqaLicense.empty() && !pvqaConfig.empty())
sevana::pvqa::initialize(pvqaLicense, pvqaConfig);
#endif
#if !defined(TARGET_ANDROID) && defined(USE_AQUA_LIBRARY)
std::string aquaLicense = d["aqua-license"].asString();
if (!aquaLicense.empty())
sevana::aqua::initialize(aquaLicense.c_str(), aquaLicense.size());
#endif
std::string transport = d["transport"].asString();
config()[CONFIG_TRANSPORT] = (transport == "any") ? TransportType_Any : (transport == "udp" ? TransportType_Udp : (transport == "tcp" ? TransportType_Tcp : TransportType_Tls));
config()[CONFIG_IPV4] = d["ipv4"].asBool();
config()[CONFIG_IPV6] = d["ipv6"].asBool();
if (transport == "tls")
config()[CONFIG_SIPS] = true;
// Log file
std::string logfile = d["logfile"].asString();
std::string logfile = d["logfile"].asString();
ice::Logger& logger = ice::GLogger;
logger.useFile(logfile.empty() ? nullptr : logfile.c_str());
config()[CONFIG_MULTIPLEXING] = true;
config()[CONFIG_DISPLAYNAME] = "Voip quality tester";
config()[CONFIG_USERAGENT] = d["useragent"].asString();
mUseNativeAudio = d["nativeaudio"].asBool();
config()[CONFIG_OWN_DNS] = d["dns_servers"].asString();
config()[CONFIG_SIPS] = d["secure"].asBool() || transport == "tls";
config()[CONFIG_STUNSERVER_IP] = d["stun_server"].asString();
config()[CONFIG_SIPS] = d["secure"].asBool();
answer["status"] = Status_Ok;
}
void AgentImpl::processStart(JsonCpp::Value& request, JsonCpp::Value& answer)
void AgentImpl::processStart(JsonCpp::Value& request, JsonCpp::Value &answer)
{
std::unique_lock<std::recursive_mutex> l(mAgentMutex);
if (mThread)
@@ -200,25 +210,28 @@ void AgentImpl::processStart(JsonCpp::Value& request, JsonCpp::Value& answer)
SocketHeap::instance().start();
// Initialize terminal
auto settings = MT::CodecList::Settings::getClientSettings();
MT::CodecList::Settings settings;
mTerminal = std::make_shared<MT::Terminal>(settings);
// Enable/disable codecs
PVariantMap priorityConfig = std::make_shared<VariantMap>();
PVariantMap priorityConfig = std::make_shared<VariantMap>();
MT::CodecList& cl = mTerminal->codeclist();
for (int i = 0; i < cl.count(); i++)
for (int i=0; i<cl.count(); i++)
priorityConfig->at(i) = i;
// Disable dynamic payload codec types - commented for now
/*if (cl.codecAt(i).payloadType() < 96)
priorityConfig->at(i) = i;
else
priorityConfig->at(i) = -1;*/
config()[CONFIG_CODEC_PRIORITY] = priorityConfig;
// Enable audio
mAudioManager = std::make_shared<AudioManager>();
mAudioManager->setTerminal(mTerminal.get());
if (mAudioMonitoring)
mAudioManager->setAudioMonitoring(mAudioMonitoring);
// Do not start audio manager here. Start right before call.
// Do not start here. Start right before call.
// Initialize endpoint
start();
@@ -235,19 +248,17 @@ void AgentImpl::processStop(JsonCpp::Value& /*request*/, JsonCpp::Value& answer)
answer["status"] = Status_Ok;
}
void AgentImpl::processCreateAccount(JsonCpp::Value& d, JsonCpp::Value& answer)
void AgentImpl::processCreateAccount(JsonCpp::Value &d, JsonCpp::Value& answer)
{
std::unique_lock<std::recursive_mutex> l(mAgentMutex);
PVariantMap c = std::make_shared<VariantMap>();
PVariantMap c = std::make_shared<VariantMap>();
(*c)[CONFIG_USERNAME] = d["username"].asString();
(*c)[CONFIG_PASSWORD] = d["password"].asString();
(*c)[CONFIG_DOMAIN] = d["domain"].asString();
if (d.isMember("domain_port"))
(*c)[CONFIG_DOMAINPORT] = d["domain_port"].asInt();
(*c)[CONFIG_EXTERNALIP] = d["use_external_ip"].asBool();
auto nameAndPort = strx::parseHost(d["stun_server"].asString(), 3478);
auto nameAndPort = StringHelper::parseHost(d["stun_server"].asString(), 3478);
(*c)[CONFIG_STUNSERVER_NAME] = nameAndPort.first;
(*c)[CONFIG_STUNSERVER_PORT] = nameAndPort.second;
@@ -261,7 +272,7 @@ void AgentImpl::processStartAccount(JsonCpp::Value& request, JsonCpp::Value& ans
{
std::unique_lock<std::recursive_mutex> l(mAgentMutex);
// Locate account in map
auto accountIter = mAccountMap.find(request["account_id"].asInt());
auto accountIter = mAccountMap.find(request["account_id"].asInt());
if (accountIter != mAccountMap.end())
{
accountIter->second->start();
@@ -271,17 +282,17 @@ void AgentImpl::processStartAccount(JsonCpp::Value& request, JsonCpp::Value& ans
answer["status"] = Status_AccountNotFound;
}
void AgentImpl::processSetUserInfoToAccount(JsonCpp::Value& request, JsonCpp::Value& answer)
void AgentImpl::processSetUserInfoToAccount(JsonCpp::Value &request, JsonCpp::Value &answer)
{
std::unique_lock<std::recursive_mutex> l(mAgentMutex);
// Locate account in map
auto accountIter = mAccountMap.find(request["account_id"].asInt());
auto accountIter = mAccountMap.find(request["account_id"].asInt());
if (accountIter != mAccountMap.end())
{
Account::UserInfo info;
JsonCpp::Value& arg = request["userinfo"];
Account::UserInfo info;
JsonCpp::Value& arg = request["userinfo"];
std::vector<std::string> keys = arg.getMemberNames();
for (const std::string& k : keys)
for (const std::string& k: keys)
info[k] = arg[k].asString();
accountIter->second->setUserInfo(info);
@@ -291,10 +302,10 @@ void AgentImpl::processSetUserInfoToAccount(JsonCpp::Value& request, JsonCpp::Va
answer["status"] = Status_AccountNotFound;
}
void AgentImpl::processCreateSession(JsonCpp::Value& request, JsonCpp::Value& answer)
void AgentImpl::processCreateSession(JsonCpp::Value &request, JsonCpp::Value &answer)
{
std::unique_lock<std::recursive_mutex> l(mAgentMutex);
auto accountIter = mAccountMap.find(request["account_id"].asInt());
auto accountIter = mAccountMap.find(request["account_id"].asInt());
if (accountIter != mAccountMap.end())
{
PSession session = createSession(accountIter->second);
@@ -315,27 +326,21 @@ void AgentImpl::processStartSession(JsonCpp::Value& request, JsonCpp::Value& ans
{
// Agent was not started
ICELogError(<< "No audio manager installed.");
answer["status"] = Status_NoAudioManager;
answer["status"] = "Audio manager not started. Most probably agent is not started.";
return;
}
if (request["use_null_mic"].asBool())
mAudioManager->setAudioInput(std::make_shared<Audio::NullInputDevice>());
if (request["use_null_spk"].asBool())
mAudioManager->setAudioOutput(std::make_shared<Audio::NullOutputDevice>());
mAudioManager->start(mUseNativeAudio ? AudioManager::atReceiver : AudioManager::atNull);
auto sessionIter = mSessionMap.find(request["session_id"].asInt());
if (sessionIter != mSessionMap.end())
{
// Ensure audio provider is here
PSession session = sessionIter->second;
PSession session = sessionIter->second;
PDataProvider audioProvider = std::make_shared<AudioProvider>(*this, *mTerminal);
audioProvider->setState(audioProvider->state() | static_cast<int>(StreamState::Grabbing) |
static_cast<int>(StreamState::Playing));
audioProvider->setState(audioProvider->state() | static_cast<int>(StreamState::Grabbing) | static_cast<int>(StreamState::Playing));
/*#if defined(USE_AQUA_LIBRARY)
#if defined(USE_AQUA_LIBRARY)
std::string path_faults = request["path_faults"].asString();
sevana::aqua::config config = {
@@ -358,10 +363,9 @@ void AgentImpl::processStartSession(JsonCpp::Value& request, JsonCpp::Value& ans
{ "specp", "32"}
};
// std::string config = "-avlp on -smtnrm on -decor off -mprio off -npnt auto -voip off -enorm off -g711 on
-spfrcor off -grad off -tmc on -miter 1 -trim a 10 -output json";
// if (temp_path.size())
// config += " -fau " + temp_path;
// std::string config = "-avlp on -smtnrm on -decor off -mprio off -npnt auto -voip off -enorm off -g711 on -spfrcor off -grad off -tmc on -miter 1 -trim a 10 -output json";
/*if (temp_path.size())
config += " -fau " + temp_path; */
auto qc = std::make_shared<sevana::aqua>();
if (!qc->is_open())
@@ -374,15 +378,14 @@ void AgentImpl::processStartSession(JsonCpp::Value& request, JsonCpp::Value& ans
mAquaMap[sessionIter->first] = qc;
dynamic_cast<AudioProvider*>(audioProvider.get())->configureMediaObserver(this, (void*)qc.get());
#endif
*/
// TODO: support SRTP via StreamState::Srtp option in audio provider state
// Get user headers
Session::UserHeaders info;
JsonCpp::Value& arg = request["userinfo"];
Session::UserHeaders info;
JsonCpp::Value& arg = request["userinfo"];
std::vector<std::string> keys = arg.getMemberNames();
for (const std::string& k : keys)
for (const std::string& k: keys)
info[k] = arg[k].asString();
session->setUserHeaders(info);
@@ -400,7 +403,7 @@ void AgentImpl::processStopSession(JsonCpp::Value& request, JsonCpp::Value& answ
{
std::unique_lock<std::recursive_mutex> l(mAgentMutex);
auto sessionIter = mSessionMap.find(request["session_id"].asInt());
auto sessionIter = mSessionMap.find(request["session_id"].asInt());
if (sessionIter != mSessionMap.end())
{
PSession session = sessionIter->second;
@@ -414,72 +417,58 @@ void AgentImpl::processStopSession(JsonCpp::Value& request, JsonCpp::Value& answ
void AgentImpl::processAcceptSession(JsonCpp::Value& request, JsonCpp::Value& answer)
{
std::unique_lock<std::recursive_mutex> l(mAgentMutex);
auto sessionIter = mSessionMap.find(request["session_id"].asInt());
auto sessionIter = mSessionMap.find(request["session_id"].asInt());
if (sessionIter != mSessionMap.end())
{
if (!mAudioManager)
{
ICELogError(<< "No audio manager installed.");
answer["status"] = Status_NoAudioManager;
}
else
{
// Ensure audio manager is here
if (request["use_null_mic"].asBool())
mAudioManager->setAudioInput(std::make_shared<Audio::NullInputDevice>());
if (request["use_null_spk"].asBool())
mAudioManager->setAudioOutput(std::make_shared<Audio::NullOutputDevice>());
mAudioManager->start(mUseNativeAudio ? AudioManager::atReceiver : AudioManager::atNull);
// Ensure audio manager is here
mAudioManager->start(mUseNativeAudio ? AudioManager::atReceiver : AudioManager::atNull);
// Accept session on SIP level
PSession session = sessionIter->second;
// Accept session on SIP level
PSession session = sessionIter->second;
// Get user headers
Session::UserHeaders info;
JsonCpp::Value& arg = request["userinfo"];
std::vector<std::string> keys = arg.getMemberNames();
for (const std::string& k : keys)
info[k] = arg[k].asString();
session->setUserHeaders(info);
// Get user headers
Session::UserHeaders info;
JsonCpp::Value& arg = request["userinfo"];
std::vector<std::string> keys = arg.getMemberNames();
for (const std::string& k: keys)
info[k] = arg[k].asString();
session->setUserHeaders(info);
// Accept finally
session->accept();
// Accept finally
session->accept();
answer["status"] = Status_Ok;
}
answer["status"] = Status_Ok;
}
else
answer["status"] = Status_SessionNotFound;
}
void AgentImpl::processDestroySession(JsonCpp::Value& request, JsonCpp::Value& answer)
{
std::unique_lock<std::recursive_mutex> l(mAgentMutex);
int sessionId = request["session_id"].asInt();
auto sessionIter = mSessionMap.find(sessionId);
int sessionId = request["session_id"].asInt();
auto sessionIter = mSessionMap.find(sessionId);
if (sessionIter != mSessionMap.end())
mSessionMap.erase(sessionIter);
// #if defined(USE_AQUA_LIBRARY)
// closeAqua(sessionId);
// #endif
#if defined(USE_AQUA_LIBRARY)
closeAqua(sessionId);
#endif
answer["status"] = Status_Ok;
}
void AgentImpl::processWaitForEvent(JsonCpp::Value& request, JsonCpp::Value& answer)
void AgentImpl::processWaitForEvent(JsonCpp::Value &request, JsonCpp::Value &answer)
{
// Deliberately does NOT take mAgentMutex: events are produced by the worker
// thread inside process(), which needs mAgentMutex. Holding it here would
// stall all SIP/media processing for the whole timeout and guarantee that
// the awaited event can never arrive during the wait.
std::unique_lock<std::recursive_mutex> l(mAgentMutex);
int timeout = 0;
if (request.isMember("timeout"))
timeout = request["timeout"].asInt();
//int x = 0;
//int y = 1/x;
int timeout = request["timeout"].asInt();
std::unique_lock<std::mutex> eventLock(mEventListMutex);
mEventListChangeCondVar.wait_for(eventLock, chrono::milliseconds(timeout),
[this]() { return !mEventList.empty(); });
if (mEventList.empty())
mEventListChangeCondVar.wait_for(eventLock, chrono::milliseconds(timeout));
if (!mEventList.empty())
{
@@ -489,23 +478,70 @@ void AgentImpl::processWaitForEvent(JsonCpp::Value& request, JsonCpp::Value& ans
answer["status"] = Status_Ok;
}
#if defined(USE_PVQA_LIBRARY)
static JsonCpp::Value CsvReportToJson(const std::string& report)
{
JsonCpp::Value detectorValues;
std::istringstream iss(report);
CsvReader reader(iss);
std::vector<std::string> cells;
if (reader.readLine(cells))
{
JsonCpp::Value detectorNames;
for (size_t nameIndex = 0; nameIndex < cells.size(); nameIndex++)
detectorNames[static_cast<int>(nameIndex)] = StringHelper::trim(cells[nameIndex]);
// Put first line name of columns
detectorValues[0] = detectorNames;
int rowIndex = 1;
while (reader.readLine(cells))
{
// Skip last column for now
JsonCpp::Value row;
for (size_t valueIndex = 0; valueIndex < cells.size(); valueIndex++)
{
bool isFloat = true;
float v = StringHelper::toFloat(cells[valueIndex], 0.0, &isFloat);
if (isFloat)
row[static_cast<int>(valueIndex)] = static_cast<double>(v);
else
row[static_cast<int>(valueIndex)] = cells[valueIndex];
}
detectorValues[rowIndex++] = row;
}
}
return detectorValues;
}
#endif
void AgentImpl::processGetMediaStats(JsonCpp::Value& request, JsonCpp::Value& answer)
{
std::unique_lock<std::recursive_mutex> l(mAgentMutex);
int sessionId = request["session_id"].asInt();
SessionMap::iterator sessionIter = mSessionMap.find(sessionId);
int sessionId = request["session_id"].asInt();
SessionMap::iterator sessionIter = mSessionMap.find(sessionId);
if (sessionIter != mSessionMap.end())
{
PSession session = sessionIter->second;
PSession session = sessionIter->second;
VariantMap result;
session->getSessionInfo(Session::InfoOptions::Detailed, result);
bool includePvqa = request["include_pvqa"].asBool();
#if defined(USE_AQUA_LIBRARY)
bool includeAqua = request["include_aqua"].asBool();
std::string aquaReference = request["aqua_reference_audio"].asString();
#endif
session->getSessionInfo(includePvqa ? Session::InfoOptions::Detailed : Session::InfoOptions::Standard,
result);
if (result.exists(SessionInfo_AudioCodec))
answer["codec"] = result[SessionInfo_AudioCodec].asStdString();
if (result.exists(SessionInfo_NetworkMos))
answer["network_mos"] = result[SessionInfo_NetworkMos].asFloat();
if (result.exists(SessionInfo_LostRtp))
#if defined(USE_PVQA_LIBRARY)
if (result.exists(SessionInfo_PvqaMos))
answer["pvqa_mos"] = result[SessionInfo_PvqaMos].asFloat();
if (result.exists(SessionInfo_PvqaReport))
answer["pvqa_report"] = CsvReportToJson(result[SessionInfo_PvqaReport].asStdString());
#endif
if (result.exists(SessionInfo_PacketLoss))
answer["rtp_lost"] = result[SessionInfo_LostRtp].asInt();
if (result.exists(SessionInfo_DroppedRtp))
answer["rtp_dropped"] = result[SessionInfo_DroppedRtp].asInt();
@@ -514,9 +550,6 @@ void AgentImpl::processGetMediaStats(JsonCpp::Value& request, JsonCpp::Value& an
answer["rtp_sent"] = result[SessionInfo_SentRtp].asInt();
if (result.exists(SessionInfo_ReceivedRtp))
answer["rtp_received"] = result[SessionInfo_ReceivedRtp].asInt();
// Raw byte total; consumers divide by rtp_received for the average packet size.
if (result.exists(SessionInfo_ReceivedRtpTraffic))
answer["rtp_received_bytes"] = result[SessionInfo_ReceivedRtpTraffic].asInt();
if (result.exists(SessionInfo_Duration))
answer["duration"] = result[SessionInfo_Duration].asInt();
if (result.exists(SessionInfo_Jitter))
@@ -525,13 +558,79 @@ void AgentImpl::processGetMediaStats(JsonCpp::Value& request, JsonCpp::Value& an
answer["rtt"] = result[SessionInfo_Rtt].asFloat();
if (result.exists(SessionInfo_BitrateSwitchCounter))
answer["bitrate_switch_counter"] = result[SessionInfo_BitrateSwitchCounter].asInt();
if (result.exists(SessionInfo_CngCounter))
answer["cng_counter"] = result[SessionInfo_CngCounter].asInt();
if (result.exists(SessionInfo_SSRC))
answer["rtp_ssrc"] = result[SessionInfo_SSRC].asInt();
if (result.exists(SessionInfo_RemotePeer))
answer["rtp_remotepeer"] = result[SessionInfo_RemotePeer].asStdString();
#if defined(USE_AQUA_LIBRARY)
if (includeAqua)
{
answer["incoming_audio"] = mAquaIncoming.hexstring();
answer["incoming_audio_samplerate"] = AUDIO_SAMPLERATE;
answer["incoming_audio_channels"] = AUDIO_CHANNELS;
ICELogInfo(<< "Running AQuA analyzer.");
ByteBuffer referenceAudio;
// Read AQuA reference audio from file if available
if (aquaReference.empty())
{
ICELogCritical(<< "AQuA reference audio file is not set, skipping analyzing.");
}
else {
auto sa = mAquaMap[sessionIter->first];
if (sa) {
Audio::WavFileReader reader;
reader.open(StringHelper::makeTstring(aquaReference));
if (reader.isOpened()) {
char buffer[1024];
int wasRead = 0;
do {
wasRead = reader.read(buffer, 1024);
if (wasRead > 0)
referenceAudio.appendBuffer(buffer, wasRead);
} while (wasRead == 1024);
}
else {
ICELogCritical(<< "Failed to read AQuA reference audio, error code: " << reader.lastError());
}
sevana::aqua::audio_buffer test(mAquaIncoming.data(), mAquaIncoming.size()),
reference(referenceAudio.data(), referenceAudio.size());
test.mRate = AUDIO_SAMPLERATE;
reference.mRate = AUDIO_SAMPLERATE;
test.mChannels = AUDIO_CHANNELS;
reference.mChannels = AUDIO_CHANNELS;
ICELogInfo(
<< "Comparing test audio " << mAquaIncoming.size() << " bytes with reference audio " << referenceAudio.size() << " bytes.");
auto r = sa->compare(reference, test);
if (r.mErrorCode) {
ICELogInfo(
<< "Error code: " << r.mErrorCode << ", msg: " << r.mErrorMessage);
} else {
ICELogInfo(<< "MOS: " << r.mMos << ", faults: " << r.mFaultsText);
}
answer["aqua_mos"] = r.mMos;
answer["aqua_report"] = r.mFaultsText;
/*std::string aqua_audio_text;
if (Base64::Encode(std::string(reinterpret_cast<const char*>(mAquaIncoming.data()), mAquaIncoming.size()), &aqua_audio_text))
{
answer["aqua_audio"] = aqua_audio_text;
}*/
if (r.mErrorCode) {
answer["aqua_error_code"] = r.mErrorCode;
answer["aqua_error_message"] = r.mErrorMessage;
}
closeAqua(sessionIter->first);
}
}
// Remove test audio
mAquaIncoming.clear(); mAquaOutgoing.clear();
}
#endif
answer["status"] = Status_Ok;
}
else
@@ -546,32 +645,32 @@ void AgentImpl::processNetworkChanged(JsonCpp::Value& /*request*/, JsonCpp::Valu
const std::string BeginCertificate = "-----BEGIN CERTIFICATE-----";
const std::string EndCertificate = "-----END CERTIFICATE-----";
void AgentImpl::processAddRootCert(JsonCpp::Value& request, JsonCpp::Value& answer)
void AgentImpl::processAddRootCert(JsonCpp::Value& request, JsonCpp::Value& answer)
{
std::unique_lock<std::recursive_mutex> l(mAgentMutex);
std::string pem = request["cert"].asString();
std::string pem = request["cert"].asString();
std::string::size_type pb = 0, pe = 0;
while (pb != std::string::npos && pe != std::string::npos)
std::string::size_type pb = 0, pe = 0;
for(pb = pem.find(BeginCertificate, pb), pe = pem.find(EndCertificate, pe);
pb != std::string::npos && pe != std::string::npos;
pb = pem.find(BeginCertificate, pb + BeginCertificate.size()), pe = pem.find(EndCertificate, pe + EndCertificate.size()))
{
pb = pem.find(BeginCertificate, pb);
pe = pem.find(EndCertificate, pe);
// Get single certificate
std::string cert = pem.substr(pb, pe + EndCertificate.size());
//int size = cert.size();
addRootCert(ByteBuffer(cert.c_str(), cert.size()));
if (pb != std::string::npos && pe != std::string::npos && pe > pb)
{
std::string cert = pem.substr(pb, pe - pb + EndCertificate.size());
addRootCert(ByteBuffer(cert.c_str(), cert.size()));
pb = ++pe;
}
// Delete processed part
pem.erase(0, pe + EndCertificate.size());
}
answer["status"] = Status_Ok;
}
void AgentImpl::processLogMessage(JsonCpp::Value& request, JsonCpp::Value& answer)
void AgentImpl::processLogMessage(JsonCpp::Value &request, JsonCpp::Value &answer)
{
int level = request["level"].asInt();
int level = request["level"].asInt();
std::string message = request["message"].asString();
ICELog(static_cast<ice::LogLevel>(level), "App", << message);
@@ -588,8 +687,7 @@ void AgentImpl::stopAgentAndThread()
stop();
}
catch (...)
{
}
{}
// Stop worker thread
if (mThread)
@@ -623,19 +721,19 @@ void AgentImpl::stopAgentAndThread()
void AgentImpl::processUseStreamForSession(JsonCpp::Value& request, JsonCpp::Value& answer)
{
std::unique_lock<std::recursive_mutex> l(mAgentMutex);
SessionMap::iterator sessionIter = mSessionMap.find(request["session_id"].asInt());
SessionMap::iterator sessionIter = mSessionMap.find(request["session_id"].asInt());
if (sessionIter != mSessionMap.end())
{
// Extract ptr to session
PSession session = sessionIter->second;
PSession session = sessionIter->second;
// Parse command
std::string actionText = request["media_action"].asString(),
directionText = request["media_direction"].asString();
std::string actionText = request["media_action"].asString(),
directionText = request["media_direction"].asString();
MT::Stream::MediaDirection direction =
directionText == "incoming" ? MT::Stream::MediaDirection::Incoming : MT::Stream::MediaDirection::Outgoing;
std::string path = request["path"].asString();
MT::Stream::MediaDirection direction = directionText == "incoming" ? MT::Stream::MediaDirection::Incoming
: MT::Stream::MediaDirection::Outgoing;
std::string path = request["path"].asString();
// Try to open file
AudioProvider* prov = session->findProviderForActiveAudio();
@@ -652,7 +750,7 @@ void AgentImpl::processUseStreamForSession(JsonCpp::Value& request, JsonCpp::Val
else
{
Audio::PWavFileReader reader = std::make_shared<Audio::WavFileReader>();
if (!reader->open(strx::makeTstring(path)))
if (!reader->open(StringHelper::makeTstring(path)))
answer["status"] = Status_FailedToOpenFile;
else
{
@@ -661,64 +759,72 @@ void AgentImpl::processUseStreamForSession(JsonCpp::Value& request, JsonCpp::Val
}
}
}
else if (actionText == "write")
{
if (path.empty())
else
if (actionText == "write")
{
// Turn off recording from the stream
prov->writeFile(Audio::PWavFileWriter(), direction);
answer["status"] = Status_Ok;
}
else
{
Audio::PWavFileWriter writer = std::make_shared<Audio::WavFileWriter>();
if (!writer->open(strx::makeTstring(path), AUDIO_SAMPLERATE, AUDIO_CHANNELS))
answer["status"] = Status_FailedToOpenFile;
else
if (path.empty())
{
prov->writeFile(writer, direction);
// Turn off recording from the stream
prov->writeFile(Audio::PWavFileWriter(), direction);
answer["status"] = Status_Ok;
}
else
{
Audio::PWavFileWriter writer = std::make_shared<Audio::WavFileWriter>();
if (!writer->open(StringHelper::makeTstring(path), AUDIO_SAMPLERATE, AUDIO_CHANNELS))
answer["status"] = Status_FailedToOpenFile;
else
{
prov->writeFile(writer, direction);
answer["status"] = Status_Ok;
}
}
}
}
else if (actionText == "mirror")
{
prov->setupMirror(request["enable"].asBool());
answer["status"] = Status_Ok;
}
else
answer["status"] = Status_NoCommand;
else
if (actionText == "mirror")
{
prov->setupMirror(request["enable"].asBool());
answer["status"] = Status_Ok;
}
else
answer["status"] = Status_AccountNotFound;
}
else
answer["status"] = Status_NoMediaAction;
}
}
void AgentImpl::onMedia(const void* data, int length, MT::Stream::MediaDirection direction, void* context,
void* userTag)
#if defined(USE_AQUA_LIBRARY)
void AgentImpl::onMedia(const void* data, int length, MT::Stream::MediaDirection direction, void* context, void* userTag)
{
/*switch (direction)
/* if (mIncomingAudioDump && direction == MT::Stream::MediaDirection::Incoming)
mIncomingAudioDump->write(data, length);
if (mOutgoingAudioDump && direction == MT::Stream::MediaDirection::Outgoing)
mOutgoingAudioDump->write(data, length);*/
// User tag points to accumulator object which includes
// auto* sa = reinterpret_cast<sevana::aqua*>(userTag);
switch (direction)
{
case MT::Stream::MediaDirection::Incoming: mAquaIncoming.appendBuffer(data, length); break;
case MT::Stream::MediaDirection::Outgoing: mAquaOutgoing.appendBuffer(data, length); break;
}*/
}
}
#endif
// Called on new incoming session; providers shoukld
#define EVENT_WITH_NAME(X) \
JsonCpp::Value v; \
v["event_name"] = X;
#define EVENT_WITH_NAME(X) JsonCpp::Value v; v["event_name"] = X;
PDataProvider AgentImpl::onProviderNeeded(const std::string& name)
{
assert(mTerminal);
EVENT_WITH_NAME("provider_needed");
v["provider_name"] = name;
addEvent(v);
return std::make_shared<AudioProvider>(*this, *mTerminal);
return PDataProvider(new AudioProvider(*this, *mTerminal));
}
// Called on new session offer
@@ -740,8 +846,7 @@ void AgentImpl::onSessionTerminated(PSession s, int responsecode, int reason)
if (mOutgoingAudioDump)
mOutgoingAudioDump->close();
*/
if (mAudioManager)
mAudioManager->stop(mUseNativeAudio ? AudioManager::atReceiver : AudioManager::atNull);
mAudioManager->stop(mUseNativeAudio ? AudioManager::atReceiver : AudioManager::atNull);
// Gather statistics before
EVENT_WITH_NAME("session_terminated");
v["session_id"] = s->id();
@@ -846,7 +951,8 @@ void AgentImpl::onCheckFinished(PSession s, const char* description)
}
// Called when log message must be recorded
void AgentImpl::onLog(const char* /*msg*/) {}
void AgentImpl::onLog(const char* /*msg*/)
{}
// Called when problem with SIP connection(s) detected
void AgentImpl::onSipConnectionFailed()
@@ -863,12 +969,12 @@ void AgentImpl::addEvent(const JsonCpp::Value& v)
}
#if defined(USE_AQUA_LIBRARY)
/*void AgentImpl::closeAqua(int sessionId)
void AgentImpl::closeAqua(int sessionId)
{
auto aquaIter = mAquaMap.find(sessionId);
if (aquaIter != mAquaMap.end()) {
aquaIter->second->close();
mAquaMap.erase(aquaIter);
}
}*/
}
#endif
src/engine/agent/Agent_Impl.h
+93 -83
View File
@@ -13,118 +13,128 @@
#include "Agent_AudioManager.h"
#include <mutex>
#include <condition_variable>
#include <atomic>
#if defined(USE_AQUA_LIBRARY)
# include "aqua++.h"
#endif
#if defined(USE_PVQA_LIBRARY)
# include "pvqa++.h"
#endif
class AgentImpl : public UserAgent, public MT::Stream::MediaObserver
class AgentImpl: public UserAgent
#if defined(USE_AQUA_LIBRARY)
, public MT::Stream::MediaObserver
#endif
{
protected:
std::recursive_mutex mAgentMutex;
std::mutex mEventListMutex;
std::condition_variable mEventListChangeCondVar;
std::vector<JsonCpp::Value> mEventList;
bool mUseNativeAudio = false;
std::recursive_mutex mAgentMutex;
std::mutex mEventListMutex;
std::condition_variable mEventListChangeCondVar;
std::vector<JsonCpp::Value> mEventList;
bool mUseNativeAudio = false;
typedef std::map<int, PAccount> AccountMap;
AccountMap mAccountMap;
typedef std::map<int, PAccount> AccountMap;
AccountMap mAccountMap;
typedef std::map<int, PSession> SessionMap;
SessionMap mSessionMap;
typedef std::map<int, PSession> SessionMap;
SessionMap mSessionMap;
#if defined(USE_AQUA_LIBRARY)
// Keys are the same as used in mSessionMap
typedef std::map<int, std::shared_ptr<sevana::aqua>> AquaMap;
AquaMap mAquaMap;
ByteBuffer mAquaIncoming, mAquaOutgoing;
void closeAqua(int sessionId);
#endif
std::shared_ptr<std::thread> mThread;
std::atomic<bool> mShutdown;
std::shared_ptr<MT::Terminal> mTerminal;
std::shared_ptr<AudioManager> mAudioManager;
Audio::DataConnection* mAudioMonitoring = nullptr;
std::shared_ptr<std::thread> mThread;
volatile bool mShutdown;
std::shared_ptr<MT::Terminal> mTerminal;
std::shared_ptr<AudioManager> mAudioManager;
//Audio::PWavFileWriter mIncomingAudioDump, mOutgoingAudioDump;
void run();
void addEvent(const JsonCpp::Value& v);
void processConfig(JsonCpp::Value& request, JsonCpp::Value& answer);
void processStart(JsonCpp::Value& request, JsonCpp::Value& answer);
void processStop(JsonCpp::Value& request, JsonCpp::Value& answer);
void processCreateAccount(JsonCpp::Value& request, JsonCpp::Value& answer);
void processStartAccount(JsonCpp::Value& request, JsonCpp::Value& answer);
void processSetUserInfoToAccount(JsonCpp::Value& request, JsonCpp::Value& answer);
void processCreateSession(JsonCpp::Value& request, JsonCpp::Value& answer);
void processStartSession(JsonCpp::Value& request, JsonCpp::Value& answer);
void processStopSession(JsonCpp::Value& request, JsonCpp::Value& answer);
void processAcceptSession(JsonCpp::Value& request, JsonCpp::Value& answer);
void processDestroySession(JsonCpp::Value& request, JsonCpp::Value& answer);
void processWaitForEvent(JsonCpp::Value& request, JsonCpp::Value& answer);
void processGetMediaStats(JsonCpp::Value& request, JsonCpp::Value& answer);
void processUseStreamForSession(JsonCpp::Value& request, JsonCpp::Value& answer);
void processNetworkChanged(JsonCpp::Value& request, JsonCpp::Value& answer);
void processAddRootCert(JsonCpp::Value& request, JsonCpp::Value& answer);
void processLogMessage(JsonCpp::Value& request, JsonCpp::Value& answer);
void stopAgentAndThread();
void run();
void addEvent(const JsonCpp::Value& v);
void processConfig(JsonCpp::Value& request, JsonCpp::Value& answer);
void processStart(JsonCpp::Value& request, JsonCpp::Value& answer);
void processStop(JsonCpp::Value& request, JsonCpp::Value& answer);
void processCreateAccount(JsonCpp::Value& request, JsonCpp::Value& answer);
void processStartAccount(JsonCpp::Value& request, JsonCpp::Value& answer);
void processSetUserInfoToAccount(JsonCpp::Value& request, JsonCpp::Value& answer);
void processCreateSession(JsonCpp::Value& request, JsonCpp::Value& answer);
void processStartSession(JsonCpp::Value& request, JsonCpp::Value& answer);
void processStopSession(JsonCpp::Value& request, JsonCpp::Value& answer);
void processAcceptSession(JsonCpp::Value& request, JsonCpp::Value& answer);
void processDestroySession(JsonCpp::Value& request, JsonCpp::Value& answer);
void processWaitForEvent(JsonCpp::Value& request, JsonCpp::Value& answer);
void processGetMediaStats(JsonCpp::Value& request, JsonCpp::Value& answer);
void processUseStreamForSession(JsonCpp::Value& request, JsonCpp::Value& answer);
void processNetworkChanged(JsonCpp::Value& request, JsonCpp::Value& answer);
void processAddRootCert(JsonCpp::Value& request, JsonCpp::Value& answer);
void processLogMessage(JsonCpp::Value& request, JsonCpp::Value& answer);
void stopAgentAndThread();
public:
AgentImpl();
~AgentImpl();
AgentImpl();
~AgentImpl();
std::string command(const std::string& command);
bool waitForData(int milliseconds);
std::string read();
std::string command(const std::string& command);
bool waitForData(int milliseconds);
std::string read();
// Get access to internal audio manager. Value can be nullptr.
const std::shared_ptr<AudioManager>& audioManager() const;
// UserAgent overrides
// Called on new incoming session; providers shoukld
PDataProvider onProviderNeeded(const std::string& name) override;
void setAudioMonitoring(Audio::DataConnection* monitoring);
Audio::DataConnection* monitoring() const;
// Called on new session offer
void onNewSession(PSession s) override;
// UserAgent overrides
// Called on new incoming session; providers shoukld
PDataProvider onProviderNeeded(const std::string& name) override;
// Called when session is terminated
void onSessionTerminated(PSession s, int responsecode, int reason) override;
// Called on new session offer
void onNewSession(PSession s) override;
// Called when session is established ok i.e. after all ICE signalling is finished
// Conntype is type of establish event - EV_SIP or EV_ICE
void onSessionEstablished(PSession s, int conntype, const RtpPair<InternetAddress>& p) override;
// Called when session is terminated
void onSessionTerminated(PSession s, int responsecode, int reason) override;
void onSessionProvisional(PSession s, int code) override;
// Called when session is established ok i.e. after all ICE signalling is finished
// Conntype is type of establish event - EV_SIP or EV_ICE
void onSessionEstablished(PSession s, int conntype, const RtpPair<InternetAddress>& p) override;
// Called when user agent started
void onStart(int errorcode) override;
void onSessionProvisional(PSession s, int code) override;
// Called when user agent stopped
void onStop() override;
// Called when user agent started
void onStart(int errorcode) override;
// Called when account registered
void onAccountStart(PAccount account) override;
// Called when user agent stopped
void onStop() override;
// Called when account removed or failed (non zero error code)
void onAccountStop(PAccount account, int error) override;
// Called when account registered
void onAccountStart(PAccount account) override;
// Called when connectivity checks failed.
void onConnectivityFailed(PSession s) override;
// Called when account removed or failed (non zero error code)
void onAccountStop(PAccount account, int error) override;
// Called when new candidate is gathered
void onCandidateGathered(PSession s, const char* address) override;
// Called when connectivity checks failed.
void onConnectivityFailed(PSession s) override;
// Called when network change detected
void onNetworkChange(PSession s) override;
// Called when new candidate is gathered
void onCandidateGathered(PSession s, const char* address) override;
// Called when all candidates are gathered
void onGathered(PSession s) override;
// Called when network change detected
void onNetworkChange(PSession s) override;
// Called when new connectivity check is finished
void onCheckFinished(PSession s, const char* description) override;
// Called when all candidates are gathered
void onGathered(PSession s) override;
// Called when log message must be recorded
void onLog(const char* msg) override;
// Called when new connectivity check is finished
void onCheckFinished(PSession s, const char* description) override;
// Called when problem with SIP connection(s) detected
void onSipConnectionFailed() override;
// Called when log message must be recorded
void onLog(const char* msg) override;
// Called when problem with SIP connection(s) detected
void onSipConnectionFailed() override;
// Called on incoming & outgoing audio for voice sessions
void onMedia(const void* data, int length, MT::Stream::MediaDirection direction, void* context,
void* userTag) override;
#if defined(USE_AQUA_LIBRARY)
// Called on incoming & outgoing audio for voice sessions
void onMedia(const void* data, int length, MT::Stream::MediaDirection direction, void* context, void* userTag) override;
#endif
};
#endif
src/engine/agent/Agent_Interface.cpp
+16 -5
View File
@@ -1,16 +1,27 @@
#include "Agent_Interface.h"
#include "Agent_Impl.h"
Agent::Agent() : mContext(new AgentImpl());
Agent::Agent()
:mContext(new AgentImpl());
{
}
Agent::~Agent() {}
Agent::~Agent()
{
void Agent::write(const std::string& command) {}
}
void Agent::write(const std::string& command)
{
}
bool Agent::waitForData(int milliseconds)
{
return false;
return false;
}
std::string Agent::read() {}
std::string Agent::read()
{
}
src/engine/agent/Agent_Interface.h
+6 -6
View File
@@ -6,14 +6,14 @@
class Agent
{
protected:
void* mContext;
void* mContext;
public:
Agent();
~Agent();
void write(const std::string& command);
bool waitForData(int milliseconds);
std::string read();
Agent();
~Agent();
void write(const std::string& command);
bool waitForData(int milliseconds);
std::string read();
};
#endif
src/engine/audio/Audio_Android.cpp
+378 -373
View File
@@ -14,580 +14,585 @@ using namespace Audio;
// -------------------- AndroidEnumerator -----------------------------
AndroidEnumerator::AndroidEnumerator() {}
AndroidEnumerator::AndroidEnumerator()
{}
AndroidEnumerator::~AndroidEnumerator() {}
AndroidEnumerator::~AndroidEnumerator()
{}
int AndroidEnumerator::indexOfDefaultDevice()
{
return 0;
return 0;
}
int AndroidEnumerator::count()
{
return 1;
return 1;
}
int AndroidEnumerator::idAt(int index)
{
return 0;
return 0;
}
std::string AndroidEnumerator::nameAt(int index)
{
return "Audio";
return "Audio";
}
void AndroidEnumerator::open(int direction) {}
void AndroidEnumerator::open(int direction)
{}
void AndroidEnumerator::close() {}
void AndroidEnumerator::close()
{}
// -----------------------
OpenSLEngine::OpenSLEngine() {}
OpenSLEngine::OpenSLEngine()
{}
OpenSLEngine::~OpenSLEngine() {}
OpenSLEngine::~OpenSLEngine()
{}
void OpenSLEngine::open()
{
std::unique_lock<std::mutex> l(mMutex);
if (++mUsageCounter == 1)
internalOpen();
std::unique_lock<std::mutex> l(mMutex);
if (++mUsageCounter == 1)
internalOpen();
}
void OpenSLEngine::close()
{
std::unique_lock<std::mutex> l(mMutex);
if (mUsageCounter == 0)
return;
std::unique_lock<std::mutex> l(mMutex);
if (mUsageCounter == 0)
return;
if (--mUsageCounter == 0)
internalClose();
if (--mUsageCounter == 0)
internalClose();
}
#define CHECK_OPENSLES_ERROR \
if (resultCode != SL_RESULT_SUCCESS) \
throw Exception(ERR_OPENSLES, (int)resultCode)
#define CHECK_OPENSLES_ERROR if (resultCode != SL_RESULT_SUCCESS) throw Exception(ERR_OPENSLES, (int)resultCode)
void OpenSLEngine::internalOpen()
{
SLresult resultCode;
SLresult resultCode;
// Instantiate OpenSL ES engine object
resultCode = slCreateEngine(&mEngineObject, 0, nullptr, 0, nullptr, nullptr);
CHECK_OPENSLES_ERROR;
// Instantiate OpenSL ES engine object
resultCode = slCreateEngine(&mEngineObject, 0, nullptr, 0, nullptr, nullptr);
CHECK_OPENSLES_ERROR;
// Bring it online (realize)
resultCode = (*mEngineObject)->Realize(mEngineObject, SL_BOOLEAN_FALSE);
CHECK_OPENSLES_ERROR;
// Bring it online (realize)
resultCode = (*mEngineObject)->Realize(mEngineObject, SL_BOOLEAN_FALSE);
CHECK_OPENSLES_ERROR;
// Get interface finally
resultCode = (*mEngineObject)->GetInterface(mEngineObject, SL_IID_ENGINE, &mEngineInterface);
CHECK_OPENSLES_ERROR;
// Get interface finally
resultCode = (*mEngineObject)->GetInterface(mEngineObject, SL_IID_ENGINE, &mEngineInterface);
CHECK_OPENSLES_ERROR;
ICELogInfo(<< "OpenSL engine object created.");
ICELogInfo(<< "OpenSL engine object created.");
}
void OpenSLEngine::internalClose()
{
if (mEngineObject != nullptr)
{
ICELogInfo(<< "Destroy OpenSL engine object.");
if (mEngineObject != nullptr)
{
ICELogInfo(<< "Destroy OpenSL engine object.");
(*mEngineObject)->Destroy(mEngineObject);
mEngineObject = nullptr;
mEngineInterface = nullptr;
}
(*mEngineObject)->Destroy(mEngineObject);
mEngineObject = nullptr;
mEngineInterface = nullptr;
}
}
SLEngineItf OpenSLEngine::getNativeEngine() const
{
return mEngineInterface;
return mEngineInterface;
}
static OpenSLEngine OpenSLEngineInstance;
OpenSLEngine& OpenSLEngine::instance()
OpenSLEngine& OpenSLEngine::instance()
{
return OpenSLEngineInstance;
return OpenSLEngineInstance;
}
// --------------- Input implementation ----------------
AndroidInputDevice::AndroidInputDevice(int devId) {}
AndroidInputDevice::AndroidInputDevice(int devId)
{}
AndroidInputDevice::~AndroidInputDevice() {}
AndroidInputDevice::~AndroidInputDevice()
{}
static int RateToProbe[12][2] = {
{SL_SAMPLINGRATE_16, 16000}, {SL_SAMPLINGRATE_8, 8000}, {SL_SAMPLINGRATE_32, 32000},
{SL_SAMPLINGRATE_44_1, 44100}, {SL_SAMPLINGRATE_11_025, 10025}, {SL_SAMPLINGRATE_22_05, 22050},
{SL_SAMPLINGRATE_24, 24000}, {SL_SAMPLINGRATE_48, 48000}, {SL_SAMPLINGRATE_64, 64000},
{SL_SAMPLINGRATE_88_2, 88200}, {SL_SAMPLINGRATE_96, 96000}, {SL_SAMPLINGRATE_192, 192000}};
{ SL_SAMPLINGRATE_16, 16000 },
{ SL_SAMPLINGRATE_8, 8000 },
{ SL_SAMPLINGRATE_32, 32000 },
{ SL_SAMPLINGRATE_44_1, 44100 },
{ SL_SAMPLINGRATE_11_025, 10025 },
{ SL_SAMPLINGRATE_22_05, 22050 },
{ SL_SAMPLINGRATE_24, 24000 },
{ SL_SAMPLINGRATE_48, 48000 },
{ SL_SAMPLINGRATE_64, 64000 },
{ SL_SAMPLINGRATE_88_2, 88200 },
{ SL_SAMPLINGRATE_96, 96000 },
{ SL_SAMPLINGRATE_192, 192000} };
bool AndroidInputDevice::open()
{
if (active())
return true;
if (active())
return true;
OpenSLEngine::instance().open();
OpenSLEngine::instance().open();
// Probe few sampling rates
bool opened = false;
for (int rateIndex = 0; rateIndex < 12 && !opened; rateIndex++)
// Probe few sampling rates
bool opened = false;
for (int rateIndex = 0; rateIndex < 12 && !opened; rateIndex++)
{
try
{
try
{
internalOpen(RateToProbe[rateIndex][0], RateToProbe[rateIndex][1]);
mDeviceRate = RateToProbe[rateIndex][1];
ICELogInfo(<< "Input Opened with rate " << mDeviceRate << " and rate index " << rateIndex);
opened = mDeviceRate != 0;
if (!opened)
internalClose();
}
catch (...)
{
opened = false;
internalClose();
}
internalOpen(RateToProbe[rateIndex][0], RateToProbe[rateIndex][1]);
mDeviceRate = RateToProbe[rateIndex][1];
ICELogInfo(<< "Input Opened with rate " << mDeviceRate << " and rate index " << rateIndex);
opened = mDeviceRate != 0;
if (!opened)
internalClose();
}
mActive = opened;
catch(...)
{
opened = false;
internalClose();
}
}
mActive = opened;
return opened;
return opened;
}
void AndroidInputDevice::close()
{
// There is no check for active() value because close() can be called to cleanup after bad open() call.
internalClose();
OpenSLEngine::instance().close();
mActive = false;
// There is no check for active() value because close() can be called to cleanup after bad open() call.
internalClose();
OpenSLEngine::instance().close();
mActive = false;
}
Format AndroidInputDevice::getFormat()
{
return Format(mDeviceRate, 1);
return Format(mDeviceRate, 1);
}
bool AndroidInputDevice::active() const
{
return mActive;
return mActive;
}
bool AndroidInputDevice::fakeMode()
{
return false;
return false;
}
void AndroidInputDevice::setFakeMode(bool fakemode) {}
void AndroidInputDevice::setFakeMode(bool fakemode)
{}
int AndroidInputDevice::readBuffer(void* buffer)
int AndroidInputDevice::readBuffer(void* buffer)
{
std::unique_lock<std::mutex> l(mMutex);
while (mSdkRateCache.filled() < AUDIO_MIC_BUFFER_SIZE)
{
mDataCondVar.wait(l);
}
std::unique_lock<std::mutex> l(mMutex);
while (mSdkRateCache.filled() < AUDIO_MIC_BUFFER_SIZE)
{
mDataCondVar.wait(l);
}
return mSdkRateCache.read(buffer, AUDIO_MIC_BUFFER_SIZE);
return mSdkRateCache.read(buffer, AUDIO_MIC_BUFFER_SIZE);
}
#define CHECK_SL_INTERFACE(INTF, ERR) \
{ \
if (!INTF) \
throw Exception(ERR_OPENSLES, ERR); \
if (!(*INTF)) \
throw Exception(ERR_OPENSLES, ERR); \
}
#define CHECK_SL_INTERFACE(INTF, ERR) {if (!INTF) throw Exception(ERR_OPENSLES, ERR); if (!(*INTF)) throw Exception(ERR_OPENSLES, ERR);}
void AndroidInputDevice::internalOpen(int rateCode, int rate)
{
SLresult resultCode = 0;
SLuint32 nrOfChannels = 1;
SLresult resultCode = 0;
SLuint32 nrOfChannels = 1;
// Prepare audio source
SLDataLocator_IODevice devDescription = {SL_DATALOCATOR_IODEVICE, SL_IODEVICE_AUDIOINPUT,
SL_DEFAULTDEVICEID_AUDIOINPUT, NULL};
SLDataSource audioSource = {&devDescription, NULL};
// Prepare audio source
SLDataLocator_IODevice devDescription = { SL_DATALOCATOR_IODEVICE, SL_IODEVICE_AUDIOINPUT, SL_DEFAULTDEVICEID_AUDIOINPUT, NULL};
SLDataSource audioSource = { &devDescription, NULL };
// Source flags
SLuint32 speakersFlags =
nrOfChannels > 1 ? (SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT) : SL_SPEAKER_FRONT_CENTER;
// Source flags
SLuint32 speakersFlags = nrOfChannels > 1 ? (SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT) : SL_SPEAKER_FRONT_CENTER;
// Buffer queue
SLDataLocator_AndroidSimpleBufferQueue queueDescription = {SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, 2};
// Buffer queue
SLDataLocator_AndroidSimpleBufferQueue queueDescription = { SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, 2 };
// Audio format
SLDataFormat_PCM formatDescription = {SL_DATAFORMAT_PCM, nrOfChannels,
(SLuint32)rateCode, SL_PCMSAMPLEFORMAT_FIXED_16,
SL_PCMSAMPLEFORMAT_FIXED_16, (SLuint32)speakersFlags,
SL_BYTEORDER_LITTLEENDIAN};
// Audio format
SLDataFormat_PCM formatDescription = { SL_DATAFORMAT_PCM, nrOfChannels, (SLuint32)rateCode, SL_PCMSAMPLEFORMAT_FIXED_16,
SL_PCMSAMPLEFORMAT_FIXED_16, (SLuint32)speakersFlags, SL_BYTEORDER_LITTLEENDIAN };
SLDataSink audioSink = {&queueDescription, &formatDescription};
SLDataSink audioSink = { &queueDescription, &formatDescription };
// Create recorder
// Do not forget about RECORD_AUDIO permission
const SLInterfaceID interfacesList[2] = {SL_IID_ANDROIDSIMPLEBUFFERQUEUE, SL_IID_ANDROIDCONFIGURATION};
const SLboolean interfacesRequirements[2] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE};
// Create recorder
// Do not forget about RECORD_AUDIO permission
const SLInterfaceID interfacesList[2] = { SL_IID_ANDROIDSIMPLEBUFFERQUEUE, SL_IID_ANDROIDCONFIGURATION };
const SLboolean interfacesRequirements[2] = { SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE };
// Get access to OpenSL engine
SLEngineItf engine_interface = OpenSLEngine::instance().getNativeEngine();
CHECK_SL_INTERFACE(engine_interface, -1);
// Get access to OpenSL engine
SLEngineItf engine_interface = OpenSLEngine::instance().getNativeEngine();
CHECK_SL_INTERFACE(engine_interface, -1);
resultCode = (*engine_interface)
->CreateAudioRecorder(OpenSLEngine::instance().getNativeEngine(), &mRecorderObject, &audioSource,
&audioSink, 2, interfacesList, interfacesRequirements);
CHECK_OPENSLES_ERROR;
CHECK_SL_INTERFACE(mRecorderObject, -2);
resultCode = (*engine_interface)->CreateAudioRecorder(
OpenSLEngine::instance().getNativeEngine(),
&mRecorderObject, &audioSource, &audioSink, 2, interfacesList, interfacesRequirements);
CHECK_OPENSLES_ERROR;
CHECK_SL_INTERFACE(mRecorderObject, -2);
// Obtain stream type
resultCode = (*mRecorderObject)->GetInterface(mRecorderObject, SL_IID_ANDROIDCONFIGURATION, &mAndroidCfg);
CHECK_OPENSLES_ERROR;
// Obtain stream type
resultCode = (*mRecorderObject)->GetInterface(mRecorderObject, SL_IID_ANDROIDCONFIGURATION, &mAndroidCfg);
CHECK_OPENSLES_ERROR;
// Now audio recorder goes to real world
resultCode = (*mRecorderObject)->Realize(mRecorderObject, SL_BOOLEAN_FALSE);
CHECK_OPENSLES_ERROR;
// Now audio recorder goes to real world
resultCode = (*mRecorderObject)->Realize(mRecorderObject, SL_BOOLEAN_FALSE);
CHECK_OPENSLES_ERROR;
// Get recorder interface
resultCode = (*mRecorderObject)->GetInterface(mRecorderObject, SL_IID_RECORD, &mRecorderInterface);
CHECK_OPENSLES_ERROR;
CHECK_SL_INTERFACE(mRecorderInterface, -3);
// Get recorder interface
resultCode = (*mRecorderObject)->GetInterface(mRecorderObject, SL_IID_RECORD, &mRecorderInterface);
CHECK_OPENSLES_ERROR;
CHECK_SL_INTERFACE(mRecorderInterface, -3);
// Now buffer queue interface...
resultCode =
(*mRecorderObject)->GetInterface(mRecorderObject, SL_IID_ANDROIDSIMPLEBUFFERQUEUE, &mRecorderBufferInterface);
CHECK_OPENSLES_ERROR;
CHECK_SL_INTERFACE(mRecorderBufferInterface, -4);
// Now buffer queue interface...
resultCode = (*mRecorderObject)->GetInterface(mRecorderObject, SL_IID_ANDROIDSIMPLEBUFFERQUEUE, &mRecorderBufferInterface);
CHECK_OPENSLES_ERROR;
CHECK_SL_INTERFACE(mRecorderBufferInterface, -4);
// Resampler is needed to provide SDK's rate
mResampler = std::make_shared<Resampler>();
mResampler->start(nrOfChannels, rate, AUDIO_SAMPLERATE);
// Resampler is needed to provide SDK's rate
mResampler = std::make_shared<Resampler>();
mResampler->start(nrOfChannels, rate, AUDIO_SAMPLERATE);
// Allocate recorder buffer size
mBufferSize = (AUDIO_MIC_BUFFER_LENGTH / 10) * (rate / 100) * 2;
mRecorderBuffer.setCapacity(mBufferSize * AUDIO_MIC_BUFFER_COUNT);
mRecorderBufferIndex = 0;
// Allocate recorder buffer size
mBufferSize = (AUDIO_MIC_BUFFER_LENGTH / 10) * (rate / 100) * 2;
mRecorderBuffer.setCapacity(mBufferSize * AUDIO_MIC_BUFFER_COUNT);
mRecorderBufferIndex = 0;
// Setup data consuming callback
resultCode = (*mRecorderBufferInterface)->RegisterCallback(mRecorderBufferInterface, DeviceCallback, (void*)this);
CHECK_OPENSLES_ERROR;
// Setup data consuming callback
resultCode = (*mRecorderBufferInterface)->RegisterCallback(mRecorderBufferInterface, DeviceCallback, (void*)this);
CHECK_OPENSLES_ERROR;
// Setup buffers
for (int i = 0; i < AUDIO_MIC_BUFFER_COUNT; i++)
(*mRecorderBufferInterface)
->Enqueue(mRecorderBufferInterface, mRecorderBuffer.data() + i * mBufferSize, mBufferSize);
// Setup buffers
for (int i=0; i<AUDIO_MIC_BUFFER_COUNT; i++)
(*mRecorderBufferInterface)->Enqueue(mRecorderBufferInterface, mRecorderBuffer.data() + i * mBufferSize, mBufferSize);
// Start finally
resultCode = (*mRecorderInterface)->SetRecordState(mRecorderInterface, SL_RECORDSTATE_RECORDING);
CHECK_OPENSLES_ERROR;
// Start finally
resultCode = (*mRecorderInterface)->SetRecordState(mRecorderInterface, SL_RECORDSTATE_RECORDING);
CHECK_OPENSLES_ERROR;
}
void AndroidInputDevice::internalClose()
{
if (!mRecorderObject)
return;
if (!mRecorderObject)
return;
if (*mRecorderObject)
if (*mRecorderObject)
{
if (active())
{
if (active())
{
// Stop recording
(*mRecorderInterface)->SetRecordState(mRecorderInterface, SL_RECORDSTATE_STOPPED);
// Stop recording
(*mRecorderInterface)->SetRecordState(mRecorderInterface, SL_RECORDSTATE_STOPPED);
// Wait until recording will not stop really
SLuint32 state = SL_RECORDSTATE_STOPPED;
do
{
(*mRecorderInterface)->GetRecordState(mRecorderInterface, &state);
SyncHelper::delay(1);
} while (state == SL_RECORDSTATE_RECORDING);
}
(*mRecorderObject)->Destroy(mRecorderObject);
// Wait until recording will not stop really
SLuint32 state = SL_RECORDSTATE_STOPPED;
do
{
(*mRecorderInterface)->GetRecordState(mRecorderInterface, &state);
SyncHelper::delay(1);
}
while (state == SL_RECORDSTATE_RECORDING);
}
(*mRecorderObject)->Destroy(mRecorderObject);
}
mRecorderObject = nullptr;
mRecorderInterface = nullptr;
mRecorderBufferInterface = nullptr;
mAndroidCfg = nullptr;
mRecorderObject = nullptr;
mRecorderInterface = nullptr;
mRecorderBufferInterface = nullptr;
mAndroidCfg = nullptr;
}
void AndroidInputDevice::handleCallback(SLAndroidSimpleBufferQueueItf bq)
{
std::unique_lock<std::mutex> l(mMutex);
std::unique_lock<std::mutex> l(mMutex);
// Send data to AudioPair
// Send data to AudioPair
if (mConnection)
mConnection->onMicData(getFormat(), mRecorderBuffer.data() + mRecorderBufferIndex * mBufferSize, mBufferSize);
/*
// Send audio to cache with native sample rate
mDeviceRateCache.add(mRecorderBuffer.data() + mRecorderBufferIndex * mBufferSize, mBufferSize);
// Check if there is enough data (10 ms) to send
int tenMsSize = (int)Format(mDeviceRate, 1).sizeFromTime(10);
while (mDeviceRateCache.filled() >= tenMsSize)
{
char* resampled = (char*)alloca(Format().sizeFromTime(10));
int processed = 0;
int outlen = mResampler->processBuffer(mDeviceRateCache.data(), tenMsSize, processed, resampled, Format().sizeFromTime(10));
if (outlen > 0)
mSdkRateCache.add(resampled, (int)Format().sizeFromTime(10));
mDeviceRateCache.erase(tenMsSize);
}
// Tell about data
while (mSdkRateCache.filled() >= AUDIO_MIC_BUFFER_SIZE)
{
if (mConnection)
mConnection->onMicData(getFormat(), mRecorderBuffer.data() + mRecorderBufferIndex * mBufferSize, mBufferSize);
/*
// Send audio to cache with native sample rate
mDeviceRateCache.add(mRecorderBuffer.data() + mRecorderBufferIndex * mBufferSize, mBufferSize);
// Check if there is enough data (10 ms) to send
int tenMsSize = (int)Format(mDeviceRate, 1).sizeFromTime(10);
while (mDeviceRateCache.filled() >= tenMsSize)
{
char* resampled = (char*)alloca(Format().sizeFromTime(10));
int processed = 0;
int outlen = mResampler->processBuffer(mDeviceRateCache.data(), tenMsSize, processed, resampled,
Format().sizeFromTime(10)); if (outlen > 0) mSdkRateCache.add(resampled, (int)Format().sizeFromTime(10));
mDeviceRateCache.erase(tenMsSize);
}
// Tell about data
while (mSdkRateCache.filled() >= AUDIO_MIC_BUFFER_SIZE)
{
if (mConnection)
mConnection->onMicData(Format(), mSdkRateCache.data(), AUDIO_MIC_BUFFER_SIZE);
mSdkRateCache.erase(AUDIO_MIC_BUFFER_SIZE);
}
*/
// Re-enqueue used buffer
(*mRecorderBufferInterface)
->Enqueue(mRecorderBufferInterface, mRecorderBuffer.data() + mRecorderBufferIndex * mBufferSize, mBufferSize);
mRecorderBufferIndex++;
mRecorderBufferIndex %= AUDIO_MIC_BUFFER_COUNT;
mConnection->onMicData(Format(), mSdkRateCache.data(), AUDIO_MIC_BUFFER_SIZE);
mSdkRateCache.erase(AUDIO_MIC_BUFFER_SIZE);
}
*/
// Re-enqueue used buffer
(*mRecorderBufferInterface)->Enqueue(mRecorderBufferInterface, mRecorderBuffer.data() + mRecorderBufferIndex * mBufferSize, mBufferSize);
mRecorderBufferIndex++;
mRecorderBufferIndex %= AUDIO_MIC_BUFFER_COUNT;
}
void AndroidInputDevice::DeviceCallback(SLAndroidSimpleBufferQueueItf bq, void* context)
void AndroidInputDevice::DeviceCallback(SLAndroidSimpleBufferQueueItf bq, void *context)
{
try
{
if (context)
reinterpret_cast<AndroidInputDevice*>(context)->handleCallback(bq);
}
catch (...)
{
}
try
{
if (context)
reinterpret_cast<AndroidInputDevice*>(context)->handleCallback(bq);
}
catch(...)
{}
}
// ------------ AndroidOutputDevice -----------------
AndroidOutputDevice::AndroidOutputDevice(int devId)
{
ICELogDebug(<< "Creating AndroidOutputDevice. This is: " << strx::toHex(this));
ICELogDebug(<< "Creating AndroidOutputDevice. This is: " << StringHelper::toHex(this));
}
AndroidOutputDevice::~AndroidOutputDevice()
{
ICELogDebug(<< "Deleting AndroidOutputDevice.");
close();
ICELogDebug(<< "Deleting AndroidOutputDevice.");
close();
}
bool AndroidOutputDevice::open()
{
std::unique_lock<std::mutex> l(mMutex);
bool opened = false;
for (int rateIndex = 0; rateIndex < 12 && !opened; rateIndex++)
std::unique_lock<std::mutex> l(mMutex);
bool opened = false;
for (int rateIndex = 0; rateIndex < 12 && !opened; rateIndex++)
{
try
{
try
{
internalOpen(RateToProbe[rateIndex][0], RateToProbe[rateIndex][1], true);
opened = true;
mDeviceRate = RateToProbe[rateIndex][1];
ICELogCritical(<< "Output opened with rate " << mDeviceRate << " and index " << rateIndex);
}
catch (...)
{
opened = false;
}
internalOpen(RateToProbe[rateIndex][0], RateToProbe[rateIndex][1], true);
opened = true;
mDeviceRate = RateToProbe[rateIndex][1];
ICELogCritical(<< "Output opened with rate " << mDeviceRate << " and index " << rateIndex);
}
if (opened)
ICELogInfo(<< "Speaker opened on rate " << mDeviceRate);
catch(...)
{
opened = false;
}
}
if (opened)
ICELogInfo(<< "Speaker opened on rate " << mDeviceRate);
return opened;
return opened;
}
void AndroidOutputDevice::close()
{
std::unique_lock<std::mutex> l(mMutex);
internalClose();
std::unique_lock<std::mutex> l(mMutex);
internalClose();
}
Format AndroidOutputDevice::getFormat()
{
return Format(mDeviceRate, 1);
return Format(mDeviceRate, 1);
}
bool AndroidOutputDevice::fakeMode()
{
return false;
return false;
}
void AndroidOutputDevice::setFakeMode(bool fakemode) {}
void AndroidOutputDevice::setFakeMode(bool fakemode)
{
}
void AndroidOutputDevice::internalOpen(int rateId, int rate, bool voice)
{
mInShutdown = false;
mInShutdown = false;
SLresult resultCode;
SLuint32 channels = 1;
SLresult resultCode;
SLuint32 channels = 1;
// Configure audio source
SLDataLocator_AndroidSimpleBufferQueue queue_desc = {SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, 2};
// Configure audio source
SLDataLocator_AndroidSimpleBufferQueue queue_desc = { SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, 2 };
const SLInterfaceID interfacesList[] = {SL_IID_VOLUME};
const SLboolean interfaceRequirements[] = {SL_BOOLEAN_FALSE};
resultCode = (*OpenSLEngine::instance().getNativeEngine())
->CreateOutputMix(OpenSLEngine::instance().getNativeEngine(), &mMixer, 1, interfacesList,
interfaceRequirements);
CHECK_OPENSLES_ERROR;
const SLInterfaceID interfacesList[] = { SL_IID_VOLUME };
const SLboolean interfaceRequirements[] = { SL_BOOLEAN_FALSE };
resultCode = (*OpenSLEngine::instance().getNativeEngine())->CreateOutputMix(
OpenSLEngine::instance().getNativeEngine(), &mMixer, 1, interfacesList,
interfaceRequirements);
CHECK_OPENSLES_ERROR;
// Bring mixer online
resultCode = (*mMixer)->Realize(mMixer, SL_BOOLEAN_FALSE);
CHECK_OPENSLES_ERROR;
// Bring mixer online
resultCode = (*mMixer)->Realize(mMixer, SL_BOOLEAN_FALSE);
CHECK_OPENSLES_ERROR;
// Prepare mixer configuration
SLuint32 speakers = channels > 1 ? (SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT) : SL_SPEAKER_FRONT_CENTER;
// Prepare mixer configuration
SLuint32 speakers =
channels > 1 ? (SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT) : SL_SPEAKER_FRONT_CENTER;
// Describe audio format
SLDataFormat_PCM pcm_format = {
SL_DATAFORMAT_PCM, channels, (SLuint32)rateId, SL_PCMSAMPLEFORMAT_FIXED_16,
SL_PCMSAMPLEFORMAT_FIXED_16, speakers, SL_BYTEORDER_LITTLEENDIAN};
// Describe audio format
SLDataFormat_PCM pcm_format = {SL_DATAFORMAT_PCM, channels, (SLuint32) rateId,
SL_PCMSAMPLEFORMAT_FIXED_16, SL_PCMSAMPLEFORMAT_FIXED_16,
speakers, SL_BYTEORDER_LITTLEENDIAN};
// Describe audio source - buffers + audio format
SLDataSource audio_source = {&queue_desc, &pcm_format};
// Describe audio source - buffers + audio format
SLDataSource audio_source = { &queue_desc, &pcm_format };
// Describe audio sink
SLDataLocator_OutputMix mixer_desc = {SL_DATALOCATOR_OUTPUTMIX, mMixer};
SLDataSink audio_sink = {&mixer_desc, NULL};
// Describe audio sink
SLDataLocator_OutputMix mixer_desc = { SL_DATALOCATOR_OUTPUTMIX, mMixer };
SLDataSink audio_sink = { &mixer_desc, NULL };
// Create player instance
const SLInterfaceID playerInterfaces[] = {SL_IID_ANDROIDSIMPLEBUFFERQUEUE, SL_IID_VOLUME,
SL_IID_ANDROIDCONFIGURATION};
const SLboolean playerInterfacesReqs[] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE};
// Create player instance
const SLInterfaceID playerInterfaces[] = { SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
SL_IID_VOLUME,
SL_IID_ANDROIDCONFIGURATION };
const SLboolean playerInterfacesReqs[] = { SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE };
resultCode = (*OpenSLEngine::instance().getNativeEngine())
->CreateAudioPlayer(OpenSLEngine::instance().getNativeEngine(), &mPlayer, &audio_source,
&audio_sink, 3, playerInterfaces, playerInterfacesReqs);
CHECK_OPENSLES_ERROR;
resultCode = (*OpenSLEngine::instance().getNativeEngine())->CreateAudioPlayer(
OpenSLEngine::instance().getNativeEngine(), &mPlayer,
&audio_source, &audio_sink, 3, playerInterfaces, playerInterfacesReqs);
CHECK_OPENSLES_ERROR;
// Get android config interface
resultCode = (*mPlayer)->GetInterface(mPlayer, SL_IID_ANDROIDCONFIGURATION, &mAndroidConfig);
// Get android config interface
resultCode = (*mPlayer)->GetInterface(mPlayer, SL_IID_ANDROIDCONFIGURATION, &mAndroidConfig);
if (resultCode == SL_RESULT_SUCCESS)
{
SLint32 streamType = voice ? SL_ANDROID_STREAM_VOICE : SL_ANDROID_STREAM_MEDIA;
resultCode = (*mAndroidConfig)
->SetConfiguration(mAndroidConfig, SL_ANDROID_KEY_STREAM_TYPE, &streamType, sizeof(SLint32));
if (resultCode != SL_RESULT_SUCCESS)
ICELogCritical(<< "Failed to set audio destination with error " << (unsigned)resultCode);
}
else
ICELogCritical(<< "Failed to obtain android cfg audio interface with error " << (unsigned)resultCode);
if (resultCode == SL_RESULT_SUCCESS)
{
SLint32 streamType = voice ? SL_ANDROID_STREAM_VOICE : SL_ANDROID_STREAM_MEDIA;
resultCode = (*mAndroidConfig)->SetConfiguration(mAndroidConfig, SL_ANDROID_KEY_STREAM_TYPE,
&streamType, sizeof(SLint32));
if (resultCode != SL_RESULT_SUCCESS)
ICELogCritical(<< "Failed to set audio destination with error " << (unsigned)resultCode);
}
else
ICELogCritical(<< "Failed to obtain android cfg audio interface with error " << (unsigned)resultCode);
// Bring player online
resultCode = (*mPlayer)->Realize(mPlayer, SL_BOOLEAN_FALSE);
CHECK_OPENSLES_ERROR;
// Bring player online
resultCode = (*mPlayer)->Realize(mPlayer, SL_BOOLEAN_FALSE);
CHECK_OPENSLES_ERROR;
// Obtain player control
resultCode = (*mPlayer)->GetInterface(mPlayer, SL_IID_PLAY, &mPlayerControl);
CHECK_OPENSLES_ERROR;
// Obtain player control
resultCode = (*mPlayer)->GetInterface(mPlayer, SL_IID_PLAY, &mPlayerControl);
CHECK_OPENSLES_ERROR;
// Get the buffer queue interface
resultCode = (*mPlayer)->GetInterface(mPlayer, SL_IID_ANDROIDSIMPLEBUFFERQUEUE, &mBufferQueue);
CHECK_OPENSLES_ERROR;
// Get the buffer queue interface
resultCode = (*mPlayer)->GetInterface(mPlayer, SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
&mBufferQueue);
CHECK_OPENSLES_ERROR;
// Setup callback
resultCode = (*mBufferQueue)->RegisterCallback(mBufferQueue, DeviceCallback, this);
CHECK_OPENSLES_ERROR;
// Setup callback
resultCode = (*mBufferQueue)->RegisterCallback(mBufferQueue, DeviceCallback, this);
CHECK_OPENSLES_ERROR;
// Enqueue buffers
mBufferSize = (int)Format(rate, channels).sizeFromTime(AUDIO_SPK_BUFFER_LENGTH);
mPlayBuffer.setCapacity(AUDIO_SPK_BUFFER_COUNT * mBufferSize);
// Enqueue buffers
mBufferSize = (int)Format(rate, channels).sizeFromTime(AUDIO_SPK_BUFFER_LENGTH);
mPlayBuffer.setCapacity(AUDIO_SPK_BUFFER_COUNT * mBufferSize);
mBufferIndex = 0;
for (int i = 0; i < AUDIO_SPK_BUFFER_COUNT; i++)
(*mBufferQueue)->Enqueue(mBufferQueue, mPlayBuffer.data() + i * mBufferSize, (SLuint32)mBufferSize);
mBufferIndex = 0;
for (int i = 0; i < AUDIO_SPK_BUFFER_COUNT; i++)
(*mBufferQueue)->Enqueue(mBufferQueue, mPlayBuffer.data() + i * mBufferSize,
(SLuint32)mBufferSize);
// Set the player's state to playing
resultCode = (*mPlayerControl)->SetPlayState(mPlayerControl, SL_PLAYSTATE_PLAYING);
CHECK_OPENSLES_ERROR;
// Set the player's state to playing
resultCode = (*mPlayerControl)->SetPlayState(mPlayerControl, SL_PLAYSTATE_PLAYING);
CHECK_OPENSLES_ERROR;
ICELogInfo(<< "Android audio output is opened and playing.");
ICELogInfo(<< "Android audio output is opened and playing.");
}
void AndroidOutputDevice::internalClose()
{
if (mPlayer)
if (mPlayer)
{
if (*mPlayer)
{
if (*mPlayer)
{
mInShutdown = true;
ICELogInfo(<< "Stop player");
if (mPlayerControl)
{
if (*mPlayerControl)
{
SLuint32 state = SL_PLAYSTATE_PLAYING;
(*mPlayerControl)->SetPlayState(mPlayerControl, SL_PLAYSTATE_STOPPED);
mInShutdown = true;
ICELogInfo(<< "Stop player");
if (mPlayerControl) {
if (*mPlayerControl) {
SLuint32 state = SL_PLAYSTATE_PLAYING;
(*mPlayerControl)->SetPlayState(mPlayerControl, SL_PLAYSTATE_STOPPED);
while (state != SL_PLAYSTATE_STOPPED)
{
(*mPlayerControl)->GetPlayState(mPlayerControl, &state);
SyncHelper::delay(1);
}
}
}
// Clear buffer queue
ICELogInfo(<< "Clear player buffer queue");
(*mBufferQueue)->Clear(mBufferQueue);
ICELogInfo(<< "Destroy player object");
// Destroy player object
(*mPlayer)->Destroy(mPlayer);
ICELogInfo(<< "Android audio output closed.");
mPlayer = nullptr;
mPlayerControl = nullptr;
mBufferQueue = nullptr;
mEffect = nullptr;
mAndroidConfig = nullptr;
while (state != SL_PLAYSTATE_STOPPED) {
(*mPlayerControl)->GetPlayState(mPlayerControl, &state);
SyncHelper::delay(1);
}
}
}
}
if (mMixer)
{
if (*mMixer)
(*mMixer)->Destroy(mMixer);
mMixer = nullptr;
// Clear buffer queue
ICELogInfo(<< "Clear player buffer queue");
(*mBufferQueue)->Clear(mBufferQueue);
ICELogInfo(<< "Destroy player object");
// Destroy player object
(*mPlayer)->Destroy(mPlayer);
ICELogInfo(<< "Android audio output closed.");
mPlayer = nullptr;
mPlayerControl = nullptr;
mBufferQueue = nullptr;
mEffect = nullptr;
mAndroidConfig = nullptr;
}
}
if (mMixer)
{
if (*mMixer)
(*mMixer)->Destroy(mMixer);
mMixer = nullptr;
}
}
void AndroidOutputDevice::handleCallback(SLAndroidSimpleBufferQueueItf bq)
{
if (mInShutdown)
return;
/*{
char silence[mBufferSize]; memset(silence, 0, mBufferSize);
(*mBufferQueue)->Enqueue(mBufferQueue, silence, mBufferSize);
return;
}*/
if (mInShutdown)
return;
/*{
char silence[mBufferSize]; memset(silence, 0, mBufferSize);
(*mBufferQueue)->Enqueue(mBufferQueue, silence, mBufferSize);
return;
}*/
// Ask producer about data
char* buffer = mPlayBuffer.mutableData() + mBufferIndex * mBufferSize;
if (mConnection)
{
Format f = getFormat();
if (f.mRate != 0)
mConnection->onSpkData(f, buffer, mBufferSize);
}
(*mBufferQueue)->Enqueue(mBufferQueue, buffer, (SLuint32)mBufferSize);
// Ask producer about data
char* buffer = mPlayBuffer.mutableData() + mBufferIndex * mBufferSize;
if (mConnection)
{
Format f = getFormat();
if (f.mRate != 0)
mConnection->onSpkData(f, buffer, mBufferSize);
}
(*mBufferQueue)->Enqueue(mBufferQueue, buffer, (SLuint32)mBufferSize);
mBufferIndex++;
mBufferIndex %= AUDIO_SPK_BUFFER_COUNT;
mBufferIndex++;
mBufferIndex %= AUDIO_SPK_BUFFER_COUNT;
}
void AndroidOutputDevice::DeviceCallback(SLAndroidSimpleBufferQueueItf bq, void* context)
{
if (!context)
return;
if (!context)
return;
try
{
reinterpret_cast<AndroidOutputDevice*>(context)->handleCallback(bq);
}
catch (...)
{
}
try
{
reinterpret_cast<AndroidOutputDevice*>(context)->handleCallback(bq);
}
catch(...)
{}
}
#endif // TARGET_ANDROID
src/engine/audio/Audio_Android.h
+93 -92
View File
@@ -25,120 +25,121 @@
namespace Audio
{
class AndroidEnumerator : public Enumerator
{
public:
AndroidEnumerator();
~AndroidEnumerator();
class AndroidEnumerator: public Enumerator
{
public:
AndroidEnumerator();
~AndroidEnumerator();
void open(int direction);
void close();
void open(int direction);
void close();
int count();
std::string nameAt(int index);
int idAt(int index);
int indexOfDefaultDevice();
int count();
std::string nameAt(int index);
int idAt(int index);
int indexOfDefaultDevice();
protected:
};
protected:
};
class AndroidInputDevice : public InputDevice
{
public:
AndroidInputDevice(int devId);
~AndroidInputDevice();
class AndroidInputDevice: public InputDevice
{
public:
AndroidInputDevice(int devId);
~AndroidInputDevice();
bool open();
void close();
Format getFormat();
bool open();
void close();
Format getFormat();
bool fakeMode();
void setFakeMode(bool fakemode);
int readBuffer(void* buffer);
bool active() const;
bool fakeMode();
void setFakeMode(bool fakemode);
int readBuffer(void* buffer);
bool active() const;
protected:
bool mActive = false;
SLObjectItf mRecorderObject = nullptr;
SLRecordItf mRecorderInterface = nullptr;
SLAndroidSimpleBufferQueueItf mRecorderBufferInterface = nullptr;
SLAndroidConfigurationItf mAndroidCfg = nullptr;
protected:
bool mActive = false;
SLObjectItf mRecorderObject = nullptr;
SLRecordItf mRecorderInterface = nullptr;
SLAndroidSimpleBufferQueueItf mRecorderBufferInterface = nullptr;
SLAndroidConfigurationItf mAndroidCfg = nullptr;
PResampler mResampler;
DataWindow mDeviceRateCache, mSdkRateCache;
int mDeviceRate; // Actual rate of opened recorder
int mBufferSize; // Size of buffer used for recording (at native sample rate)
DataWindow mRecorderBuffer;
std::condition_variable mDataCondVar;
int mRecorderBufferIndex;
std::mutex mMutex;
PResampler mResampler;
DataWindow mDeviceRateCache, mSdkRateCache;
int mDeviceRate; // Actual rate of opened recorder
int mBufferSize; // Size of buffer used for recording (at native sample rate)
DataWindow mRecorderBuffer;
std::condition_variable mDataCondVar;
int mRecorderBufferIndex;
std::mutex mMutex;
void internalOpen(int rateCode, int rate);
void internalClose();
void handleCallback(SLAndroidSimpleBufferQueueItf bq);
static void DeviceCallback(SLAndroidSimpleBufferQueueItf bq, void* context);
};
void internalOpen(int rateCode, int rate);
void internalClose();
void handleCallback(SLAndroidSimpleBufferQueueItf bq);
static void DeviceCallback(SLAndroidSimpleBufferQueueItf bq, void* context);
};
class AndroidOutputDevice : public OutputDevice
{
public:
AndroidOutputDevice(int devId);
~AndroidOutputDevice();
class AndroidOutputDevice: public OutputDevice
{
public:
AndroidOutputDevice(int devId);
~AndroidOutputDevice();
bool open();
void close();
Format getFormat();
bool open();
void close();
Format getFormat();
bool fakeMode();
void setFakeMode(bool fakemode);
bool fakeMode();
void setFakeMode(bool fakemode);
protected:
std::mutex mMutex;
int mDeviceRate = 0;
SLObjectItf mMixer = nullptr;
SLObjectItf mPlayer = nullptr;
SLPlayItf mPlayerControl = nullptr;
SLAndroidSimpleBufferQueueItf mBufferQueue = nullptr;
SLAndroidConfigurationItf mAndroidConfig = nullptr;
SLEffectSendItf mEffect = nullptr;
protected:
std::mutex mMutex;
int mDeviceRate = 0;
SLObjectItf mMixer = nullptr;
SLObjectItf mPlayer = nullptr;
SLPlayItf mPlayerControl = nullptr;
SLAndroidSimpleBufferQueueItf mBufferQueue = nullptr;
SLAndroidConfigurationItf mAndroidConfig = nullptr;
SLEffectSendItf mEffect = nullptr;
DataWindow mPlayBuffer;
int mBufferIndex = 0, mBufferSize = 0;
bool mInShutdown = false;
DataWindow mPlayBuffer;
int mBufferIndex = 0, mBufferSize = 0;
bool mInShutdown = false;
void internalOpen(int rateId, int rate, bool voice);
void internalClose();
void internalOpen(int rateId, int rate, bool voice);
void internalClose();
void handleCallback(SLAndroidSimpleBufferQueueItf bq);
static void DeviceCallback(SLAndroidSimpleBufferQueueItf bq, void* context);
};
void handleCallback(SLAndroidSimpleBufferQueueItf bq);
static void DeviceCallback(SLAndroidSimpleBufferQueueItf bq, void* context);
class OpenSLEngine : public OsEngine
{
public:
OpenSLEngine();
~OpenSLEngine();
};
// open() / close() methods are based on usage counting.
// It means every close() call must be matched by corresponding open() call.
// True audio engine close will happen only on last close() call.
void open() override;
void close() override;
class OpenSLEngine: public OsEngine
{
public:
OpenSLEngine();
~OpenSLEngine();
SLEngineItf getNativeEngine() const;
// open() / close() methods are based on usage counting.
// It means every close() call must be matched by corresponding open() call.
// True audio engine close will happen only on last close() call.
void open() override;
void close() override;
static OpenSLEngine& instance();
SLEngineItf getNativeEngine() const;
protected:
std::mutex mMutex;
int mUsageCounter = 0;
SLObjectItf mEngineObject = nullptr;
SLEngineItf mEngineInterface = nullptr;
static OpenSLEngine& instance();
void internalOpen();
void internalClose();
};
} // namespace Audio
protected:
std::mutex mMutex;
int mUsageCounter = 0;
SLObjectItf mEngineObject = nullptr;
SLEngineItf mEngineInterface = nullptr;
void internalOpen();
void internalClose();
};
}
#endif // TARGET_ANDROID
src/engine/audio/Audio_AndroidOboe.cpp
+131 -182
View File
@@ -4,293 +4,242 @@
#include <mutex>
#include <iostream>
#include <stdexcept>
#include <algorithm>
#include "../helper/HL_String.h"
#include "../helper/HL_Time.h"
#ifdef TARGET_ANDROID
#define LOG_SUBSYSTEM "audio"
#define LOG_SUBSYSTEM "Audio"
using namespace Audio;
// -------------------- AndroidEnumerator -----------------------------
AndroidEnumerator::AndroidEnumerator() {}
AndroidEnumerator::AndroidEnumerator()
{}
AndroidEnumerator::~AndroidEnumerator() {}
AndroidEnumerator::~AndroidEnumerator()
{}
int AndroidEnumerator::indexOfDefaultDevice()
{
return 0;
return 0;
}
int AndroidEnumerator::count()
{
return 1;
return 1;
}
int AndroidEnumerator::idAt(int index)
{
return 0;
return 0;
}
std::string AndroidEnumerator::nameAt(int index)
{
return "Audio";
return "Audio";
}
void AndroidEnumerator::open(int direction) {}
void AndroidEnumerator::open(int direction)
{}
void AndroidEnumerator::close() {}
void AndroidEnumerator::close()
{}
// --------------- Input implementation ----------------
AndroidInputDevice::AndroidInputDevice(int devId) {}
AndroidInputDevice::AndroidInputDevice(int devId)
{}
AndroidInputDevice::~AndroidInputDevice()
{
close();
close();
}
bool AndroidInputDevice::open()
{
if (active())
return true;
if (active())
return true;
oboe::AudioStreamBuilder builder;
builder.setDirection(oboe::Direction::Input);
builder.setPerformanceMode(oboe::PerformanceMode::LowLatency);
builder.setSharingMode(oboe::SharingMode::Exclusive);
builder.setFormat(oboe::AudioFormat::I16);
builder.setChannelCount(oboe::ChannelCount::Mono);
builder.setCallback(this);
oboe::Result rescode = builder.openStream(&mRecordingStream);
if (rescode != oboe::Result::OK)
return false;
oboe::AudioStreamBuilder builder;
builder.setDirection(oboe::Direction::Input);
builder.setPerformanceMode(oboe::PerformanceMode::LowLatency);
builder.setSharingMode(oboe::SharingMode::Exclusive);
builder.setFormat(oboe::AudioFormat::I16);
builder.setChannelCount(oboe::ChannelCount::Mono);
builder.setCallback(this);
oboe::Result rescode = builder.openStream(&mRecordingStream);
if (rescode != oboe::Result::OK)
return false;
mDeviceRate = mRecordingStream->getSampleRate();
ICELogInfo(<< "Input Opened with rate " << mDeviceRate);
mActive = true;
mDeviceRate = mRecordingStream->getSampleRate();
ICELogInfo(<< "Input Opened with rate " << mDeviceRate);
mActive = true;
rescode = mRecordingStream->requestStart();
if (rescode != oboe::Result::OK)
{
close();
mActive = false;
}
return mActive;
rescode = mRecordingStream->requestStart();
if (rescode != oboe::Result::OK)
{
close();
mActive = false;
}
return mActive;
}
void AndroidInputDevice::close()
{
// There is no check for active() value because close() can be called to cleanup after bad open() call.
if (mRecordingStream != nullptr)
{
mRecordingStream->close();
delete mRecordingStream;
mRecordingStream = nullptr;
}
mActive = false;
// There is no check for active() value because close() can be called to cleanup after bad open() call.
if (mRecordingStream != nullptr)
{
mRecordingStream->close();
delete mRecordingStream; mRecordingStream = nullptr;
}
mActive = false;
}
oboe::DataCallbackResult AndroidInputDevice::onAudioReady(oboe::AudioStream* audioStream, void* audioData,
int32_t numFrames)
oboe::DataCallbackResult
AndroidInputDevice::onAudioReady(oboe::AudioStream *audioStream, void *audioData, int32_t numFrames)
{
std::unique_lock<std::mutex> l(mMutex);
std::unique_lock<std::mutex> l(mMutex);
// Send data to AudioPair
if (mConnection)
mConnection->onMicData(getFormat(), audioData, numFrames);
// Send data to AudioPair
if (mConnection)
mConnection->onMicData(getFormat(), audioData, numFrames);
return oboe::DataCallbackResult::Continue;
return oboe::DataCallbackResult::Continue;
}
Format AndroidInputDevice::getFormat()
{
return Format(mDeviceRate, 1);
return Format(mDeviceRate, 1);
}
bool AndroidInputDevice::active() const
{
return mActive;
return mActive;
}
bool AndroidInputDevice::fakeMode()
{
return false;
return false;
}
void AndroidInputDevice::setFakeMode(bool fakemode) {}
void AndroidInputDevice::setFakeMode(bool fakemode)
{}
int AndroidInputDevice::readBuffer(void* buffer)
int AndroidInputDevice::readBuffer(void* buffer)
{
throw std::runtime_error("AndroidInputDevice::readBuffer() is not implemented.");
throw std::runtime_error("AndroidInputDevice::readBuffer() is not implemented.");
}
// ------------ AndroidOutputDevice -----------------
AndroidOutputDevice::AndroidOutputDevice(int devId)
{
ICELogDebug(<< "Creating AndroidOutputDevice. This is: " << strx::toHex(this));
ICELogDebug(<< "Creating AndroidOutputDevice. This is: " << StringHelper::toHex(this));
}
AndroidOutputDevice::~AndroidOutputDevice()
{
ICELogDebug(<< "Deleting AndroidOutputDevice.");
// Mark shutdown before closing so a disconnect callback racing with teardown
// does not resurrect the stream via onErrorAfterClose()'s restart.
mInShutdown = true;
close();
ICELogDebug(<< "Deleting AndroidOutputDevice.");
close();
}
bool AndroidOutputDevice::open()
{
std::unique_lock<std::mutex> l(mMutex);
std::unique_lock<std::mutex> l(mMutex);
if (mActive)
return true;
if (mActive)
return true;
mInShutdown = false;
mRequestedFrames = 0;
mStartTime = 0.0;
mEndTime = 0.0;
mRequestedFrames = 0;
mStartTime = 0.0;
mEndTime = 0.0;
oboe::AudioStreamBuilder builder;
builder.setDirection(oboe::Direction::Output);
builder.setPerformanceMode(oboe::PerformanceMode::LowLatency);
builder.setSharingMode(oboe::SharingMode::Exclusive);
builder.setFormat(oboe::AudioFormat::I16);
builder.setChannelCount(oboe::ChannelCount::Mono);
// Route through the platform voice-call path: correct device selection/volume
// and platform voice tuning for a softphone.
builder.setUsage(oboe::Usage::VoiceCommunication);
builder.setContentType(oboe::ContentType::Speech);
// builder.setDataCallback(this);
builder.setCallback(this);
// builder.setErrorCallback(this)
oboe::AudioStreamBuilder builder;
builder.setDirection(oboe::Direction::Output);
builder.setPerformanceMode(oboe::PerformanceMode::LowLatency);
builder.setSharingMode(oboe::SharingMode::Exclusive);
builder.setFormat(oboe::AudioFormat::I16);
builder.setChannelCount(oboe::ChannelCount::Mono);
// builder.setDataCallback(this);
builder.setCallback(this);
//builder.setErrorCallback(this)
oboe::Result rescode = builder.openStream(&mPlayingStream);
if (rescode != oboe::Result::OK)
return false;
oboe::Result rescode = builder.openStream(&mPlayingStream);
if (rescode != oboe::Result::OK)
return false;
mDeviceRate = mPlayingStream->getSampleRate();
ICELogInfo(<< "Output opened with rate " << mDeviceRate);
mActive = true;
mDeviceRate = mPlayingStream->getSampleRate();
ICELogInfo(<< "Input Opened with rate " << mDeviceRate);
mActive = true;
rescode = mPlayingStream->requestStart();
if (rescode != oboe::Result::OK)
{
close();
mActive = false;
return mActive;
}
// Latch the burst size and start from a two-burst buffer. onAudioReady() grows
// this on XRuns (up to a cap) so we keep low latency when the device can sustain
// it and trade a little latency for glitch-free playback when it can't.
mBurstFrames = mPlayingStream->getFramesPerBurst();
mXRunLast = 0;
mHeartbeatLast = 0.0f;
if (mBurstFrames > 0)
mPlayingStream->setBufferSizeInFrames(mBurstFrames * 2);
return mActive;
rescode = mPlayingStream->requestStart();
if (rescode != oboe::Result::OK)
{
close();
mActive = false;
}
return mActive;
}
void AndroidOutputDevice::close()
{
std::unique_lock<std::mutex> l(mMutex);
if (!mActive)
return;
std::unique_lock<std::mutex> l(mMutex);
if (!mActive)
return;
if (mPlayingStream != nullptr)
{
mPlayingStream->close();
delete mPlayingStream;
mPlayingStream = nullptr;
}
mEndTime = now_ms();
mActive = false;
if (mPlayingStream != nullptr)
{
mPlayingStream->close();
delete mPlayingStream; mPlayingStream = nullptr;
}
mEndTime = now_ms();
mActive = false;
ICELogInfo(<< "For time " << mEndTime - mStartTime << " ms was requested "
<< float(mRequestedFrames) / getFormat().mRate * 1000 << " ms");
ICELogInfo(<< "For time " << mEndTime - mStartTime << " ms was requested "
<< float(mRequestedFrames) / getFormat().mRate * 1000 << " ms");
}
Format AndroidOutputDevice::getFormat()
{
return {mDeviceRate, 1};
return {mDeviceRate, 1};
}
bool AndroidOutputDevice::fakeMode()
{
return false;
return false;
}
void AndroidOutputDevice::setFakeMode(bool /*fakemode*/) {}
oboe::DataCallbackResult AndroidOutputDevice::onAudioReady(oboe::AudioStream* audioStream, void* audioData,
int32_t numFrames)
void AndroidOutputDevice::setFakeMode(bool /*fakemode*/)
{
if (mInShutdown)
return oboe::DataCallbackResult::Stop;
if (mStartTime == 0.0)
mStartTime = now_ms();
// Ask producer about data
memset(audioData, 0, numFrames * 2);
if (mConnection)
{
Format f = getFormat();
if (f.mRate != 0)
mConnection->onSpkData(f, audioData, numFrames * 2);
}
mRequestedFrames += numFrames;
// Adaptive buffer sizing: on new XRuns (device-side underruns, i.e. we missed a
// callback deadline), grow the buffer one burst at a time up to a cap. Both calls
// are documented as safe from within the data callback.
auto xrun = audioStream->getXRunCount();
if (xrun && xrun.value() > mXRunLast)
{
mXRunLast = xrun.value();
if (mBurstFrames > 0)
{
int32_t cap = mBurstFrames * 8;
int32_t cur = audioStream->getBufferSizeInFrames();
int32_t next = std::min(cur + mBurstFrames, cap);
if (next > cur)
audioStream->setBufferSizeInFrames(next);
}
}
// Device-side heartbeat (Step 0): surfaces XRuns/buffer growth so device glitches
// can be told apart from network/jitter impairments.
float t = now_ms();
if (mHeartbeatLast == 0.0f)
mHeartbeatLast = t;
else if (t - mHeartbeatLast >= 5000.0f)
{
ICELogInfo(<< "[spk-heartbeat] xruns=" << mXRunLast << " bufFrames=" << audioStream->getBufferSizeInFrames()
<< " burst=" << mBurstFrames << " rate=" << mDeviceRate);
mHeartbeatLast = t;
}
return oboe::DataCallbackResult::Continue;
}
// Disconnect recovery: on a route change (headset/BT plug/unplug) AAudio tears the
// stream down and calls this on its own thread after the stream is closed. Rebuild
// on the new default route so audio doesn't silently die mid-call.
// See https://github.com/google/oboe/blob/master/docs/notes/disconnect.md
void AndroidOutputDevice::onErrorAfterClose(oboe::AudioStream* stream, oboe::Result result)
oboe::DataCallbackResult AndroidOutputDevice::onAudioReady(oboe::AudioStream *audioStream, void *audioData, int32_t numFrames)
{
if (result == oboe::Result::ErrorDisconnected && !mInShutdown)
{
ICELogInfo(<< "Output stream disconnected; restarting on the new route");
// close() and open() each take mMutex internally; this callback holds none.
close();
open();
}
if (mInShutdown)
return oboe::DataCallbackResult::Stop;
if (mStartTime == 0.0)
mStartTime = now_ms();
// Ask producer about data
memset(audioData, 0, numFrames * 2);
if (mConnection)
{
Format f = getFormat();
if (f.mRate != 0)
mConnection->onSpkData(f, audioData, numFrames * 2);
}
mRequestedFrames += numFrames;
return oboe::DataCallbackResult::Continue;
}
// TODO - special case https://github.com/google/oboe/blob/master/docs/notes/disconnect.md
void AndroidOutputDevice::onErrorAfterClose(oboe::AudioStream *stream, oboe::Result result) {
if (result == oboe::Result::ErrorDisconnected) {
// LOGI("Restarting AudioStream after disconnect");
// soundEngine.restart(); // please check oboe samples for soundEngine.restart(); call
}
}
#endif // TARGET_ANDROID
src/engine/audio/Audio_AndroidOboe.h
+63 -67
View File
@@ -25,88 +25,84 @@
namespace Audio
{
class AndroidEnumerator : public Enumerator
{
public:
AndroidEnumerator();
~AndroidEnumerator();
class AndroidEnumerator: public Enumerator
{
public:
AndroidEnumerator();
~AndroidEnumerator();
void open(int direction);
void close();
void open(int direction);
void close();
int count();
std::string nameAt(int index);
int idAt(int index);
int indexOfDefaultDevice();
int count();
std::string nameAt(int index);
int idAt(int index);
int indexOfDefaultDevice();
protected:
};
protected:
};
class AndroidInputDevice : public InputDevice, public oboe::AudioStreamCallback
{
public:
AndroidInputDevice(int devId);
~AndroidInputDevice();
class AndroidInputDevice: public InputDevice, public oboe::AudioStreamCallback
{
public:
AndroidInputDevice(int devId);
~AndroidInputDevice();
bool open();
void close();
Format getFormat();
bool open();
void close();
Format getFormat();
bool fakeMode();
void setFakeMode(bool fakemode);
int readBuffer(void* buffer);
bool active() const;
bool fakeMode();
void setFakeMode(bool fakemode);
int readBuffer(void* buffer);
bool active() const;
oboe::DataCallbackResult onAudioReady(oboe::AudioStream* audioStream, void* audioData, int32_t numFrames);
oboe::DataCallbackResult
onAudioReady(oboe::AudioStream *audioStream, void *audioData, int32_t numFrames);
protected:
bool mActive = false;
oboe::AudioStream* mRecordingStream = nullptr;
PResampler mResampler;
DataWindow mDeviceRateCache, mSdkRateCache;
int mDeviceRate; // Actual rate of opened recorder
int mBufferSize; // Size of buffer used for recording (at native sample rate)
DataWindow mRecorderBuffer;
std::condition_variable mDataCondVar;
int mRecorderBufferIndex;
std::mutex mMutex;
};
protected:
bool mActive = false;
oboe::AudioStream* mRecordingStream = nullptr;
PResampler mResampler;
DataWindow mDeviceRateCache, mSdkRateCache;
int mDeviceRate; // Actual rate of opened recorder
int mBufferSize; // Size of buffer used for recording (at native sample rate)
DataWindow mRecorderBuffer;
std::condition_variable mDataCondVar;
int mRecorderBufferIndex;
std::mutex mMutex;
};
class AndroidOutputDevice : public OutputDevice, public oboe::AudioStreamCallback
{
public:
AndroidOutputDevice(int devId);
~AndroidOutputDevice();
class AndroidOutputDevice: public OutputDevice, public oboe::AudioStreamCallback
{
public:
AndroidOutputDevice(int devId);
~AndroidOutputDevice();
bool open();
void close();
Format getFormat();
bool open();
void close();
Format getFormat();
bool fakeMode();
void setFakeMode(bool fakemode);
bool fakeMode();
void setFakeMode(bool fakemode);
oboe::DataCallbackResult onAudioReady(oboe::AudioStream* audioStream, void* audioData, int32_t numFrames);
void onErrorAfterClose(oboe::AudioStream* stream, oboe::Result result);
oboe::DataCallbackResult onAudioReady(oboe::AudioStream *audioStream, void *audioData, int32_t numFrames);
void onErrorAfterClose(oboe::AudioStream *stream, oboe::Result result);
protected:
std::mutex mMutex;
int mDeviceRate = 0;
oboe::AudioStream* mPlayingStream = nullptr;
DataWindow mPlayBuffer;
int mBufferIndex = 0, mBufferSize = 0;
bool mInShutdown = false;
bool mActive = false;
protected:
std::mutex mMutex;
int mDeviceRate = 0;
oboe::AudioStream* mPlayingStream = nullptr;
DataWindow mPlayBuffer;
int mBufferIndex = 0, mBufferSize = 0;
bool mInShutdown = false;
bool mActive = false;
// Adaptive buffer sizing + device-side diagnostics (Step 0 / #5).
int32_t mBurstFrames = 0; // frames per burst, latched at open()
int32_t mXRunLast = 0; // last observed cumulative XRun count
float mHeartbeatLast = 0.0f; // now_ms() of last device heartbeat log
// Statistics
float mRequestedFrames = 0.0, mStartTime = 0.0, mEndTime = 0.0;
};
} // namespace Audio
// Statistics
float mRequestedFrames = 0.0, mStartTime = 0.0, mEndTime = 0.0;
};
}
#endif // TARGET_ANDROID
src/engine/audio/Audio_CoreAudio.cpp
+483 -418
View File
File diff suppressed because it is too large Load Diff
src/engine/audio/Audio_CoreAudio.h
+103 -96
View File
@@ -25,71 +25,69 @@
namespace Audio
{
class AudioException : public Exception
class AudioException: public Exception
{
public:
AudioException(int code, OSStatus subcode) : Exception(code, int(subcode)) {}
AudioException(int code, OSStatus subcode)
:Exception(code, int(subcode))
{}
};
// #ifndef AudioDeviceID
// # define AudioDeviceID unsigned
// #endif
class MacEnumerator : public Enumerator
//#ifndef AudioDeviceID
//# define AudioDeviceID unsigned
//#endif
class MacEnumerator: public Enumerator
{
public:
MacEnumerator();
~MacEnumerator();
MacEnumerator();
~MacEnumerator();
void open(int direction);
void close();
void open(int direction);
void close();
int count();
std::tstring nameAt(int index);
int idAt(int index);
int indexOfDefaultDevice();
int count();
std::tstring nameAt(int index);
int idAt(int index);
int indexOfDefaultDevice();
protected:
struct DeviceInfo
{
AudioDeviceID mId;
std::string mName;
bool mCanChangeOutputVolume;
bool mCanChangeInputVolume;
int mInputCount, mOutputCount;
int mDefaultRate;
DeviceInfo()
: mId(0), mCanChangeOutputVolume(false), mCanChangeInputVolume(false), mInputCount(0), mOutputCount(0),
mDefaultRate(16000)
{
}
};
std::vector<DeviceInfo> mDeviceList;
unsigned mDefaultInput, mDefaultOutput;
int mDirection;
void getInfo(DeviceInfo& di);
struct DeviceInfo
{
AudioDeviceID mId;
std::string mName;
bool mCanChangeOutputVolume;
bool mCanChangeInputVolume;
int mInputCount, mOutputCount;
int mDefaultRate;
DeviceInfo(): mId(0), mCanChangeOutputVolume(false), mCanChangeInputVolume(false), mInputCount(0), mOutputCount(0), mDefaultRate(16000) {}
};
std::vector<DeviceInfo> mDeviceList;
unsigned mDefaultInput, mDefaultOutput;
int mDirection;
void getInfo(DeviceInfo& di);
};
class CoreAudioUnit
{
public:
CoreAudioUnit();
~CoreAudioUnit();
CoreAudioUnit();
~CoreAudioUnit();
void open(bool voice);
void close();
AudioStreamBasicDescription getFormat(int scope, int bus);
void setFormat(AudioStreamBasicDescription& format, int scope, int bus);
bool getEnabled(int scope, int bus);
void setEnabled(bool enabled, int scope, int bus);
void makeCurrent(AudioDeviceID deviceId, int scope, int bus);
void setCallback(AURenderCallbackStruct cb, int callbackType, int scope, int bus);
void setBufferFrameSizeInMilliseconds(int ms);
int getBufferFrameSize();
void initialize();
AudioUnit getHandle();
void open(bool voice);
void close();
AudioStreamBasicDescription getFormat(int scope, int bus);
void setFormat(AudioStreamBasicDescription& format, int scope, int bus);
bool getEnabled(int scope, int bus);
void setEnabled(bool enabled, int scope, int bus);
void makeCurrent(AudioDeviceID deviceId, int scope, int bus);
void setCallback(AURenderCallbackStruct cb, int callbackType, int scope, int bus);
void setBufferFrameSizeInMilliseconds(int ms);
int getBufferFrameSize();
void initialize();
AudioUnit getHandle();
protected:
AudioUnit mUnit;
AudioUnit mUnit;
};
class MacDevice
@@ -98,92 +96,101 @@ public:
MacDevice(int devId);
~MacDevice();
bool open();
void close();
void setRender(bool render);
void setCapture(bool capture);
int getId();
Format getFormat();
bool open();
void close();
void setRender(bool render);
void setCapture(bool capture);
int getId();
Format getFormat();
DataConnection* connection();
void setConnection(DataConnection* c);
void provideAudioToSpeaker(int channels, void* buffer, int length);
void obtainAudioFromMic(int channels, const void* buffer, int length);
void setConnection(DataConnection* c);
void provideAudioToSpeaker(int channels, void* buffer, int length);
void obtainAudioFromMic(int channels, const void* buffer, int length);
protected:
AudioDeviceID mDeviceId;
bool mCapture, mRender;
bool mActive;
int mUsageCount;
Mutex mGuard;
AudioDeviceID mDeviceId;
bool mCapture, mRender;
bool mActive;
int mUsageCount;
Mutex mGuard;
CoreAudioUnit mAudioUnit;
AudioComponent mComponent;
AudioStreamBasicDescription mCaptureInputFormat, mCaptureOutputFormat, mRenderInputFormat, mRenderOutputFormat,
mStreamFormat;
CoreAudioUnit mAudioUnit;
AudioComponent mComponent;
AudioStreamBasicDescription mCaptureInputFormat, mCaptureOutputFormat, mRenderInputFormat, mRenderOutputFormat, mStreamFormat;
AudioBufferList* mInputBufferList;
DataConnection* mConnection;
SpeexResampler mCaptureResampler, mRenderResampler;
ByteBuffer mTail;
DataWindow mInputBuffer, mOutputBuffer;
bool createUnit(bool voice);
void destroyUnit();
void startStream();
void stopStream();
void setupStreamFormat();
bool createResampleUnit(AudioStreamBasicDescription format);
DataConnection* mConnection;
SpeexResampler mCaptureResampler, mRenderResampler;
ByteBuffer mTail;
DataWindow mInputBuffer, mOutputBuffer;
bool createUnit(bool voice);
void destroyUnit();
void startStream();
void stopStream();
void setupStreamFormat();
bool createResampleUnit(AudioStreamBasicDescription format);
static OSStatus outputCallback(void* inRefCon, AudioUnitRenderActionFlags* ioActionFlags,
const AudioTimeStamp* inTimeStamp, UInt32 inBusNumber, UInt32 inNumberFrames,
AudioBufferList* ioData);
static OSStatus outputCallback( void *inRefCon,
AudioUnitRenderActionFlags *ioActionFlags,
const AudioTimeStamp *inTimeStamp,
UInt32 inBusNumber,
UInt32 inNumberFrames,
AudioBufferList *ioData );
static OSStatus inputCallback(void* inRefCon, AudioUnitRenderActionFlags* ioActionFlags,
const AudioTimeStamp* inTimeStamp, UInt32 inBusNumber, UInt32 inNumberFrames,
AudioBufferList* ioData);
static OSStatus inputCallback(void *inRefCon,
AudioUnitRenderActionFlags *ioActionFlags,
const AudioTimeStamp *inTimeStamp,
UInt32 inBusNumber,
UInt32 inNumberFrames,
AudioBufferList *ioData);
#ifdef TARGET_IOS
static void propListener(void* inClientData, AudioSessionPropertyID inID, UInt32 inDataSize, const void* inData);
static void interruptionListener(void* inClientData, UInt32 inInterruption);
static void propListener(void *inClientData,
AudioSessionPropertyID inID,
UInt32 inDataSize,
const void * inData);
static void interruptionListener(void *inClientData, UInt32 inInterruption);
#endif
};
typedef std::shared_ptr<MacDevice> PMacDevice;
class MacInputDevice : public InputDevice
class MacInputDevice: public InputDevice
{
public:
MacInputDevice(int devId);
~MacInputDevice();
bool open();
void close();
bool open();
void close();
Format getFormat();
bool fakeMode();
void setFakeMode(bool fakemode);
int readBuffer(void* buffer);
bool fakeMode();
void setFakeMode(bool fakemode);
int readBuffer(void* buffer);
protected:
PMacDevice mDevice;
};
class MacOutputDevice : public OutputDevice
class MacOutputDevice: public OutputDevice
{
public:
MacOutputDevice(int devId);
~MacOutputDevice();
bool open();
void close();
bool open();
void close();
Format getFormat();
bool fakeMode();
void setFakeMode(bool fakemode);
bool fakeMode();
void setFakeMode(bool fakemode);
protected:
PMacDevice mDevice;
};
} // namespace Audio
}
#endif // TARGET_OSX
src/engine/audio/Audio_DataWindow.cpp
+103 -134
View File
@@ -1,4 +1,4 @@
/* Copyright(C) 2007-2026 VoIP objects (voipobjects.com)
/* Copyright(C) 2007-2018 VoIP objects (voipobjects.com)
* 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/. */
@@ -8,204 +8,173 @@
using namespace Audio;
DataWindow::DataWindow() {}
DataWindow::DataWindow()
{
mFilled = 0;
mData = NULL;
mCapacity = 0;
}
DataWindow::~DataWindow()
{
if (mData)
{
free(mData);
mData = nullptr;
}
if (mData)
free(mData);
}
void DataWindow::setCapacity(size_t capacity)
void DataWindow::setCapacity(int capacity)
{
Lock l(mMutex);
// The window only ever grows; a smaller request keeps the current buffer.
if (capacity <= mCapacity)
return;
size_t tail = capacity - mCapacity;
char* buffer = mData;
mData = (char*)realloc(mData, capacity);
if (!mData)
{
// Realloc failed
mData = buffer;
throw std::bad_alloc();
}
if (tail > 0)
memset(mData + mCapacity, 0, tail);
mCapacity = capacity;
Lock l(mMutex);
int tail = capacity - mCapacity;
mData = (char*)realloc(mData, capacity);
if (tail > 0)
memset(mData + mCapacity, 0, tail);
mCapacity = capacity;
}
void DataWindow::addZero(size_t length)
void DataWindow::addZero(int length)
{
Lock l(mMutex);
Lock l(mMutex);
if (length > mCapacity)
length = mCapacity;
if (length > mCapacity)
length = mCapacity;
int avail = mCapacity - mFilled;
int avail = mCapacity - mFilled;
if (avail < length)
{
memmove(mData, mData + length - avail, mFilled - (length - avail));
mFilled -= length - avail;
}
memset(mData + mFilled, 0, length);
mFilled += length;
if (avail < length)
{
memmove(mData, mData + length - avail, mFilled - (length - avail));
mFilled -= length - avail;
}
memset(mData + mFilled, 0, length);
mFilled += length;
}
void DataWindow::add(const void* data, size_t length)
void DataWindow::add(const void* data, int length)
{
Lock l(mMutex);
Lock l(mMutex);
if (length > mCapacity)
{
// Use latest bytes from data buffer in this case.
data = (char*)data + length - mCapacity;
length = mCapacity;
}
if (length > mCapacity)
{
// Use latest bytes from data buffer in this case.
data = (char*)data + length - mCapacity;
length = mCapacity;
}
// Check how much free space we have
int avail = mCapacity - mFilled;
// Check how much free space we have
int avail = mCapacity - mFilled;
if (avail < length)
{
// Find the portion of data to move & save
int delta = length - avail;
if (avail < length)
{
// Find the portion of data to move & save
int delta = length - avail;
// Move the data
if (mFilled - delta > 0)
memmove(mData, mData + delta, mFilled - delta);
mFilled -= delta;
}
// Move the data
if (mFilled - delta > 0)
memmove(mData, mData + delta, mFilled - delta);
mFilled -= delta;
}
memcpy(mData + mFilled, data, length);
mFilled += length;
memcpy(mData + mFilled, data, length);
mFilled += length;
}
void DataWindow::add(short sample)
{
add(&sample, sizeof sample);
add(&sample, sizeof sample);
}
void DataWindow::erase(size_t length)
void DataWindow::erase(int length)
{
Lock l(mMutex);
if (length > mFilled)
length = mFilled;
if (length != mFilled)
memmove(mData, mData + length, mFilled - length);
mFilled -= length;
Lock l(mMutex);
if (length > mFilled)
length = mFilled;
if (length != mFilled)
memmove(mData, mData + length, mFilled - length);
mFilled -= length;
}
const char* DataWindow::data() const
{
return mData;
return mData;
}
char* DataWindow::mutableData()
{
return mData;
return mData;
}
void DataWindow::clear()
{
Lock l(mMutex);
mFilled = 0;
Lock l(mMutex);
mFilled = 0;
}
short DataWindow::shortAt(size_t index) const
short DataWindow::shortAt(int index) const
{
Lock l(mMutex);
assert(index < mFilled / 2);
return ((short*)mData)[index];
Lock l(mMutex);
assert(index < mFilled / 2);
return ((short*)mData)[index];
}
void DataWindow::setShortAt(short value, size_t index)
void DataWindow::setShortAt(short value, int index)
{
Lock l(mMutex);
assert(index < mFilled / 2);
((short*)mData)[index] = value;
Lock l(mMutex);
assert(index < mFilled / 2);
((short*)mData)[index] = value;
}
size_t DataWindow::read(void* buffer, size_t length)
int DataWindow::read(void* buffer, int length)
{
Lock l(mMutex);
if (length > mFilled)
length = mFilled;
if (length)
{
if (buffer)
memcpy(buffer, mData, length);
if (length < mFilled)
memmove(mData, mData + length, mFilled - length);
mFilled -= length;
}
return length;
Lock l(mMutex);
if (length > mFilled)
length = mFilled;
if (length)
{
if (buffer)
memcpy(buffer, mData, length);
if (length < mFilled)
memmove(mData, mData+length, mFilled - length);
mFilled -= length;
}
return length;
}
size_t DataWindow::filled() const
int DataWindow::filled() const
{
Lock l(mMutex);
return mFilled;
Lock l(mMutex);
return mFilled;
}
void DataWindow::setFilled(size_t filled)
void DataWindow::setFilled(int filled)
{
Lock l(mMutex);
if (filled > mCapacity)
throw std::bad_alloc();
mFilled = filled;
Lock l(mMutex);
mFilled = filled;
}
size_t DataWindow::capacity() const
int DataWindow::capacity() const
{
Lock l(mMutex);
return mCapacity;
Lock l(mMutex);
return mCapacity;
}
void DataWindow::zero(size_t length)
void DataWindow::zero(int length)
{
Lock l(mMutex);
assert(length <= mCapacity);
mFilled = length;
memset(mData, 0, mFilled);
}
size_t DataWindow::moveTo(DataWindow& dst, size_t size)
{
Lock l(mMutex);
size_t avail = std::min(size, (size_t)filled());
if (avail != 0)
{
dst.add(mData, avail);
erase(avail);
}
return avail;
}
std::chrono::milliseconds DataWindow::getTimeLength(const Audio::Format& fmt) const
{
Lock l(mMutex);
return std::chrono::milliseconds(mFilled / sizeof(short) / fmt.channels() / (fmt.rate() / 1000));
Lock l(mMutex);
assert(length <= mCapacity);
mFilled = length;
memset(mData, 0, mFilled);
}
void DataWindow::makeStereoFromMono(DataWindow& dst, DataWindow& src)
{
Lock lockDst(dst.mMutex), lockSrc(src.mMutex);
Lock lockDst(dst.mMutex), lockSrc(src.mMutex);
dst.setCapacity(src.filled() * 2);
short* input = (short*)src.mutableData();
short* output = (short*)dst.mutableData();
dst.setCapacity(src.filled()*2);
short* input = (short*)src.mutableData();
short* output = (short*)dst.mutableData();
for (int i = 0; i < src.filled() / 2; i++)
output[i * 2] = output[i * 2 + 1] = input[i];
dst.mFilled = src.filled() * 2;
for (int i=0; i<src.filled()/2; i++)
output[i*2] = output[i*2+1] = input[i];
dst.mFilled = src.filled() * 2;
}
src/engine/audio/Audio_DataWindow.h
+25 -29
View File
@@ -8,44 +8,40 @@
#include "../helper/HL_ByteBuffer.h"
#include "../helper/HL_Sync.h"
#include "Audio_Interface.h"
namespace Audio
{
class DataWindow
{
public:
class DataWindow
{
public:
DataWindow();
~DataWindow();
void setCapacity(size_t capacity);
size_t capacity() const;
void setCapacity(int capacity);
int capacity() const;
void addZero(size_t length);
void add(const void* data, size_t length);
void add(short sample);
size_t read(void* buffer, size_t length);
void erase(size_t length);
const char* data() const;
char* mutableData();
size_t filled() const;
void setFilled(size_t filled);
void clear();
void addZero(int length);
void add(const void* data, int length);
void add(short sample);
int read(void* buffer, int length);
void erase(int length = -1);
const char* data() const;
char* mutableData();
int filled() const;
void setFilled(int filled);
void clear();
short shortAt(size_t index) const;
void setShortAt(short value, size_t index);
void zero(size_t length);
size_t moveTo(DataWindow& dst, size_t size /* in bytes*/);
short shortAt(int index) const;
void setShortAt(short value, int index);
void zero(int length);
std::chrono::milliseconds getTimeLength(const Format& fmt) const;
static void makeStereoFromMono(DataWindow& dst, DataWindow& src);
static void makeStereoFromMono(DataWindow& dst, DataWindow& src);
protected:
protected:
mutable Mutex mMutex;
char* mData = nullptr;
size_t mFilled = 0;
size_t mCapacity = 0;
};
} // namespace Audio
char* mData;
int mFilled;
int mCapacity;
};
}
#endif
src/engine/audio/Audio_DevicePair.cpp
+139 -185
View File
@@ -1,286 +1,240 @@
/* Copyright(C) 2007-2026 VoIPobjects (voipobjects.com)
/* Copyright(C) 2007-2017 VoIPobjects (voipobjects.com)
* 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/. */
#define NOMINMAX
#include "Audio_DevicePair.h"
#include <algorithm>
#include <assert.h>
#define LOG_SUBSYSTEM "audio"
#define LOG_SUBSYSTEM "Audio"
using namespace Audio;
// --- DevicePair ---
DevicePair::DevicePair()
: mConfig(nullptr), mDelegate(nullptr), mAec(false), mAgc(false),
mAecFilter(AUDIO_MIC_BUFFER_LENGTH * 10, AUDIO_MIC_BUFFER_LENGTH, AUDIO_SAMPLERATE), mAgcFilter(AUDIO_CHANNELS),
mMonitoring(nullptr)
DevicePair::DevicePair(bool aec, bool agc)
:mConfig(NULL), mDelegate(NULL), mAec(aec), mAgc(agc), mAecFilter(AUDIO_MIC_BUFFER_LENGTH*10, AUDIO_MIC_BUFFER_LENGTH, AUDIO_SAMPLERATE), mAgcFilter(AUDIO_CHANNELS)
{
mInputBuffer.setCapacity(AUDIO_MIC_BUFFER_SIZE * (AUDIO_MIC_BUFFER_COUNT + 1));
mOutputBuffer.setCapacity(AUDIO_SPK_BUFFER_SIZE * (AUDIO_SPK_BUFFER_COUNT + 1));
mInputResampingData.setCapacity(AUDIO_MIC_BUFFER_SIZE * (AUDIO_MIC_BUFFER_COUNT + 1));
mOutput10msBuffer.setCapacity((int)Format().sizeFromTime(AUDIO_SPK_BUFFER_LENGTH));
mOutputNativeData.setCapacity((int)Format().sizeFromTime(AUDIO_SPK_BUFFER_LENGTH * AUDIO_SPK_BUFFER_COUNT * 24));
mInputBuffer.setCapacity(AUDIO_MIC_BUFFER_SIZE * (AUDIO_MIC_BUFFER_COUNT + 1));
mOutputBuffer.setCapacity(AUDIO_SPK_BUFFER_SIZE * (AUDIO_SPK_BUFFER_COUNT + 1));
mInputResampingData.setCapacity(AUDIO_MIC_BUFFER_SIZE * (AUDIO_MIC_BUFFER_COUNT + 1));
mOutput10msBuffer.setCapacity((int)Format().sizeFromTime(AUDIO_SPK_BUFFER_LENGTH));
mOutputNativeData.setCapacity((int)Format().sizeFromTime(AUDIO_SPK_BUFFER_LENGTH * AUDIO_SPK_BUFFER_COUNT * 24));
}
DevicePair::~DevicePair()
{
if (mInput)
{
if (mInput->connection() == this)
mInput->setConnection(nullptr);
mInput.reset();
}
if (mInput)
{
if (mInput->connection() == this)
mInput->setConnection(NULL);
mInput.reset();
}
if (mOutput)
{
if (mOutput->connection() == this)
mOutput->setConnection(nullptr);
mOutput.reset();
}
if (mOutput)
{
if (mOutput->connection() == this)
mOutput->setConnection(NULL);
mOutput.reset();
}
}
DevicePair& DevicePair::setAec(bool aec)
{
mAec = aec;
return *this;
}
bool DevicePair::aec()
{
return mAec;
}
DevicePair& DevicePair::setAgc(bool agc)
{
mAgc = agc;
return *this;
}
bool DevicePair::agc()
{
return mAgc;
}
VariantMap* DevicePair::config()
{
return mConfig;
return mConfig;
}
DevicePair& DevicePair::setConfig(VariantMap* config)
void DevicePair::setConfig(VariantMap* config)
{
mConfig = config;
return *this;
mConfig = config;
}
PInputDevice DevicePair::input()
{
return mInput;
return mInput;
}
DevicePair& DevicePair::setInput(PInputDevice input)
void DevicePair::setInput(PInputDevice input)
{
if (mInput == input)
return *this;
if (mInput == input)
return;
mInput = input;
mInput->setConnection(this);
if (mDelegate)
mDelegate->deviceChanged(this);
return *this;
mInput = input;
mInput->setConnection(this);
if (mDelegate)
mDelegate->deviceChanged(this);
}
POutputDevice DevicePair::output()
{
return mOutput;
return mOutput;
}
DevicePair& DevicePair::setOutput(POutputDevice output)
void DevicePair::setOutput(POutputDevice output)
{
if (output == mOutput)
return *this;
mOutput = output;
mOutput->setConnection(this);
if (mDelegate)
mDelegate->deviceChanged(this);
return *this;
if (output == mOutput)
return;
mOutput = output;
mOutput->setConnection(this);
if (mDelegate)
mDelegate->deviceChanged(this);
}
bool DevicePair::start()
{
bool result = false;
if (mInput)
result = mInput->open();
if (mOutput && result)
result &= mOutput->open();
return result;
bool result = false;
if (mInput)
result = mInput->open();
if (mOutput && result)
result &= mOutput->open();
return result;
}
void DevicePair::stop()
{
if (mInput)
mInput->close();
if (mOutput)
mOutput->close();
if (mInput)
mInput->close();
if (mOutput)
mOutput->close();
}
DevicePair& DevicePair::setDelegate(Delegate* dc)
void DevicePair::setDelegate(Delegate* dc)
{
mDelegate = dc;
return *this;
mDelegate = dc;
}
DevicePair::Delegate* DevicePair::delegate()
{
return mDelegate;
}
DevicePair& DevicePair::setMonitoring(DataConnection* monitoring)
{
mMonitoring = monitoring;
return *this;
}
DataConnection* DevicePair::monitoring()
{
return mMonitoring;
return mDelegate;
}
Player& DevicePair::player()
{
return mPlayer;
return mPlayer;
}
void DevicePair::onMicData(const Format& f, const void* buffer, int length)
{
#ifdef DUMP_NATIVEINPUT
if (!mNativeInputDump)
{
mNativeInputDump = std::make_shared<WavFileWriter>();
mNativeInputDump->open("nativeinput.wav", f.mRate, f.mChannels);
}
if (mNativeInputDump)
mNativeInputDump->write(buffer, length);
if (!mNativeInputDump)
{
mNativeInputDump = std::make_shared<WavFileWriter>();
mNativeInputDump->open("nativeinput.wav", f.mRate, f.mChannels);
}
if (mNativeInputDump)
mNativeInputDump->write(buffer, length);
#endif
// send the data to internal queue - it can hold data which were not processed by resampler in last call
mInputResampingData.add(buffer, length);
// send the data to internal queue - it can hold data which were not processed by resampler in last call
mInputResampingData.add(buffer, length);
// split processing by blocks
int blocks = mInputResampingData.filled() / (int)f.sizeFromTime(AUDIO_MIC_BUFFER_LENGTH);
// split processing by blocks
int blocks = mInputResampingData.filled() / (int)f.sizeFromTime(AUDIO_MIC_BUFFER_LENGTH);
for (int blockIndex = 0; blockIndex < blocks; blockIndex++)
{
size_t wasProcessed = 0;
for (int blockIndex = 0; blockIndex < blocks; blockIndex++)
{
size_t wasProduced = mMicResampler.resample(f.mRate, // Source rate
mInputResampingData.data(), // Source data
(int)f.sizeFromTime(AUDIO_MIC_BUFFER_LENGTH), // Source size
wasProcessed,
AUDIO_SAMPLERATE, // Dest rate
mInputBuffer.mutableData() + mInputBuffer.filled(),
mInputBuffer.capacity() - mInputBuffer.filled());
size_t wasProcessed = 0;
mInputBuffer.setFilled(mInputBuffer.filled() + wasProduced);
mInputResampingData.erase((int)f.sizeFromTime(AUDIO_MIC_BUFFER_LENGTH));
processMicData(Format(), mInputBuffer.mutableData(), (int)Format().sizeFromTime(AUDIO_MIC_BUFFER_LENGTH));
size_t wasProduced = mMicResampler.resample(f.mRate, // Source rate
mInputResampingData.data(), // Source data
(int)f.sizeFromTime(AUDIO_MIC_BUFFER_LENGTH), // Source size
wasProcessed,
AUDIO_SAMPLERATE, // Dest rate
mInputBuffer.mutableData() + mInputBuffer.filled(),
mInputBuffer.capacity() - mInputBuffer.filled());
mInputBuffer.setFilled(mInputBuffer.filled() + wasProduced);
mInputResampingData.erase((int)f.sizeFromTime(AUDIO_MIC_BUFFER_LENGTH));
processMicData(Format(), mInputBuffer.mutableData(), (int)Format().sizeFromTime(AUDIO_MIC_BUFFER_LENGTH));
mInputBuffer.erase((int)Format().sizeFromTime(AUDIO_MIC_BUFFER_LENGTH));
}
mInputBuffer.erase((int)Format().sizeFromTime(AUDIO_MIC_BUFFER_LENGTH));
}
}
void DevicePair::onSpkData(const Format& f, void* buffer, int length)
{
// ICELogMedia(<< "Audio::DevicePair::onSpkData() begin");
//ICELogMedia(<< "Audio::DevicePair::onSpkData() begin");
#ifdef DUMP_NATIVEOUTPUT
if (!mNativeOutputDump)
{
mNativeOutputDump = std::make_shared<WavFileWriter>();
mNativeOutputDump->open("nativeoutput.wav", f.mRate, f.mChannels);
}
if (!mNativeOutputDump)
{
mNativeOutputDump = std::make_shared<WavFileWriter>();
mNativeOutputDump->open("nativeoutput.wav", f.mRate, f.mChannels);
}
#endif
#ifdef CONSOLE_LOGGING
printf("Speaker requests %d\n", length);
printf("Speaker requests %d\n", length);
#endif
Format nativeFormat = mOutput->getFormat();
// See how much bytes are needed yet - mOutputNativeData can contain some data already
int required = length - mOutputNativeData.filled();
if (required > 0)
Format nativeFormat = mOutput->getFormat();
// See how much bytes are needed yet - mOutputNativeData can contain some data already
int required = length - mOutputNativeData.filled();
if (required > 0)
{
// Find how much blocks must be received from RTP/decoder side
int nativeBufferSize = (int)nativeFormat.sizeFromTime(AUDIO_SPK_BUFFER_LENGTH);
int blocks = required / nativeBufferSize;
if (required % nativeBufferSize)
blocks++;
// Now request data from terminal or whetever delegate is
for (int blockIndex = 0; blockIndex < blocks; blockIndex++)
{
// Find how much blocks must be received from RTP/decoder side
int nativeBufferSize = (int)nativeFormat.sizeFromTime(AUDIO_SPK_BUFFER_LENGTH);
int blocks = required / nativeBufferSize;
if (required % nativeBufferSize)
blocks++;
memset(mOutput10msBuffer.mutableData(), 0, (size_t)mOutput10msBuffer.capacity());
// Now request data from terminal or whetever delegate is
for (int blockIndex = 0; blockIndex < blocks; blockIndex++)
{
memset(mOutput10msBuffer.mutableData(), 0, (size_t)mOutput10msBuffer.capacity());
if (mDelegate)
mDelegate->onSpkData(Format(), mOutput10msBuffer.mutableData(), mOutput10msBuffer.capacity());
// Ask audio data on main AUDIO_SAMPLERATE frequency
if (mDelegate)
mDelegate->onSpkData(Format(), mOutput10msBuffer.mutableData(), mOutput10msBuffer.capacity());
// Replace received data with custom file or data playing
mPlayer.onSpkData(Format(), mOutput10msBuffer.mutableData(), mOutput10msBuffer.capacity());
// Replace received data with custom file or data playing
mPlayer.onSpkData(Format(), mOutput10msBuffer.mutableData(), mOutput10msBuffer.capacity());
// Save it to process with AEC
if (mAec)
mAecSpkBuffer.add(mOutput10msBuffer.data(), mOutput10msBuffer.capacity());
// Save it to process with AEC
if (mAec)
mAecSpkBuffer.add(mOutput10msBuffer.data(), mOutput10msBuffer.capacity());
// Resample these 10 milliseconds it to native format
size_t wasProcessed = 0;
size_t wasProduced = mSpkResampler.resample(Format().mRate, mOutput10msBuffer.data(),
mOutput10msBuffer.capacity(), wasProcessed, f.mRate,
mOutputNativeData.mutableData() + mOutputNativeData.filled(),
mOutputNativeData.capacity() - mOutputNativeData.filled());
mOutputNativeData.setFilled(mOutputNativeData.filled() + wasProduced);
// Resample these 10 milliseconds it to native format
size_t wasProcessed = 0;
size_t wasProduced = mSpkResampler.resample(nativeFormat.mRate, mOutput10msBuffer.data(), mOutput10msBuffer.capacity(), wasProcessed, f.mRate,
mOutputNativeData.mutableData() + mOutputNativeData.filled(), mOutputNativeData.capacity() - mOutputNativeData.filled());
mOutputNativeData.setFilled(mOutputNativeData.filled() + wasProduced);
#ifdef CONSOLE_LOGGING
printf("Resampled %d to %d\n", wasProcessed, wasProduced);
printf("Resampled %d to %d\n", wasProcessed, wasProduced);
#endif
}
}
}
// assert(mOutputNativeData.filled() >= length);
// assert(mOutputNativeData.filled() >= length);
#ifdef DUMP_NATIVEOUTPUT
if (mNativeOutputDump)
mNativeOutputDump->write(mOutputNativeData.data(), length);
if (mNativeOutputDump)
mNativeOutputDump->write(mOutputNativeData.data(), length);
#endif
mOutputNativeData.read(buffer, length);
mOutputNativeData.read(buffer, length);
// Send data to monitoring if needed
if (mMonitoring)
mMonitoring->onSpkData(f, buffer, length);
#define AEC_FRAME_SIZE (AUDIO_CHANNELS * (AUDIO_SAMPLERATE / 1000) * AEC_FRAME_TIME * sizeof(short))
#define AEC_FRAME_SIZE (AUDIO_CHANNELS * (AUDIO_SAMPLERATE / 1000) * AEC_FRAME_TIME * sizeof(short))
// AEC filter wants frames.
if (mAec)
{
int nrOfFrames = mAecSpkBuffer.filled() / AEC_FRAME_SIZE;
for (int frameIndex = 0; frameIndex < nrOfFrames; frameIndex++)
mAecFilter.toSpeaker(mAecSpkBuffer.mutableData() + AEC_FRAME_SIZE * frameIndex);
mAecSpkBuffer.erase(nrOfFrames * AEC_FRAME_SIZE);
}
// AEC filter wants frames.
if (mAec)
{
int nrOfFrames = mAecSpkBuffer.filled() / AEC_FRAME_SIZE;
for (int frameIndex=0; frameIndex < nrOfFrames; frameIndex++)
mAecFilter.toSpeaker(mAecSpkBuffer.mutableData() + AEC_FRAME_SIZE * frameIndex);
mAecSpkBuffer.erase(nrOfFrames * AEC_FRAME_SIZE);
}
//ICELogMedia(<< "Audio::DevicePair::onSpkData() end")
}
void DevicePair::processMicData(const Format& f, void* buffer, int length)
{
if (mAgc)
mAgcFilter.process(buffer, length);
if (mAgc)
mAgcFilter.process(buffer, length);
if (mAec)
mAecFilter.fromMic(buffer);
if (mAec)
mAecFilter.fromMic(buffer);
if (mDelegate)
mDelegate->onMicData(f, buffer, length);
if (mDelegate)
mDelegate->onMicData(f, buffer, length);
}
src/engine/audio/Audio_DevicePair.h
+36 -40
View File
@@ -11,62 +11,58 @@
#include "Audio_Resampler.h"
#include "Audio_DataWindow.h"
// #define DUMP_NATIVEOUTPUT
// #define DUMP_NATIVEINPUT
//#define DUMP_NATIVEOUTPUT
//#define DUMP_NATIVEINPUT
namespace Audio
{
class DevicePair : protected DataConnection
{
public:
class Delegate : public DataConnection
class DevicePair: protected DataConnection
{
public:
class Delegate: public DataConnection
{
public:
virtual void deviceChanged(DevicePair* dpair) = 0;
virtual void deviceChanged(DevicePair* dpair) = 0;
};
DevicePair();
DevicePair(bool aec = true, bool agc = true);
virtual ~DevicePair();
DevicePair& setAec(bool aec);
bool aec();
DevicePair& setAgc(bool agc);
bool agc();
void setAec(bool aec);
bool aec();
void setAgc(bool agc);
bool agc();
VariantMap* config();
DevicePair& setConfig(VariantMap* config);
VariantMap* config();
void setConfig(VariantMap* config);
PInputDevice input();
DevicePair& setInput(PInputDevice input);
PInputDevice input();
void setInput(PInputDevice input);
POutputDevice output();
DevicePair& setOutput(POutputDevice output);
POutputDevice output();
void setOutput(POutputDevice output);
bool start();
void stop();
bool start();
void stop();
DevicePair& setDelegate(Delegate* dc);
Delegate* delegate();
void setDelegate(Delegate* dc);
Delegate* delegate();
DevicePair& setMonitoring(DataConnection* monitoring);
DataConnection* monitoring();
Player& player();
Player& player();
protected:
VariantMap* mConfig;
PInputDevice mInput;
POutputDevice mOutput;
Delegate* mDelegate;
bool mAec;
bool mAgc;
AgcFilter mAgcFilter;
AecFilter mAecFilter;
Player mPlayer;
protected:
VariantMap* mConfig;
PInputDevice mInput;
POutputDevice mOutput;
Delegate* mDelegate;
bool mAec;
bool mAgc;
AgcFilter mAgcFilter;
AecFilter mAecFilter;
Player mPlayer;
UniversalResampler mMicResampler, mSpkResampler;
DataWindow mInputBuffer, mOutputBuffer, mAecSpkBuffer, mInputResampingData, mOutputNativeData, mOutput10msBuffer;
DataConnection* mMonitoring;
#ifdef DUMP_NATIVEOUTPUT
std::shared_ptr<WavFileWriter> mNativeOutputDump;
@@ -77,9 +73,9 @@ protected:
void onMicData(const Format& f, const void* buffer, int length);
void onSpkData(const Format& f, void* buffer, int length);
void processMicData(const Format& f, void* buffer, int length);
};
};
typedef std::shared_ptr<DevicePair> PDevicePair;
} // namespace Audio
typedef std::shared_ptr<DevicePair> PDevicePair;
}
#endif
src/engine/audio/Audio_DirectSound.cpp
+155 -138
View File
@@ -19,10 +19,10 @@
#define DRVM_MAPPER_CONSOLEVOICECOM_GET (0x2000 + 23)
#define DRVM_MAPPER_PREFERRED_GET (0x2000 + 21)
#define DRV_QUERYFUNCTIONINSTANCEID (DRV_RESERVED + 17)
#define DRV_QUERYFUNCTIONINSTANCEID (DRV_RESERVED + 17)
#define DRV_QUERYFUNCTIONINSTANCEIDSIZE (DRV_RESERVED + 18)
#define LOG_SUBSYSTEM "audio"
#define LOG_SUBSYSTEM "DirectSound"
using namespace Audio;
@@ -39,29 +39,32 @@ public:
{
HINSTANCE mInstance;
HRESULT(WINAPI* DirectSoundCreate8)(LPGUID, LPDIRECTSOUND8*, LPUNKNOWN);
HRESULT(WINAPI* DirectSoundEnumerateW)(LPDSENUMCALLBACKW, LPVOID);
HRESULT(WINAPI* DirectSoundEnumerateA)(LPDSENUMCALLBACKA, LPVOID);
HRESULT (WINAPI *DirectSoundCreate8)(LPGUID, LPDIRECTSOUND8 *, LPUNKNOWN);
HRESULT (WINAPI *DirectSoundEnumerateW)(LPDSENUMCALLBACKW, LPVOID);
HRESULT (WINAPI *DirectSoundEnumerateA)(LPDSENUMCALLBACKA, LPVOID);
HRESULT(WINAPI* DirectSoundCaptureCreate8)(LPGUID, LPDIRECTSOUNDCAPTURE8*, LPUNKNOWN);
HRESULT(WINAPI* DirectSoundCaptureEnumerateW)(LPDSENUMCALLBACKW, LPVOID);
HRESULT(WINAPI* DirectSoundCaptureEnumerateA)(LPDSENUMCALLBACKA, LPVOID);
HRESULT(WINAPI* GetDeviceID)(LPCGUID src, LPGUID dst);
HRESULT (WINAPI *DirectSoundCaptureCreate8)(LPGUID, LPDIRECTSOUNDCAPTURE8* , LPUNKNOWN);
HRESULT (WINAPI *DirectSoundCaptureEnumerateW)(LPDSENUMCALLBACKW, LPVOID);
HRESULT (WINAPI *DirectSoundCaptureEnumerateA)(LPDSENUMCALLBACKA, LPVOID);
HRESULT (WINAPI *GetDeviceID)(LPCGUID src, LPGUID dst);
} mRoutines;
protected:
LPDIRECTSOUND mDirectSound;
Mutex mGuard;
Mutex mGuard;
unsigned int mRefCount;
};
DSoundInit gDSoundInit;
DSoundInit::DSoundInit() : mRefCount(0) {}
DSoundInit::DSoundInit()
:mRefCount(0)
{
}
DSoundInit::~DSoundInit()
{
// Unload();
//Unload();
}
void DSoundInit::load()
@@ -74,21 +77,16 @@ void DSoundInit::load()
hr = ::CoInitialize(NULL);
// load the DirectSound DLL
//load the DirectSound DLL
mRoutines.mInstance = ::LoadLibraryW(L"dsound.dll");
if (!mRoutines.mInstance)
throw std::logic_error("Cannot load dsound.dll");
mRoutines.DirectSoundCaptureCreate8 =
(HRESULT(WINAPI*)(LPGUID, LPDIRECTSOUNDCAPTURE8*, LPUNKNOWN))::GetProcAddress(mRoutines.mInstance,
"DirectSoundCaptureCreate8");
mRoutines.DirectSoundCaptureEnumerateW = (HRESULT(WINAPI*)(LPDSENUMCALLBACKW, LPVOID))::GetProcAddress(
mRoutines.mInstance, "DirectSoundCaptureEnumerateW");
mRoutines.DirectSoundCreate8 = (HRESULT(WINAPI*)(LPGUID, LPDIRECTSOUND8*, LPUNKNOWN))::GetProcAddress(
mRoutines.mInstance, "DirectSoundCreate8");
mRoutines.DirectSoundEnumerateW =
(HRESULT(WINAPI*)(LPDSENUMCALLBACKW, LPVOID))::GetProcAddress(mRoutines.mInstance, "DirectSoundEnumerateW");
mRoutines.GetDeviceID = (HRESULT(WINAPI*)(LPCGUID, LPGUID))GetProcAddress(mRoutines.mInstance, "GetDeviceID");
mRoutines.DirectSoundCaptureCreate8 = (HRESULT (WINAPI *)(LPGUID, LPDIRECTSOUNDCAPTURE8 *, LPUNKNOWN))::GetProcAddress(mRoutines.mInstance, "DirectSoundCaptureCreate8");
mRoutines.DirectSoundCaptureEnumerateW = (HRESULT (WINAPI *)(LPDSENUMCALLBACKW, LPVOID))::GetProcAddress(mRoutines.mInstance, "DirectSoundCaptureEnumerateW");
mRoutines.DirectSoundCreate8 = (HRESULT (WINAPI *)(LPGUID, LPDIRECTSOUND8 *, LPUNKNOWN))::GetProcAddress(mRoutines.mInstance, "DirectSoundCreate8");
mRoutines.DirectSoundEnumerateW = (HRESULT (WINAPI *)(LPDSENUMCALLBACKW, LPVOID))::GetProcAddress(mRoutines.mInstance, "DirectSoundEnumerateW");
mRoutines.GetDeviceID = (HRESULT (WINAPI*) (LPCGUID, LPGUID)) GetProcAddress(mRoutines.mInstance, "GetDeviceID");
}
}
@@ -108,7 +106,10 @@ void DSoundInit::unload()
}
// --------------- VistaEnumerator ---------------------
VistaEnumerator::VistaEnumerator() : mCollection(NULL), mDefaultDevice(NULL), mEnumerator(NULL), mDirection(eCapture) {}
VistaEnumerator::VistaEnumerator()
:mCollection(NULL), mDefaultDevice(NULL), mEnumerator(NULL), mDirection(eCapture)
{
}
VistaEnumerator::~VistaEnumerator()
{
@@ -118,12 +119,14 @@ VistaEnumerator::~VistaEnumerator()
void VistaEnumerator::open(int direction)
{
const CLSID CLSID_MMDeviceEnumerator = __uuidof(MMDeviceEnumerator);
const IID IID_IMMDeviceEnumerator = __uuidof(IMMDeviceEnumerator);
const IID IID_IMMDeviceEnumerator = __uuidof(IMMDeviceEnumerator);
mDirection = (direction == myMicrophone) ? eCapture : eRender;
HRESULT hr =
CoCreateInstance(CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL, IID_IMMDeviceEnumerator, (void**)&mEnumerator);
HRESULT hr = CoCreateInstance(
CLSID_MMDeviceEnumerator, NULL,
CLSCTX_ALL, IID_IMMDeviceEnumerator,
(void**)&mEnumerator);
if (!mEnumerator)
return;
@@ -149,7 +152,7 @@ void VistaEnumerator::close()
if (mDefaultDevice)
{
// mDefaultDevice->Release();
//mDefaultDevice->Release();
mDefaultDevice = NULL;
}
@@ -159,7 +162,7 @@ void VistaEnumerator::close()
mEnumerator = NULL;
}
}
catch (...)
catch(...)
{
}
}
@@ -172,9 +175,9 @@ IMMDevice* VistaEnumerator::mapIndexToInterface(int index)
if (index == -1)
return mDefaultDevice;
size_t idSize = 0;
MMRESULT mmres = 0;
WCHAR* id = NULL;
size_t idSize = 0;
MMRESULT mmres = 0;
WCHAR* id = NULL;
if (mDirection == eCapture)
{
mmres = waveInMessage((HWAVEIN)index, DRV_QUERYFUNCTIONINSTANCEIDSIZE, (DWORD_PTR)&idSize, NULL);
@@ -182,7 +185,7 @@ IMMDevice* VistaEnumerator::mapIndexToInterface(int index)
if (mmres != MMSYSERR_NOERROR)
return NULL;
id = (WCHAR*)_alloca(idSize * sizeof(WCHAR));
id = (WCHAR*)_alloca(idSize*sizeof(WCHAR));
mmres = waveInMessage((HWAVEIN)index, DRV_QUERYFUNCTIONINSTANCEID, (DWORD_PTR)id, idSize);
}
else
@@ -192,7 +195,7 @@ IMMDevice* VistaEnumerator::mapIndexToInterface(int index)
if (mmres != MMSYSERR_NOERROR)
return NULL;
id = (WCHAR*)_alloca(idSize * sizeof(WCHAR));
id = (WCHAR*)_alloca(idSize*sizeof(WCHAR));
mmres = waveOutMessage((HWAVEOUT)index, DRV_QUERYFUNCTIONINSTANCEID, (DWORD_PTR)id, idSize);
}
@@ -210,7 +213,7 @@ void VistaEnumerator::enumerate()
mNameList.clear();
int res = (int)count();
for (int i = 0; i < res; i++)
for (int i=0; i<res; i++)
{
IMMDevice* dev = mapIndexToInterface(i);
if (dev)
@@ -255,23 +258,26 @@ int VistaEnumerator::indexOfDefaultDevice()
if (mDirection == mySpeaker)
{
if (waveOutMessage((HWAVEOUT)WAVE_MAPPER, DRVM_MAPPER_CONSOLEVOICECOM_GET, (DWORD_PTR)&devID,
(DWORD_PTR)&status) != MMSYSERR_NOERROR)
if (waveOutMessage((HWAVEOUT)WAVE_MAPPER, DRVM_MAPPER_CONSOLEVOICECOM_GET, (DWORD_PTR)&devID, (DWORD_PTR)&status) != MMSYSERR_NOERROR)
waveOutMessage((HWAVEOUT)WAVE_MAPPER, DRVM_MAPPER_PREFERRED_GET, (DWORD_PTR)&devID, (DWORD_PTR)&status);
}
else
{
if (waveInMessage((HWAVEIN)WAVE_MAPPER, DRVM_MAPPER_CONSOLEVOICECOM_GET, (DWORD_PTR)&devID,
(DWORD_PTR)&status) != MMSYSERR_NOERROR)
if (waveInMessage((HWAVEIN)WAVE_MAPPER, DRVM_MAPPER_CONSOLEVOICECOM_GET, (DWORD_PTR)&devID, (DWORD_PTR)&status) != MMSYSERR_NOERROR)
waveInMessage((HWAVEIN)WAVE_MAPPER, DRVM_MAPPER_PREFERRED_GET, (DWORD_PTR)&devID, (DWORD_PTR)&status);
}
return devID;
}
// -------------- XpEnumerator ---------------
XpEnumerator::XpEnumerator() : mDirection(-1) {}
XpEnumerator::XpEnumerator()
:mDirection(-1)
{
}
XpEnumerator::~XpEnumerator() {}
XpEnumerator::~XpEnumerator()
{
}
void XpEnumerator::open(int direction)
{
@@ -279,7 +285,7 @@ void XpEnumerator::open(int direction)
if (direction == myMicrophone)
{
int count = waveInGetNumDevs();
for (int i = 0; i < count; i++)
for (int i=0; i<count; i++)
{
WAVEINCAPSW caps;
if (waveInGetDevCapsW(i, &caps, sizeof caps) == MMSYSERR_NOERROR)
@@ -291,7 +297,7 @@ void XpEnumerator::open(int direction)
else
{
int count = waveOutGetNumDevs();
for (int i = 0; i < count; i++)
for (int i=0; i<count; i++)
{
WAVEOUTCAPSW caps;
if (waveOutGetDevCapsW(i, &caps, sizeof caps) == MMSYSERR_NOERROR)
@@ -302,9 +308,11 @@ void XpEnumerator::open(int direction)
}
}
void XpEnumerator::close() {}
void XpEnumerator::close()
{
}
int XpEnumerator::count()
int XpEnumerator::count()
{
return mNameList.size();
}
@@ -325,14 +333,12 @@ int XpEnumerator::indexOfDefaultDevice()
if (mDirection == mySpeaker)
{
if (waveOutMessage((HWAVEOUT)WAVE_MAPPER, DRVM_MAPPER_CONSOLEVOICECOM_GET, (DWORD_PTR)&devID,
(DWORD_PTR)&status) != MMSYSERR_NOERROR)
if (waveOutMessage((HWAVEOUT)WAVE_MAPPER, DRVM_MAPPER_CONSOLEVOICECOM_GET, (DWORD_PTR)&devID, (DWORD_PTR)&status) != MMSYSERR_NOERROR)
waveOutMessage((HWAVEOUT)WAVE_MAPPER, DRVM_MAPPER_PREFERRED_GET, (DWORD_PTR)&devID, (DWORD_PTR)&status);
}
else
{
if (waveInMessage((HWAVEIN)WAVE_MAPPER, DRVM_MAPPER_CONSOLEVOICECOM_GET, (DWORD_PTR)&devID,
(DWORD_PTR)&status) != MMSYSERR_NOERROR)
if (waveInMessage((HWAVEIN)WAVE_MAPPER, DRVM_MAPPER_CONSOLEVOICECOM_GET, (DWORD_PTR)&devID, (DWORD_PTR)&status) != MMSYSERR_NOERROR)
waveInMessage((HWAVEIN)WAVE_MAPPER, DRVM_MAPPER_PREFERRED_GET, (DWORD_PTR)&devID, (DWORD_PTR)&status);
}
return devID;
@@ -340,12 +346,11 @@ int XpEnumerator::indexOfDefaultDevice()
// -------- DSoundInputDevice ---------------
DSoundInputDevice::DSoundInputDevice(GUID deviceId)
: mSimulate(false), mBufferIndex(0), mGUID(deviceId), mThreadHandle(0), mDenoiser(AUDIO_SAMPLERATE),
mEnableDenoiser(true), mNullAudio(AUDIO_MIC_BUFFER_LENGTH, AUDIO_MIC_BUFFER_COUNT)
#ifdef AUDIO_DUMPINPUT
,
mDump(AUDIO_SAMPLERATE)
#endif
:mSimulate(false), mBufferIndex(0), mGUID(deviceId), mThreadHandle(0), mDenoiser(AUDIO_SAMPLERATE), mEnableDenoiser(true),
mNullAudio(AUDIO_MIC_BUFFER_LENGTH, AUDIO_MIC_BUFFER_COUNT)
#ifdef AUDIO_DUMPINPUT
,mDump(AUDIO_SAMPLERATE)
#endif
{
gDSoundInit.load();
@@ -354,7 +359,7 @@ DSoundInputDevice::DSoundInputDevice(GUID deviceId)
mDevice = NULL;
mBuffer = NULL;
mShutdownSignal = ::CreateEvent(NULL, FALSE, FALSE, NULL);
for (unsigned i = 0; i < AUDIO_MIC_BUFFER_COUNT; i++)
for (unsigned i=0; i<AUDIO_MIC_BUFFER_COUNT; i++)
{
mEventArray[i].dwOffset = (i + 1) * AUDIO_MIC_BUFFER_SIZE - 1;
mEventSignals[i] = mEventArray[i].hEventNotify = ::CreateEvent(NULL, TRUE, FALSE, NULL);
@@ -366,7 +371,7 @@ DSoundInputDevice::~DSoundInputDevice()
{
close();
::CloseHandle(mShutdownSignal);
for (int i = 0; i < AUDIO_MIC_BUFFER_COUNT; i++)
for (int i=0; i<AUDIO_MIC_BUFFER_COUNT; i++)
::CloseHandle(mEventArray[i].hEventNotify);
gDSoundInit.unload();
@@ -384,12 +389,13 @@ bool DSoundInputDevice::isSimulate() const
void DSoundInputDevice::openDevice()
{
ICELogInfo(<< "Open DirectSound audio input.")::CoInitialize(NULL);
ICELogInfo(<< "Open DirectSound audio input.")
::CoInitialize(NULL);
Lock l(mGuard);
// Ensure if GUID is not null
if (IsEqualGUID(mGUID, GUID_NULL))
{
setSimulate(true);
setSimulate( true );
return;
}
@@ -398,28 +404,24 @@ void DSoundInputDevice::openDevice()
mDump.open(L"audioinput.wav");
#endif
mNextBuffer = 0;
mDevice = NULL;
IUnknown* unk = NULL;
mBuffer = NULL;
mNextBuffer = 0; mDevice = NULL; IUnknown* unk = NULL; mBuffer = NULL;
DSoundHelper::checkComResult(gDSoundInit.mRoutines.DirectSoundCaptureCreate8(&mGUID, &mDevice, NULL));
WAVEFORMATEX wfx;
memset(&wfx, 0, sizeof(wfx));
// wfx.cbSize = sizeof(wfx);
//wfx.cbSize = sizeof(wfx);
wfx.nChannels = AUDIO_CHANNELS;
wfx.nSamplesPerSec = AUDIO_SAMPLERATE;
wfx.wBitsPerSample = 16;
wfx.nBlockAlign = wfx.nChannels * wfx.wBitsPerSample / 8;
;
wfx.nBlockAlign = wfx.nChannels * wfx.wBitsPerSample / 8;;
wfx.nAvgBytesPerSec = AUDIO_SAMPLERATE * 2 * AUDIO_CHANNELS;
wfx.wFormatTag = WAVE_FORMAT_PCM;
DSCBUFFERDESC dsbd;
ZeroMemory(&dsbd, sizeof(dsbd));
dsbd.dwSize = sizeof(DSCBUFFERDESC);
dsbd.dwFlags = 0; // DSBCAPS_CTRLPOSITIONNOTIFY;
dsbd.dwFlags = 0;//DSBCAPS_CTRLPOSITIONNOTIFY;
dsbd.dwBufferBytes = AUDIO_MIC_BUFFER_COUNT * AUDIO_MIC_BUFFER_SIZE;
dsbd.lpwfxFormat = &wfx;
dsbd.dwFXCount = 0;
@@ -432,7 +434,7 @@ void DSoundInputDevice::openDevice()
DSoundHelper::checkComResult(mNotifications->SetNotificationPositions(AUDIO_MIC_BUFFER_COUNT, mEventArray));
DSoundHelper::checkComResult(mBuffer->Start(DSCBSTART_LOOPING));
dscb->Release();
setSimulate(false);
setSimulate( false );
}
bool DSoundInputDevice::open()
@@ -450,7 +452,7 @@ bool DSoundInputDevice::open()
void DSoundInputDevice::closeDevice()
{
ICELogInfo(<< "Close DirectSound audio input");
ICELogInfo(<<"Close DirectSound audio input");
Lock l(mGuard);
#ifdef AUDIO_DUMPINPUT
@@ -503,7 +505,7 @@ bool DSoundInputDevice::tryReadBuffer(void* buffer)
// Ensure device exists
if (!mDevice)
{
setSimulate(true);
setSimulate( true );
return false;
}
@@ -522,10 +524,9 @@ bool DSoundInputDevice::tryReadBuffer(void* buffer)
try
{
if (::WaitForSingleObject(mEventArray[mNextBuffer].hEventNotify,
AUDIO_MIC_BUFFER_COUNT * AUDIO_MIC_BUFFER_LENGTH * 4) != WAIT_OBJECT_0)
if (::WaitForSingleObject(mEventArray[mNextBuffer].hEventNotify, AUDIO_MIC_BUFFER_COUNT * AUDIO_MIC_BUFFER_LENGTH * 4) != WAIT_OBJECT_0)
{
setSimulate(true);
setSimulate( true );
return false;
}
@@ -533,7 +534,7 @@ bool DSoundInputDevice::tryReadBuffer(void* buffer)
if (::WaitForMultipleObjects(AUDIO_MIC_BUFFER_COUNT, mEventSignals, TRUE, 0) != WAIT_TIMEOUT)
{
// Possible overflow. Consider current buffer resulting. Reset ALL events.
for (int i = 0; i < AUDIO_MIC_BUFFER_COUNT; i++)
for (int i = 0; i<AUDIO_MIC_BUFFER_COUNT; i++)
ResetEvent(mEventArray[i].hEventNotify);
}
else
@@ -542,12 +543,11 @@ bool DSoundInputDevice::tryReadBuffer(void* buffer)
// Find the buffer start offset
mReadOffset = mNextBuffer * AUDIO_MIC_BUFFER_SIZE;
// increase the buffer's index
//increase the buffer's index
if (++mNextBuffer == AUDIO_MIC_BUFFER_COUNT)
mNextBuffer = 0;
LPVOID ptr1 = NULL, ptr2 = NULL;
DWORD len1 = 0, len2 = 0;
LPVOID ptr1 = NULL, ptr2 = NULL; DWORD len1 = 0, len2 = 0;
DSoundHelper::checkComResult(mBuffer->Lock(mReadOffset, AUDIO_MIC_BUFFER_SIZE, &ptr1, &len1, &ptr2, &len2, 0));
// Copy&Enqueue captured data to mQueue
@@ -574,9 +574,9 @@ bool DSoundInputDevice::tryReadBuffer(void* buffer)
return true;
}
catch (...)
catch(...)
{
setSimulate(true);
setSimulate( true );
}
return false;
}
@@ -585,8 +585,9 @@ void DSoundInputDevice::setSimulate(bool s)
{
if (!mSimulate && s)
mNullAudio.start();
else if (mSimulate && !s)
mNullAudio.stop();
else
if (mSimulate && !s)
mNullAudio.stop();
mSimulate = s;
}
@@ -598,7 +599,7 @@ Format DSoundInputDevice::getFormat()
int DSoundInputDevice::readBuffer(void* buffer)
{
// Lock lock(mGuard);
//Lock lock(mGuard);
if (mRefCount <= 0 || isSimulate())
return 0;
@@ -641,8 +642,10 @@ void DSoundInputDevice::threadProc(void* arg)
DSoundOutputDevice::DSoundOutputDevice(GUID deviceId)
: mDevice(NULL), mPrimaryBuffer(NULL), mBuffer(NULL), mWriteOffset(0), mPlayedSamples(0), mTotalPlayed(0), mTail(0),
mThreadHandle(0), mSimulate(false), mGUID(deviceId), mNullAudio(AUDIO_SPK_BUFFER_LENGTH, AUDIO_SPK_BUFFER_COUNT)
:mDevice(NULL), mPrimaryBuffer(NULL), mBuffer(NULL),
mWriteOffset(0), mPlayedSamples(0), mTotalPlayed(0), mTail(0),
mThreadHandle(0), mSimulate(false), mGUID(deviceId),
mNullAudio(AUDIO_SPK_BUFFER_LENGTH, AUDIO_SPK_BUFFER_COUNT)
{
gDSoundInit.load();
mShutdownSignal = ::CreateEvent(NULL, FALSE, FALSE, NULL);
@@ -697,7 +700,7 @@ void DSoundOutputDevice::openDevice()
ICELogInfo(<< "Open DirectSound audio output");
if (IsEqualGUID(mGUID, GUID_NULL))
{
setSimulate(true);
setSimulate( true );
return;
}
@@ -726,10 +729,10 @@ void DSoundOutputDevice::openDevice()
dsbd.dwSize = sizeof(DSBUFFERDESC);
dsbd.dwFlags = DSBCAPS_PRIMARYBUFFER;
dsbd.dwBufferBytes = 0;
dsbd.lpwfxFormat = NULL; //&wfx;
dsbd.lpwfxFormat = NULL;//&wfx;
dsbd.guid3DAlgorithm = DS3DALG_DEFAULT;
DSoundHelper::checkComResult(mDevice->CreateSoundBuffer(&dsbd, &mPrimaryBuffer, NULL));
DSoundHelper::checkComResult(mDevice->CreateSoundBuffer(&dsbd, &mPrimaryBuffer, NULL ));
DSBCAPS caps;
caps.dwSize = sizeof(caps);
caps.dwFlags = 0;
@@ -748,16 +751,14 @@ void DSoundOutputDevice::openDevice()
DSoundHelper::checkComResult(mDevice->CreateSoundBuffer(&dsbd, &mBuffer, NULL));
// Fill the buffer with silence
LPVOID ptr1 = NULL, ptr2 = NULL;
DWORD len1 = 0, len2 = 0;
DSoundHelper::checkComResult(
mBuffer->Lock(0, AUDIO_SPK_BUFFER_SIZE * AUDIO_SPK_BUFFER_COUNT, &ptr1, &len1, &ptr2, &len2, 0));
LPVOID ptr1 = NULL, ptr2 = NULL; DWORD len1 = 0, len2 = 0;
DSoundHelper::checkComResult(mBuffer->Lock(0, AUDIO_SPK_BUFFER_SIZE * AUDIO_SPK_BUFFER_COUNT, &ptr1, &len1, &ptr2, &len2, 0));
if (len1 && ptr1)
memset(ptr1, 0, len1);
if (len2 && ptr2)
memset(ptr2, 0, len2);
DSoundHelper::checkComResult(mBuffer->Unlock(ptr1, len1, ptr2, len2));
DSoundHelper::checkComResult(mBuffer->Play(0, 0, DSBPLAY_LOOPING));
DSoundHelper::checkComResult(mBuffer->Play(0,0,DSBPLAY_LOOPING));
mBuffer->GetCurrentPosition(NULL, &mWriteCursor);
}
@@ -803,9 +804,8 @@ bool DSoundOutputDevice::getMediaFrame()
if (mConnection)
mConnection->onSpkData(getFormat(), mMediaFrame, sizeof mMediaFrame);
}
catch (...)
{
}
catch(...)
{}
return true;
}
@@ -833,8 +833,7 @@ bool DSoundOutputDevice::process()
offset %= mBufferSize;
// See what we can write
LPVOID ptr1 = NULL, ptr2 = NULL;
DWORD len1 = 0, len2 = 0;
LPVOID ptr1 = NULL, ptr2 = NULL; DWORD len1 = 0, len2 = 0;
DSoundHelper::checkComResult(mBuffer->Lock(offset, AUDIO_SPK_BUFFER_SIZE, &ptr1, &len1, &ptr2, &len2, 0));
assert(ptr2 == NULL);
@@ -859,10 +858,10 @@ void DSoundOutputDevice::threadProc(void* arg)
DSoundOutputDevice* impl = (DSoundOutputDevice*)arg;
impl->openDevice();
DWORD waitResult = 0;
HANDLE waitArray[2] = {impl->mBufferSignal, impl->mShutdownSignal};
DWORD waitResult = 0;
HANDLE waitArray[2] = {impl->mBufferSignal, impl->mShutdownSignal};
unsigned exitCount = 0;
bool exitSignal = false;
bool exitSignal = false;
while (true)
{
// Poll for shutdown signal
@@ -885,12 +884,12 @@ void DSoundOutputDevice::threadProc(void* arg)
impl->restoreBuffer();
impl->process();
}
catch (const Exception& e)
catch(const Exception& e)
{
ICELogError(<< "DirectSound output failed with code = " << e.code() << ", subcode = " << e.subcode());
impl->setSimulate(true);
}
catch (...)
catch(...)
{
ICELogError(<< "DirectSound output failed due to unexpected exception.");
impl->setSimulate(true);
@@ -926,61 +925,62 @@ bool DSoundOutputDevice::closing()
return false;
}
typedef WINUSERAPI HRESULT(WINAPI* LPFNDLLGETCLASSOBJECT)(const CLSID&, const IID&, void**);
typedef WINUSERAPI HRESULT (WINAPI *LPFNDLLGETCLASSOBJECT) (const CLSID &, const IID &, void **);
HRESULT DirectSoundPrivateCreate(OUT LPKSPROPERTYSET* ppKsPropertySet)
HRESULT DirectSoundPrivateCreate (OUT LPKSPROPERTYSET * ppKsPropertySet)
{
HMODULE hLibDsound = NULL;
LPFNDLLGETCLASSOBJECT pfnDllGetClassObject = NULL;
LPCLASSFACTORY pClassFactory = NULL;
LPKSPROPERTYSET pKsPropertySet = NULL;
HRESULT hr = DS_OK;
HMODULE hLibDsound = NULL;
LPFNDLLGETCLASSOBJECT pfnDllGetClassObject = NULL;
LPCLASSFACTORY pClassFactory = NULL;
LPKSPROPERTYSET pKsPropertySet = NULL;
HRESULT hr = DS_OK;
// Load dsound.dll
hLibDsound = LoadLibrary(TEXT("dsound.dll"));
if (!hLibDsound)
if(!hLibDsound)
{
hr = DSERR_GENERIC;
}
// Find DllGetClassObject
if (SUCCEEDED(hr))
if(SUCCEEDED(hr))
{
pfnDllGetClassObject = (LPFNDLLGETCLASSOBJECT)GetProcAddress(hLibDsound, "DllGetClassObject");
pfnDllGetClassObject =
(LPFNDLLGETCLASSOBJECT)GetProcAddress ( hLibDsound, "DllGetClassObject" );
if (!pfnDllGetClassObject)
if(!pfnDllGetClassObject)
{
hr = DSERR_GENERIC;
}
}
// Create a class factory object
if (SUCCEEDED(hr))
if(SUCCEEDED(hr))
{
hr = pfnDllGetClassObject(CLSID_DirectSoundPrivate, IID_IClassFactory, (LPVOID*)&pClassFactory);
hr = pfnDllGetClassObject (CLSID_DirectSoundPrivate, IID_IClassFactory, (LPVOID *)&pClassFactory );
}
// Create the DirectSoundPrivate object and query for an IKsPropertySet
// interface
if (SUCCEEDED(hr))
if(SUCCEEDED(hr))
{
hr = pClassFactory->CreateInstance(NULL, IID_IKsPropertySet, (LPVOID*)&pKsPropertySet);
hr = pClassFactory->CreateInstance ( NULL, IID_IKsPropertySet, (LPVOID *)&pKsPropertySet );
}
// Release the class factory
if (pClassFactory)
if(pClassFactory)
{
pClassFactory->Release();
}
// Handle final success or failure
if (SUCCEEDED(hr))
if(SUCCEEDED(hr))
{
*ppKsPropertySet = pKsPropertySet;
}
else if (pKsPropertySet)
else if(pKsPropertySet)
{
pKsPropertySet->Release();
}
@@ -990,43 +990,54 @@ HRESULT DirectSoundPrivateCreate(OUT LPKSPROPERTYSET* ppKsPropertySet
return hr;
}
BOOL GetInfoFromDSoundGUID(GUID i_sGUID, int& dwWaveID)
BOOL GetInfoFromDSoundGUID( GUID i_sGUID, int &dwWaveID)
{
LPKSPROPERTYSET pKsPropertySet = NULL;
HRESULT hr;
BOOL retval = FALSE;
LPKSPROPERTYSET pKsPropertySet = NULL;
HRESULT hr;
BOOL retval = FALSE;
PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_DATA psDirectSoundDeviceDescription = NULL;
DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_DATA sDirectSoundDeviceDescription;
DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_DATA sDirectSoundDeviceDescription;
memset(&sDirectSoundDeviceDescription, 0, sizeof(sDirectSoundDeviceDescription));
hr = DirectSoundPrivateCreate(&pKsPropertySet);
if (SUCCEEDED(hr))
memset(&sDirectSoundDeviceDescription,0,sizeof(sDirectSoundDeviceDescription));
hr = DirectSoundPrivateCreate( &pKsPropertySet );
if(SUCCEEDED(hr))
{
ULONG ulBytesReturned = 0;
sDirectSoundDeviceDescription.DeviceId = i_sGUID;
// On the first call the final size is unknown so pass the size of the struct in order to receive
// "Type" and "DataFlow" values, ulBytesReturned will be populated with bytes required for struct+strings.
hr = pKsPropertySet->Get(DSPROPSETID_DirectSoundDevice, DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION, NULL, 0,
&sDirectSoundDeviceDescription, sizeof(sDirectSoundDeviceDescription),
&ulBytesReturned);
hr = pKsPropertySet->Get(DSPROPSETID_DirectSoundDevice,
DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION,
NULL,
0,
&sDirectSoundDeviceDescription,
sizeof(sDirectSoundDeviceDescription),
&ulBytesReturned
);
if (ulBytesReturned)
{
// On the first call it notifies us of the required amount of memory in order to receive the strings.
// Allocate the required memory, the strings will be pointed to the memory space directly after the struct.
psDirectSoundDeviceDescription = (PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_DATA) new BYTE[ulBytesReturned];
psDirectSoundDeviceDescription = (PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_DATA)new BYTE[ulBytesReturned];
*psDirectSoundDeviceDescription = sDirectSoundDeviceDescription;
hr = pKsPropertySet->Get(DSPROPSETID_DirectSoundDevice, DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION, NULL, 0,
psDirectSoundDeviceDescription, ulBytesReturned, &ulBytesReturned);
hr = pKsPropertySet->Get(DSPROPSETID_DirectSoundDevice,
DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION,
NULL,
0,
psDirectSoundDeviceDescription,
ulBytesReturned,
&ulBytesReturned
);
dwWaveID = psDirectSoundDeviceDescription->WaveDeviceId;
dwWaveID = psDirectSoundDeviceDescription->WaveDeviceId;
/*Description = psDirectSoundDeviceDescription->Description;
Module = psDirectSoundDeviceDescription->Module;
Interface = psDirectSoundDeviceDescription->Interface;*/
delete[] psDirectSoundDeviceDescription;
delete [] psDirectSoundDeviceDescription;
retval = TRUE;
}
@@ -1038,14 +1049,20 @@ BOOL GetInfoFromDSoundGUID(GUID i_sGUID, int& dwWaveID)
struct EnumResult
{
int mDeviceId;
int mDeviceId;
GUID mGuid;
};
BOOL CALLBACK DSEnumCallback(LPGUID lpGuid, LPCTSTR lpcstrDescription, LPCTSTR lpcstrModule, LPVOID lpContext)
BOOL CALLBACK DSEnumCallback(
LPGUID lpGuid,
LPCTSTR lpcstrDescription,
LPCTSTR lpcstrModule,
LPVOID lpContext
)
{
if (lpGuid)
{
int devId = -1;
GetInfoFromDSoundGUID(*lpGuid, devId);
EnumResult* er = (EnumResult*)lpContext;
src/engine/audio/Audio_DirectSound.h
+77 -77
View File
@@ -1,4 +1,4 @@
/* Copyright(C) 2007-2025 VoIP objects (voipobjects.com)
/* Copyright(C) 2007-2017 VoIP objects (voipobjects.com)
* 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/. */
@@ -6,7 +6,7 @@
#ifndef __AUDIO_DSOUND_H
#define __AUDIO_DSOUND_H
#include "../engine_config.h"
#include "../config.h"
#include <winsock2.h>
#include <windows.h>
@@ -22,7 +22,7 @@
#include <EndpointVolume.h>
#include <MMDeviceAPI.h>
#if defined(_MSC_VER)
#include <Functiondiscoverykeys_devpkey.h>
# include <Functiondiscoverykeys_devpkey.h>
#endif
#include <vector>
#include <string>
@@ -31,48 +31,48 @@
namespace Audio
{
class VistaEnumerator : public Enumerator
class VistaEnumerator: public Enumerator
{
public:
VistaEnumerator();
~VistaEnumerator();
void open(int direction);
void close();
void open(int direction);
void close();
int count();
int count();
std::tstring nameAt(int index);
int idAt(int index);
int indexOfDefaultDevice();
int idAt(int index);
int indexOfDefaultDevice();
protected:
IMMDeviceCollection* mCollection;
IMMDevice* mDefaultDevice;
IMMDeviceEnumerator* mEnumerator;
EDataFlow mDirection;
std::vector<std::wstring> mNameList;
IMMDeviceCollection* mCollection;
IMMDevice* mDefaultDevice;
IMMDeviceEnumerator* mEnumerator;
EDataFlow mDirection;
std::vector<std::wstring> mNameList;
void enumerate();
IMMDevice* mapIndexToInterface(int index);
void enumerate();
IMMDevice* mapIndexToInterface(int index);
};
class XpEnumerator : public Enumerator
class XpEnumerator: public Enumerator
{
public:
XpEnumerator();
~XpEnumerator();
void open(int direction);
void close();
void open(int direction);
void close();
int count();
int count();
std::tstring nameAt(int index);
int idAt(int index);
int indexOfDefaultDevice();
int idAt(int index);
int indexOfDefaultDevice();
protected:
std::vector<std::wstring> mNameList;
int mDirection;
int mDirection;
};
class DSoundHelper
@@ -83,32 +83,32 @@ public:
};
#if !defined(_MSC_VER)
typedef struct IDirectSoundNotify8* LPDIRECTSOUNDNOTIFY8;
typedef struct IDirectSoundNotify8 *LPDIRECTSOUNDNOTIFY8;
#endif
class DSoundInputDevice : public InputDevice
class DSoundInputDevice: public InputDevice
{
public:
DSoundInputDevice(GUID deviceId);
~DSoundInputDevice();
void enableDenoiser(bool enable);
bool open();
void close();
void enableDenoiser(bool enable);
bool open();
void close();
bool isSimulate() const;
void setSimulate(bool s);
bool isSimulate() const;
void setSimulate(bool s);
int readBuffer(void* buffer);
int readBuffer(void* buffer);
Format getFormat();
protected:
Mutex mGuard; /// Mutex to protect this instance.
LPDIRECTSOUNDCAPTURE8 mDevice;
LPDIRECTSOUNDCAPTUREBUFFER8 mBuffer;
LPDIRECTSOUNDNOTIFY8 mNotifications;
DSBPOSITIONNOTIFY mEventArray[AUDIO_MIC_BUFFER_COUNT];
HANDLE mEventSignals[AUDIO_MIC_BUFFER_COUNT]; // Helper array to make WaitForMultipleObjects in loop
Mutex mGuard; /// Mutex to protect this instance.
LPDIRECTSOUNDCAPTURE8 mDevice;
LPDIRECTSOUNDCAPTUREBUFFER8 mBuffer;
LPDIRECTSOUNDNOTIFY8 mNotifications;
DSBPOSITIONNOTIFY mEventArray[AUDIO_MIC_BUFFER_COUNT];
HANDLE mEventSignals[AUDIO_MIC_BUFFER_COUNT]; // Helper array to make WaitForMultipleObjects in loop
int mBufferIndex;
int mNextBuffer;
@@ -116,7 +116,7 @@ protected:
HANDLE mThreadHandle;
HANDLE mShutdownSignal;
volatile bool mSimulate; /// Marks if simulate mode is active.
volatile bool mSimulate; /// Marks if simulate mode is active.
int mRefCount;
ByteBuffer mQueue;
unsigned mReadOffset;
@@ -129,59 +129,59 @@ protected:
WavFileWriter mDump;
#endif
bool tryReadBuffer(void* buffer);
void openDevice();
void closeDevice();
bool tryReadBuffer(void* buffer);
void openDevice();
void closeDevice();
static void threadProc(void* arg);
};
class DSoundOutputDevice : public OutputDevice
class DSoundOutputDevice: public OutputDevice
{
public:
DSoundOutputDevice(GUID deviceId);
~DSoundOutputDevice();
bool open();
void close();
bool open();
void close();
unsigned playedTime() const;
bool isSimulate() const;
void setSimulate(bool s);
bool closing();
Format getFormat();
unsigned playedTime() const;
bool isSimulate() const;
void setSimulate(bool s);
bool closing();
Format getFormat();
protected:
Mutex mGuard; /// Mutex to protect this instance
int mDeviceID;
LPDIRECTSOUND8 mDevice;
LPDIRECTSOUNDBUFFER mPrimaryBuffer;
LPDIRECTSOUNDBUFFER mBuffer;
GUID mGUID;
unsigned mWriteOffset;
unsigned mPlayedSamples;
unsigned mSentBytes;
DWORD mPlayCursor; // Measured in bytes
unsigned mBufferSize;
unsigned mTotalPlayed; // Measured in bytes
unsigned mTail; // Measured in bytes
HANDLE mShutdownSignal;
HANDLE mBufferSignal;
HANDLE mThreadHandle;
bool mSimulate;
StubTimer mNullAudio;
DWORD mWriteCursor;
char mMediaFrame[AUDIO_SPK_BUFFER_SIZE];
unsigned mRefCount;
Mutex mGuard; /// Mutex to protect this instance
int mDeviceID;
LPDIRECTSOUND8 mDevice;
LPDIRECTSOUNDBUFFER mPrimaryBuffer;
LPDIRECTSOUNDBUFFER mBuffer;
GUID mGUID;
unsigned mWriteOffset;
unsigned mPlayedSamples;
unsigned mSentBytes;
DWORD mPlayCursor; // Measured in bytes
unsigned mBufferSize;
unsigned mTotalPlayed; // Measured in bytes
unsigned mTail; // Measured in bytes
HANDLE mShutdownSignal;
HANDLE mBufferSignal;
HANDLE mThreadHandle;
bool mSimulate;
StubTimer mNullAudio;
DWORD mWriteCursor;
char mMediaFrame[AUDIO_SPK_BUFFER_SIZE];
unsigned mRefCount;
void openDevice();
void closeDevice();
void restoreBuffer();
bool process();
bool getMediaFrame();
void openDevice();
void closeDevice();
void restoreBuffer();
bool process();
bool getMediaFrame();
static void threadProc(void* arg);
static void threadProc(void* arg);
};
} // namespace Audio
}
#endif
src/engine/audio/Audio_Helper.cpp
+71 -67
View File
@@ -4,7 +4,7 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifdef TARGET_WIN
#include <WinSock2.h>
# include <WinSock2.h>
#endif
#include <assert.h>
@@ -17,92 +17,96 @@ using namespace Audio;
TimeSource::TimeSource(int quantTime, int nrOfQuants)
{
#ifdef TARGET_WIN
mCounter.QuadPart = 0;
mCounter.QuadPart = 0;
#endif
#if defined(TARGET_OSX) || defined(TARGET_IOS)
mach_timebase_info(&mTimebase);
mRatio = ((double)mTimebase.numer / (double)mTimebase.denom) / 1000000;
mach_timebase_info(&mTimebase);
mRatio = ((double)mTimebase.numer / (double)mTimebase.denom) / 1000000;
#endif
mQuantTime = quantTime;
mDepthTime = quantTime * nrOfQuants;
mTailTime = 0;
mQuantTime = quantTime;
mDepthTime = quantTime * nrOfQuants;
mTailTime = 0;
}
TimeSource::~TimeSource()
{
}
void TimeSource::start()
{
#ifdef TARGET_WIN
if (!QueryPerformanceFrequency(&mFreq))
throw Exception(ERR_QPC, GetLastError());
if (!QueryPerformanceCounter(&mCounter))
throw Exception(ERR_QPC, GetLastError());
if (!QueryPerformanceFrequency(&mFreq))
throw Exception(ERR_QPC, GetLastError());
if (!QueryPerformanceCounter(&mCounter))
throw Exception(ERR_QPC, GetLastError());
#endif
}
void TimeSource::stop() {}
void TimeSource::stop()
{
}
unsigned TimeSource::time()
{
#ifdef TARGET_WIN
LARGE_INTEGER c;
if (!QueryPerformanceCounter(&c))
throw Exception(ERR_QPC, GetLastError());
if (!QueryPerformanceCounter(&c))
throw Exception(ERR_QPC, GetLastError());
// find the f
double f = (double)mFreq.QuadPart / 1000.0;
//find the f
double f = (double)mFreq.QuadPart / 1000.0;
// find the difference
unsigned __int64 diff = c.QuadPart - mCounter.QuadPart;
//find the difference
unsigned __int64 diff = c.QuadPart - mCounter.QuadPart;
mCounter.QuadPart = c.QuadPart;
mCounter.QuadPart = c.QuadPart;
diff = (unsigned __int64)((double)diff / f + 0.5); // get ms
diff += mTailTime;
diff = (unsigned __int64)((double)diff / f + 0.5); //get ms
diff += mTailTime;
if (diff > mDepthTime)
{
mTailTime = 0;
return mDepthTime;
}
else
{
mTailTime = (unsigned)(diff % (unsigned __int64)mQuantTime);
unsigned int t = (unsigned)(diff / (unsigned __int64)mQuantTime);
return t * mQuantTime;
}
if (diff > mDepthTime)
{
mTailTime = 0;
return mDepthTime;
}
else
{
mTailTime = (unsigned )(diff % (unsigned __int64)mQuantTime);
unsigned int t = (unsigned )(diff / (unsigned __int64)mQuantTime);
return t * mQuantTime;
}
#endif
#if defined(TARGET_OSX) || defined(TARGET_IOS)
uint64_t t = mach_absolute_time();
uint64_t c = uint64_t((double)t * mRatio + 0.5);
uint64_t t = mach_absolute_time();
uint64_t c = uint64_t((double)t * mRatio + 0.5);
uint64_t diff = c - this->mTime + mTailTime;
mTime = c;
if (diff > mDepthTime)
{
mTailTime = 0;
return mDepthTime;
}
else
{
mTailTime = diff % mQuantTime;
uint64_t t = diff / mQuantTime;
return t * mQuantTime;
}
uint64_t diff = c - this->mTime + mTailTime;
mTime = c;
if (diff > mDepthTime)
{
mTailTime = 0;
return mDepthTime;
}
else
{
mTailTime = diff % mQuantTime;
uint64_t t = diff / mQuantTime;
return t * mQuantTime;
}
#endif
#if defined(TARGET_LINUX)
assert(0);
assert(0);
#endif
#if defined(TARGET_ANDROID)
assert(0);
assert(0);
#endif
return 0;
}
// --- StubTimer ---
StubTimer::StubTimer(int bufferTime, int bufferCount)
: mBufferTime(bufferTime), mBufferCount(bufferCount), mTimeSource(bufferTime, bufferCount), mActive(false),
mCurrentTime(0)
:mBufferTime(bufferTime), mBufferCount(bufferCount), mTimeSource(bufferTime, bufferCount), mActive(false)
{
#ifdef TARGET_WIN
mStubSignal = ::CreateEvent(NULL, FALSE, FALSE, NULL);
@@ -112,38 +116,38 @@ StubTimer::StubTimer(int bufferTime, int bufferCount)
StubTimer::~StubTimer()
{
#ifdef TARGET_WIN
::CloseHandle(mStubSignal);
::CloseHandle(mStubSignal);
#endif
}
void StubTimer::start()
{
mTimeSource.start();
mCurrentTime = mTimeSource.time();
mActive = true;
mTimeSource.start();
mCurrentTime = mTimeSource.time();
mActive = true;
}
void StubTimer::stop()
{
mTimeSource.stop();
mActive = false;
mTimeSource.stop();
mActive = false;
}
void StubTimer::waitForBuffer()
{
if (!mActive)
start();
if (!mActive)
start();
unsigned t = mTimeSource.time();
unsigned t = mTimeSource.time();
while (!t)
{
while (!t)
{
#ifdef TARGET_WIN
::WaitForSingleObject(mStubSignal, mBufferTime);
::WaitForSingleObject(mStubSignal, mBufferTime);
#endif
#if defined(TARGET_OSX) || defined(TARGET_IOS)
usleep(100);
usleep(100);
#endif
t = mTimeSource.time();
}
t = mTimeSource.time();
}
}
src/engine/audio/Audio_Helper.h
+32 -32
View File
@@ -10,15 +10,15 @@
#include <EndpointVolume.h>
#include <MMDeviceAPI.h>
#if defined(_MSC_VER)
#include <Functiondiscoverykeys_devpkey.h>
# include <Functiondiscoverykeys_devpkey.h>
#endif
#endif
#if defined(TARGET_OSX) || defined(TARGET_IOS)
#include <AudioUnit/AudioUnit.h>
#include <AudioToolbox/AudioConverter.h>
#include <AudioToolbox/AudioServices.h>
#include <mach/mach_time.h>
# include <AudioUnit/AudioUnit.h>
# include <AudioToolbox/AudioConverter.h>
# include <AudioToolbox/AudioServices.h>
# include <mach/mach_time.h>
#endif
#include <vector>
@@ -27,52 +27,52 @@
namespace Audio
{
class TimeSource
{
protected:
class TimeSource
{
protected:
#ifdef TARGET_WIN
LARGE_INTEGER mCounter; /// Current value from QPC.
LARGE_INTEGER mFreq; /// Current frequency from QPC.
LARGE_INTEGER mCounter; /// Current value from QPC.
LARGE_INTEGER mFreq; /// Current frequency from QPC.
#endif
#if defined(TARGET_OSX) || defined(TARGET_IOS)
uint64_t mTime;
uint64_t mTime;
struct mach_timebase_info mTimebase;
double mRatio;
double mRatio;
#endif
unsigned mQuantTime; /// Used time quants length in milliseconds.
unsigned mDepthTime; /// Number of available time quants.
unsigned mTailTime; /// Not-accounted milliseconds.
unsigned mQuantTime; /// Used time quants length in milliseconds.
unsigned mDepthTime; /// Number of available time quants.
unsigned mTailTime; /// Not-accounted milliseconds.
public:
public:
TimeSource(int quantTime, int nrOfQuants);
~TimeSource() = default;
~TimeSource();
void start();
void stop();
void start();
void stop();
unsigned time();
};
};
class StubTimer
{
public:
class StubTimer
{
public:
StubTimer(int bufferTime, int bufferCount);
~StubTimer();
void start();
void stop();
void waitForBuffer();
protected:
unsigned mBufferTime;
unsigned mBufferCount;
unsigned mCurrentTime;
TimeSource mTimeSource;
protected:
unsigned mBufferTime;
unsigned mBufferCount;
unsigned mCurrentTime;
TimeSource mTimeSource;
#ifdef TARGET_WIN
HANDLE mStubSignal;
HANDLE mStubSignal;
#endif
bool mActive;
};
} // namespace Audio
bool mActive;
};
}
#endif
src/engine/audio/Audio_Interface.cpp
+38 -20
View File
@@ -7,16 +7,16 @@
#include "../helper/HL_OsVersion.h"
#if !defined(USE_NULL_AUDIO)
#ifdef TARGET_WIN
#include "Audio_Wmme.h"
#include "Audio_DirectSound.h"
#endif
#ifdef TARGET_OSX
#include "Audio_CoreAudio.h"
#endif
#ifdef TARGET_ANDROID
#include "Audio_Android.h"
#endif
# ifdef TARGET_WIN
# include "Audio_Wmme.h"
# include "Audio_DirectSound.h"
# endif
# ifdef TARGET_OSX
# include "Audio_CoreAudio.h"
# endif
# ifdef TARGET_ANDROID
# include "Audio_Android.h"
# endif
#endif
#include "Audio_Helper.h"
@@ -24,9 +24,14 @@
using namespace Audio;
Device::Device() : mConnection(nullptr) {}
Device::Device()
:mConnection(nullptr)
{
}
Device::~Device() {}
Device::~Device()
{
}
void Device::setConnection(DataConnection* connection)
@@ -39,9 +44,13 @@ DataConnection* Device::connection()
return mConnection;
}
InputDevice::InputDevice() {}
InputDevice::InputDevice()
{
}
InputDevice::~InputDevice() {}
InputDevice::~InputDevice()
{
}
InputDevice* InputDevice::make(int devId)
{
@@ -62,9 +71,13 @@ InputDevice* InputDevice::make(int devId)
return nullptr;
}
OutputDevice::OutputDevice() {}
OutputDevice::OutputDevice()
{
}
OutputDevice::~OutputDevice() {}
OutputDevice::~OutputDevice()
{
}
OutputDevice* OutputDevice::make(int devId)
{
@@ -72,7 +85,7 @@ OutputDevice* OutputDevice::make(int devId)
return new NullOutputDevice();
#else
#if defined(TARGET_WIN)
// return new WmmeOutputDevice(index);
//return new WmmeOutputDevice(index);
return new DSoundOutputDevice(DSoundHelper::deviceId2Guid(devId, false));
#endif
#ifdef TARGET_OSX
@@ -87,9 +100,13 @@ OutputDevice* OutputDevice::make(int devId)
// --- Enumerator ---
Enumerator::Enumerator() {}
Enumerator::Enumerator()
{
}
Enumerator::~Enumerator() {}
Enumerator::~Enumerator()
{
}
int Enumerator::nameToIndex(const std::tstring& name)
{
@@ -102,6 +119,7 @@ int Enumerator::nameToIndex(const std::tstring& name)
Enumerator* Enumerator::make(bool useNull)
{
if (useNull)
return new NullEnumerator();
#ifndef USE_NULL_AUDIO
@@ -129,7 +147,7 @@ OsEngine* OsEngine::instance()
#ifdef TARGET_ANDROID
return nullptr; // As we use Oboe library for now
// return &OpenSLEngine::instance();
//return &OpenSLEngine::instance();
#endif
return nullptr;
src/engine/audio/Audio_Interface.h
+68 -66
View File
@@ -7,7 +7,7 @@
#define __AUDIO_INTERFACE_H
#include <string>
#include "../engine_config.h"
#include "../config.h"
#include "../helper/HL_Types.h"
#include "../helper/HL_VariantMap.h"
#include "../helper/HL_Pointer.h"
@@ -16,118 +16,120 @@
namespace Audio
{
enum
{
enum
{
myMicrophone = 1,
mySpeaker = 2
};
};
struct Format
{
struct Format
{
int mRate;
int mChannels;
Format() : mRate(AUDIO_SAMPLERATE), mChannels(AUDIO_CHANNELS) {}
Format()
:mRate(AUDIO_SAMPLERATE), mChannels(AUDIO_CHANNELS)
{}
Format(int rate, int channels) : mRate(rate), mChannels(channels) {}
Format(int rate, int channels)
:mRate(rate), mChannels(channels)
{}
size_t samplesFromSize(size_t length) const { return length / 2 / mChannels; }
size_t samplesFromSize(size_t length) const
{
return length / 2 / mChannels;
}
// Returns milliseconds
float timeFromSize(size_t length) const { return float(samplesFromSize(length) / (mRate / 1000.0)); }
float timeFromSize(size_t length) const
{
return float(samplesFromSize(length) / (mRate / 1000.0));
}
float sizeFromTime(size_t milliseconds) const { return float((milliseconds * mRate) / 500.0 * mChannels); }
size_t sizeFromTime(std::chrono::milliseconds ms) const { return sizeFromTime(ms.count()); }
float sizeFromTime(size_t milliseconds) const
{
return float((milliseconds * mRate) / 500.0 * mChannels);
}
std::string toString()
{
char buffer[64];
std::snprintf(buffer, sizeof(buffer), "%dHz %dch", mRate, mChannels);
return std::string(buffer);
char buffer[64];
sprintf(buffer, "%dHz %dch", mRate, mChannels);
return std::string(buffer);
}
};
bool operator==(const Format& rhs) const { return mRate == rhs.mRate && mChannels == rhs.mChannels; }
bool operator!=(const Format& rhs) const { return mRate != rhs.mRate || mChannels != rhs.mChannels; }
int rate() const { return mRate; }
int channels() const { return mChannels; }
};
class DataConnection
{
public:
class DataConnection
{
public:
virtual void onMicData(const Format& format, const void* buffer, int length) = 0;
virtual void onSpkData(const Format& format, void* buffer, int length) = 0;
};
};
class Device
{
public:
class Device
{
public:
Device();
virtual ~Device();
void setConnection(DataConnection* connection);
void setConnection(DataConnection* connection);
DataConnection* connection();
virtual bool open() = 0;
virtual void close() = 0;
virtual Format getFormat() = 0;
protected:
virtual bool open() = 0;
virtual void close() = 0;
virtual Format getFormat() = 0;
protected:
DataConnection* mConnection;
};
};
class InputDevice : public Device
{
public:
class InputDevice: public Device
{
public:
InputDevice();
virtual ~InputDevice();
static InputDevice* make(int devId);
};
typedef std::shared_ptr<InputDevice> PInputDevice;
};
typedef std::shared_ptr<InputDevice> PInputDevice;
class OutputDevice : public Device
{
public:
class OutputDevice: public Device
{
public:
OutputDevice();
virtual ~OutputDevice();
static OutputDevice* make(int devId);
};
typedef std::shared_ptr<OutputDevice> POutputDevice;
};
typedef std::shared_ptr<OutputDevice> POutputDevice;
class Enumerator
{
public:
class Enumerator
{
public:
Enumerator();
virtual ~Enumerator();
int nameToIndex(const std::tstring& name);
int nameToIndex(const std::tstring& name);
virtual void open(int direction) = 0;
virtual void close() = 0;
virtual void open(int direction) = 0;
virtual void close() = 0;
virtual int count() = 0;
virtual int count() = 0;
virtual std::tstring nameAt(int index) = 0;
virtual int idAt(int index) = 0;
virtual int indexOfDefaultDevice() = 0;
virtual int idAt(int index) = 0;
virtual int indexOfDefaultDevice() = 0;
static Enumerator* make(bool useNull = false);
};
static Enumerator* make(bool useNull = false);
};
class OsEngine
{
public:
virtual void open() = 0;
virtual void close() = 0;
class OsEngine
{
public:
virtual void open() = 0;
virtual void close() = 0;
static OsEngine* instance();
};
};
}; // namespace Audio
#endif
src/engine/audio/Audio_Mixer.cpp
+212 -225
View File
@@ -3,7 +3,7 @@
* 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/. */
#include "../engine_config.h"
#include "../config.h"
#include "../helper/HL_Exception.h"
#include "../helper/HL_Log.h"
@@ -12,339 +12,326 @@
#include "Audio_Mixer.h"
#define LOG_SUBSYSTEM "audio"
#define LOG_SUBSYSTEM "Mixer"
using namespace Audio;
Mixer::Stream::Stream()
{
mResampler8.start(AUDIO_CHANNELS, 8000, AUDIO_SAMPLERATE);
mResampler16.start(AUDIO_CHANNELS, 16000, AUDIO_SAMPLERATE);
mResampler32.start(AUDIO_CHANNELS, 32000, AUDIO_SAMPLERATE);
mResampler48.start(AUDIO_CHANNELS, 48000, AUDIO_SAMPLERATE);
mActive = false;
mContext = nullptr;
mSSRC = 0;
mFadeOutCounter = 0;
mData.setCapacity(AUDIO_SPK_BUFFER_SIZE * AUDIO_SPK_BUFFER_COUNT);
mResampler8.start(AUDIO_CHANNELS, 8000, AUDIO_SAMPLERATE);
mResampler16.start(AUDIO_CHANNELS, 16000, AUDIO_SAMPLERATE);
mResampler32.start(AUDIO_CHANNELS, 32000, AUDIO_SAMPLERATE);
mResampler48.start(AUDIO_CHANNELS, 48000, AUDIO_SAMPLERATE);
mActive = false;
mContext = nullptr;
mSSRC = 0;
mFadeOutCounter = 0;
mData.setCapacity(AUDIO_SPK_BUFFER_SIZE * AUDIO_SPK_BUFFER_COUNT);
}
Mixer::Stream::~Stream() {}
Mixer::Stream::~Stream()
{
}
void Mixer::Stream::setSsrc(unsigned ssrc)
{
mSSRC = ssrc;
mSSRC = ssrc;
}
unsigned Mixer::Stream::ssrc()
{
return mSSRC;
return mSSRC;
}
void Mixer::Stream::setContext(void* context)
{
mContext = context;
mContext = context;
}
void* Mixer::Stream::context()
{
return mContext;
return mContext;
}
DataWindow& Mixer::Stream::data()
{
return mData;
return mData;
}
bool Mixer::Stream::active()
{
return mActive;
return mActive;
}
void Mixer::Stream::setActive(bool active)
{
mActive = active;
mActive = active;
}
void Mixer::Stream::addPcm(int rate, const void* input, int length)
{
// Resample to internal sample rate
size_t outputSize = size_t(0.5 + length * ((float)AUDIO_SAMPLERATE / rate));
if (mTempBuffer.size() < outputSize)
mTempBuffer.resize(outputSize);
// Resample to internal sample rate
size_t outputSize = size_t(0.5 + length * ((float)AUDIO_SAMPLERATE / rate));
if (mTempBuffer.size() < outputSize)
mTempBuffer.resize(outputSize);
Resampler* resampler = (rate == 8000)
? &mResampler8
: ((rate == 16000) ? &mResampler16 : ((rate == 32000) ? &mResampler32 : &mResampler48));
size_t inputProcessed = 0;
resampler->processBuffer(input, length, inputProcessed, mTempBuffer.mutableData(), outputSize);
// inputProcessed result value is ignored here - rate will be 8/16/32/48k, inputProcessed is equal to length
Resampler* resampler = (rate == 8000) ? &mResampler8 : ((rate == 16000) ? &mResampler16 : ((rate == 32000) ? &mResampler32 : &mResampler48));
size_t inputProcessed = 0;
resampler->processBuffer(input, length, inputProcessed, mTempBuffer.mutableData(), outputSize);
// inputProcessed result value is ignored here - rate will be 8/16/32/48k, inputProcessed is equal to length
// Queue data
mData.add(mTempBuffer.data(), outputSize);
// Queue data
mData.add(mTempBuffer.data(), outputSize);
}
Mixer::Mixer()
{
mActiveCounter = 0;
mOutput.setCapacity(32768);
mActiveCounter = 0;
mOutput.setCapacity(32768);
}
Mixer::~Mixer() {}
Mixer::~Mixer()
{
}
void Mixer::unregisterChannel(void* channel)
{
Lock l(mMutex);
for (int i = 0; i < AUDIO_MIX_CHANNEL_COUNT; i++)
for (int i=0; i<AUDIO_MIX_CHANNEL_COUNT; i++)
{
Stream& c = mChannelList[i];
if (c.active() && c.context() == channel)
{
Stream& c = mChannelList[i];
if (c.active() && c.context() == channel)
{
c.setActive(false); // stream is not active anymore
c.data().clear(); // clear data
mActiveCounter--;
}
c.setActive(false); // stream is not active anymore
c.data().clear(); // clear data
mActiveCounter--;
}
}
}
void Mixer::clear(void* context, unsigned ssrc)
{
Lock l(mMutex);
for (int i = 0; i < AUDIO_MIX_CHANNEL_COUNT; i++)
for (int i=0; i<AUDIO_MIX_CHANNEL_COUNT; i++)
{
Stream& c = mChannelList[i];
if (c.active() && c.context() == context && c.ssrc() == ssrc)
{
Stream& c = mChannelList[i];
if (c.active() && c.context() == context && c.ssrc() == ssrc)
{
c.setActive(false);
c.data().clear();
mActiveCounter--;
}
c.setActive(false);
c.data().clear();
mActiveCounter--;
}
}
}
Mixer::Stream* Mixer::allocateChannel(void* context, unsigned ssrc)
{
// Allocate new channel
Lock l(mMutex);
Stream* channel;
for (int i = 0; i < AUDIO_MIX_CHANNEL_COUNT; i++)
// Allocate new channel
Lock l(mMutex);
Stream* channel;
for (int i=0; i<AUDIO_MIX_CHANNEL_COUNT;i++)
{
channel = &mChannelList[i];
if (!channel->active())
{
channel = &mChannelList[i];
if (!channel->active())
{
channel->setSsrc(ssrc);
channel->setContext(context);
channel->data().clear();
mActiveCounter++;
channel->setActive(true);
return channel;
}
channel->setSsrc(ssrc);
channel->setContext(context);
channel->data().clear();
mActiveCounter++;
channel->setActive(true);
return channel;
}
return NULL;
}
return NULL;
}
void Mixer::addPcm(void* context, unsigned ssrc, const void* inputData, int inputLength, int inputRate, bool fadeOut)
void Mixer::addPcm(void* context, unsigned ssrc,
const void* inputData, int inputLength,
int inputRate, bool fadeOut)
{
assert(inputRate == 8000 || inputRate == 16000 || inputRate == 32000);
assert(inputRate == 8000 || inputRate == 16000 || inputRate == 32000);
Lock l(mMutex);
int i;
int i;
// Locate a channel
Stream* channel = NULL;
// Locate a channel
Stream* channel = NULL;
for (i = 0; i < AUDIO_MIX_CHANNEL_COUNT && !channel; i++)
{
Stream& c = mChannelList[i];
if (c.active() && c.context() == context && c.ssrc() == ssrc)
channel = &c;
}
for (i=0; i<AUDIO_MIX_CHANNEL_COUNT && !channel; i++)
{
Stream& c = mChannelList[i];
if (c.active() && c.context() == context && c.ssrc() == ssrc)
channel = &c;
}
if (!channel)
{
channel = allocateChannel(context, ssrc);
if (!channel)
{
channel = allocateChannel(context, ssrc);
if (!channel)
throw Exception(ERR_MIXER_OVERFLOW);
}
throw Exception(ERR_MIXER_OVERFLOW);
}
channel->addPcm(inputRate, inputData, inputLength);
channel->addPcm(inputRate, inputData, inputLength);
}
void Mixer::addPcm(void* context, unsigned ssrc, Audio::DataWindow& w, int rate, bool fadeOut)
{
assert(rate == 8000 || rate == 16000 || rate == 32000 || rate == 48000);
assert(rate == 8000 || rate == 16000 || rate == 32000 || rate == 48000);
Lock l(mMutex);
int i;
int i;
// Locate a channel
Stream* channel = NULL;
// Locate a channel
Stream* channel = NULL;
for (i = 0; i < AUDIO_MIX_CHANNEL_COUNT && !channel; i++)
{
Stream& c = mChannelList[i];
if (c.active() && c.context() == context && c.ssrc() == ssrc)
channel = &c;
}
for (i=0; i<AUDIO_MIX_CHANNEL_COUNT && !channel; i++)
{
Stream& c = mChannelList[i];
if (c.active() && c.context() == context && c.ssrc() == ssrc)
channel = &c;
}
if (!channel)
{
channel = allocateChannel(context, ssrc);
if (!channel)
{
channel = allocateChannel(context, ssrc);
if (!channel)
throw Exception(ERR_MIXER_OVERFLOW);
}
throw Exception(ERR_MIXER_OVERFLOW);
}
channel->addPcm(rate, w.data(), w.filled());
// ICELogSpecial(<<"Mixer stream " << int(this) << " has " << w.filled() << " bytes");
channel->addPcm(rate, w.data(), w.filled());
//ICELogSpecial(<<"Mixer stream " << int(this) << " has " << w.filled() << " bytes");
}
void Mixer::mix()
{
Lock l(mMutex);
// Current sample
int sample = 0;
// Current sample
int sample = 0;
// Counter of processed active channels
int processed = 0;
// Counter of processed active channels
int processed = 0;
// Samples & sources counters
unsigned sampleCounter = 0, sourceCounter;
// Samples & sources counters
unsigned sampleCounter = 0, sourceCounter;
short outputBuffer[512];
unsigned outputCounter = 0;
short outputBuffer[512];
unsigned outputCounter = 0;
// Build active channel map
Stream* channelList[AUDIO_MIX_CHANNEL_COUNT];
int activeCounter = 0;
for (int i=0; i<AUDIO_MIX_CHANNEL_COUNT; i++)
if (mChannelList[i].active())
channelList[activeCounter++] = &mChannelList[i];
// Build active channel map
Stream* channelList[AUDIO_MIX_CHANNEL_COUNT];
int activeCounter = 0;
for (int i = 0; i < AUDIO_MIX_CHANNEL_COUNT; i++)
if (mChannelList[i].active())
channelList[activeCounter++] = &mChannelList[i];
// No active channels - nothing to mix - exit
if (!activeCounter)
{
// ICELogDebug(<< "No active channel");
return;
}
// No active channels - nothing to mix - exit
if (!activeCounter)
// Optimized versions for 1& 2 active channels
if (activeCounter == 1)
{
// Copy much samples as we have
Stream& audio = *channelList[0];
// Copy the decoded data
mOutput.add(audio.data().data(), audio.data().filled());
// Erase copied audio samples
audio.data().erase(audio.data().filled());
//ICELogSpecial(<<"Length of mixer stream " << audio.data().filled());
}
else
if (activeCounter == 2)
{
Stream& audio1 = *channelList[0];
Stream& audio2 = *channelList[1];
int filled1 = audio1.data().filled() / 2, filled2 = audio2.data().filled() / 2;
int available = filled1 > filled2 ? filled1 : filled2;
// Find how much samples can be mixed
int filled = mOutput.filled() / 2;
int maxsize = mOutput.capacity() / 2;
if (maxsize - filled < available)
available = maxsize - filled;
short sample = 0;
for (int i=0; i<available; i++)
{
short sample1 = filled1 > i ? audio1.data().shortAt(i) : 0;
short sample2 = filled2 > i ? audio2.data().shortAt(i) : 0;
sample = (abs(sample1) > abs(sample2)) ? sample1 : sample2;
mOutput.add(sample);
}
audio1.data().erase(available*2);
audio2.data().erase(available*2);
}
else
{
do
{
// ICELogDebug(<< "No active channel");
return;
}
sample = 0;
sourceCounter = 0;
processed = 0;
for (int i=0; i<activeCounter; i++)
{
Stream& audio = *channelList[i];
processed++;
// Optimized versions for 1& 2 active channels
if (activeCounter == 1)
{
// Copy much samples as we have
Stream& audio = *channelList[0];
// Copy the decoded data
mOutput.add(audio.data().data(), audio.data().filled());
// Erase copied audio samples
audio.data().erase(audio.data().filled());
// ICELogSpecial(<<"Length of mixer stream " << audio.data().filled());
}
else if (activeCounter == 2)
{
Stream& audio1 = *channelList[0];
Stream& audio2 = *channelList[1];
int filled1 = audio1.data().filled() / 2, filled2 = audio2.data().filled() / 2;
int available = filled1 > filled2 ? filled1 : filled2;
// Find how much samples can be mixed
int filled = mOutput.filled() / 2;
int maxsize = mOutput.capacity() / 2;
if (maxsize - filled < available)
available = maxsize - filled;
short sample = 0;
for (int i = 0; i < available; i++)
if (audio.data().filled() > (int)sampleCounter * 2)
{
short sample1 = filled1 > i ? audio1.data().shortAt(i) : 0;
short sample2 = filled2 > i ? audio2.data().shortAt(i) : 0;
sample = (abs(sample1) > abs(sample2)) ? sample1 : sample2;
mOutput.add(sample);
short currentSample = audio.data().shortAt(sampleCounter);
if (abs(currentSample) > abs(sample))
sample = currentSample;
sourceCounter++;
}
audio1.data().erase(available * 2);
audio2.data().erase(available * 2);
}
if (sourceCounter)
{
outputBuffer[outputCounter++] = (short)sample;
sampleCounter++;
}
// Check if time to flash output buffer
if ((!sourceCounter || outputCounter == 512) && outputCounter)
{
mOutput.add(outputBuffer, outputCounter * 2);
outputCounter = 0;
}
}
else
while (sourceCounter);
processed = 0;
for (int i=0; i<activeCounter; i++)
{
do
{
sample = 0;
sourceCounter = 0;
processed = 0;
for (int i = 0; i < activeCounter; i++)
{
Stream& audio = *channelList[i];
processed++;
if (audio.data().filled() > (int)sampleCounter * 2)
{
short currentSample = audio.data().shortAt(sampleCounter);
if (abs(currentSample) > abs(sample))
sample = currentSample;
sourceCounter++;
}
}
if (sourceCounter)
{
outputBuffer[outputCounter++] = (short)sample;
sampleCounter++;
}
// Check if time to flash output buffer
if ((!sourceCounter || outputCounter == 512) && outputCounter)
{
mOutput.add(outputBuffer, outputCounter * 2);
outputCounter = 0;
}
} while (sourceCounter);
processed = 0;
for (int i = 0; i < activeCounter; i++)
{
Stream& audio = *channelList[i];
audio.data().erase(sampleCounter * 2);
}
Stream& audio = *channelList[i];
audio.data().erase(sampleCounter*2);
}
}
}
int Mixer::getPcm(void* outputData, int outputLength)
{
Lock l(mMutex);
if (mOutput.filled() < outputLength)
mix();
if (mOutput.filled() < outputLength)
mix();
// ICELogSpecial(<<"Mixer has " << mOutput.filled() << " available bytes");
memset(outputData, 0, outputLength);
return mOutput.read(outputData, outputLength);
//ICELogSpecial(<<"Mixer has " << mOutput.filled() << " available bytes");
memset(outputData, 0, outputLength);
return mOutput.read(outputData, outputLength);
}
int Mixer::mixAndGetPcm(Audio::DataWindow& output)
{
Lock l(mMutex);
// Mix
mix();
// Mix
mix();
// Set output space
output.setCapacity(mOutput.filled());
size_t avail = mOutput.filled();
if (!avail)
{
output.setFilled(0);
return 0;
}
// Make sure output has enough space (setCapacity only ever grows the window)
if (output.capacity() < avail)
output.setCapacity(avail);
// Read mixed data to output and publish the real byte count
size_t got = mOutput.read(output.mutableData(), avail);
output.setFilled(got);
return static_cast<int>(got);
// Read mixed data to output
return mOutput.read(output.mutableData(), output.capacity());
}
int Mixer::available()
{
return mOutput.filled();
return mOutput.filled();
}
src/engine/audio/Audio_Mixer.h
+34 -31
View File
@@ -6,7 +6,7 @@
#ifndef _RX_MIXER_H
#define _RX_MIXER_H
#include "../engine_config.h"
#include "../config.h"
#include "../helper/HL_ByteBuffer.h"
#include "../helper/HL_Sync.h"
#include "Audio_Resampler.h"
@@ -16,43 +16,46 @@
namespace Audio
{
class Mixer
{
protected:
class Mixer
{
protected:
class Stream
{
protected:
DataWindow mData;
Resampler mResampler8, mResampler16, mResampler32, mResampler48;
bool mActive;
void* mContext;
unsigned mSSRC;
unsigned mFadeOutCounter;
ByteBuffer mTempBuffer;
DataWindow mData;
Resampler mResampler8,
mResampler16,
mResampler32,
mResampler48;
bool mActive;
void* mContext;
unsigned mSSRC;
unsigned mFadeOutCounter;
ByteBuffer mTempBuffer;
public:
Stream();
~Stream();
Stream();
~Stream();
void setSsrc(unsigned ssrc);
unsigned ssrc();
void setContext(void* context);
void* context();
DataWindow& data();
bool active();
void setActive(bool active);
void addPcm(int rate, const void* input, int length);
void setSsrc(unsigned ssrc);
unsigned ssrc();
void setContext(void* context);
void* context();
DataWindow& data();
bool active();
void setActive(bool active);
void addPcm(int rate, const void* input, int length);
};
Stream mChannelList[AUDIO_MIX_CHANNEL_COUNT];
Mutex mMutex;
DataWindow mOutput;
std::atomic_int mActiveCounter;
Stream mChannelList[AUDIO_MIX_CHANNEL_COUNT];
Mutex mMutex;
DataWindow mOutput;
std::atomic_int mActiveCounter;
void mix();
Stream* allocateChannel(void* context, unsigned ssrc);
void mix();
Stream* allocateChannel(void* context, unsigned ssrc);
public:
public:
Mixer();
~Mixer();
@@ -62,8 +65,8 @@ public:
void addPcm(void* context, unsigned ssrc, Audio::DataWindow& w, int rate, bool fadeOut);
int getPcm(void* outputData, int outputLength);
int mixAndGetPcm(Audio::DataWindow& output);
int available();
};
} // namespace Audio
int available();
};
} //end of namespace
#endif
src/engine/audio/Audio_Null.cpp
+85 -94
View File
@@ -1,187 +1,178 @@
#include "Audio_Null.h"
#include "helper/HL_Log.h"
#include <assert.h>
#include <chrono>
#define LOG_SUBSYSTEM "audio"
#define LOG_SUBSYSTEM "NULL audio"
using namespace Audio;
using namespace std::chrono_literals;
NullTimer::NullTimer(std::chrono::milliseconds interval, Delegate* delegate, const char* name)
: mShutdown(false), mDelegate(delegate), mInterval(interval), mThreadName(name)
NullTimer::NullTimer(int interval, Delegate *delegate, const char* name)
:mShutdown(false), mDelegate(delegate), mInterval(interval), mThreadName(name)
{
start();
start();
}
NullTimer::~NullTimer()
{
stop();
stop();
}
void NullTimer::start()
{
mShutdown = false;
mWorkerThread = std::thread(&NullTimer::run, this);
mShutdown = false;
mWorkerThread = std::thread(&NullTimer::run, this);
}
void NullTimer::stop()
{
mShutdown = true;
if (mWorkerThread.joinable())
mWorkerThread.join();
mShutdown = true;
if (mWorkerThread.joinable())
mWorkerThread.join();
}
void NullTimer::run()
{
mTail = 0us;
while (!mShutdown)
mTail = 0;
while (!mShutdown)
{
// Get current timestamp
std::chrono::system_clock::time_point timestamp = std::chrono::system_clock::now();
while (mTail >= mInterval * 1000)
{
// Get current timestamp
std::chrono::system_clock::time_point timestamp = std::chrono::system_clock::now();
while (mTail >= mInterval)
{
if (mDelegate)
mDelegate->onTimerSignal(*this);
mTail -= mInterval;
}
// Sleep for mInterval - mTail milliseconds
std::this_thread::sleep_for(mInterval - mTail);
mTail =
mTail + std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now() - timestamp);
if (mDelegate)
mDelegate->onTimerSignal(*this);
mTail -= mInterval * 1000;
}
// Sleep for mInterval - mTail milliseconds
std::this_thread::sleep_for(std::chrono::microseconds(mInterval * 1000 - mTail));
mTail += (int)std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now() - timestamp).count();
}
}
// --------------------- NullInputDevice -------------------------
NullInputDevice::NullInputDevice() : mBuffer(nullptr) {}
NullInputDevice::NullInputDevice()
:mBuffer(nullptr)
{
}
NullInputDevice::~NullInputDevice()
{
internalClose();
close();
}
bool NullInputDevice::open()
{
ICELogInfo(<< "Starting NullInputDevice for " << AUDIO_MIC_BUFFER_LENGTH << "ms buffers");
mBuffer = malloc(AUDIO_MIC_BUFFER_SIZE);
memset(mBuffer, 0, AUDIO_MIC_BUFFER_SIZE);
mTimeCounter = 0;
mDataCounter = 0;
// Creation of timer starts it also. So first onTimerSignal can come even before open() returns.
mTimer = std::make_shared<NullTimer>(std::chrono::milliseconds(AUDIO_MIC_BUFFER_LENGTH), this, "null_mic");
return true;
}
void NullInputDevice::internalClose()
{
ICELogInfo(<< "Stopping NullInputDevice");
mTimer.reset();
if (mBuffer)
{
free(mBuffer);
mBuffer = nullptr;
}
ICELogInfo(<< "Pseudocaptured " << mTimeCounter << " milliseconds , " << mDataCounter << " bytes.");
mBuffer = malloc(AUDIO_MIC_BUFFER_SIZE);
memset(mBuffer, 0, AUDIO_MIC_BUFFER_SIZE);
mTimeCounter = 0; mDataCounter = 0;
// Creation of timer starts it also. So first onTimerSignal can come even before open() returns.
mTimer = std::make_shared<NullTimer>(AUDIO_MIC_BUFFER_LENGTH, this, "NullMicrophoneThread");
return true;
}
void NullInputDevice::close()
{
internalClose();
mTimer.reset();
if (mBuffer)
{
free(mBuffer);
mBuffer = nullptr;
}
ICELogInfo(<<"Pseudocaptured " << mTimeCounter << " milliseconds , " << mDataCounter << " bytes.");
}
Format NullInputDevice::getFormat()
{
assert(Format().sizeFromTime(AUDIO_MIC_BUFFER_LENGTH) == AUDIO_MIC_BUFFER_SIZE);
return {}; // Return library-define default format
assert (Format().sizeFromTime(AUDIO_MIC_BUFFER_LENGTH) == AUDIO_MIC_BUFFER_SIZE);
return Format();
}
void NullInputDevice::onTimerSignal(NullTimer& timer)
{
mTimeCounter += AUDIO_MIC_BUFFER_LENGTH;
mDataCounter += AUDIO_MIC_BUFFER_SIZE;
if (mConnection)
mConnection->onMicData(getFormat(), mBuffer, AUDIO_MIC_BUFFER_SIZE);
mTimeCounter += AUDIO_MIC_BUFFER_LENGTH;
mDataCounter += AUDIO_MIC_BUFFER_SIZE;
if (mConnection)
mConnection->onMicData(getFormat(), mBuffer, AUDIO_MIC_BUFFER_SIZE);
}
// --------------------- NullOutputDevice --------------------------
NullOutputDevice::NullOutputDevice() : mBuffer(nullptr) {}
NullOutputDevice::NullOutputDevice()
:mBuffer(nullptr)
{
}
NullOutputDevice::~NullOutputDevice()
{
internalClose();
close();
}
bool NullOutputDevice::open()
{
mTimeCounter = 0;
mDataCounter = 0;
mBuffer = malloc(AUDIO_SPK_BUFFER_SIZE);
// Creation of timer starts it also. So first onSpkData() can come before open() returns even.
mTimer = std::make_shared<NullTimer>(std::chrono::milliseconds(AUDIO_SPK_BUFFER_LENGTH), this, "null_spk");
return true;
}
void NullOutputDevice::internalClose()
{
mTimer.reset();
free(mBuffer);
mBuffer = nullptr;
ICELogInfo(<< "Pseudoplayed " << mTimeCounter << " milliseconds, " << mDataCounter << " bytes.");
mTimeCounter = 0; mDataCounter = 0;
mBuffer = malloc(AUDIO_SPK_BUFFER_SIZE);
// Creation of timer starts it also. So first onSpkData() can come before open() returns even.
mTimer = std::make_shared<NullTimer>(AUDIO_SPK_BUFFER_LENGTH, this, "NullSpeakerThread");
return true;
}
void NullOutputDevice::close()
{
internalClose();
mTimer.reset();
free(mBuffer); mBuffer = nullptr;
ICELogInfo(<< "Pseudoplayed " << mTimeCounter << " milliseconds, " << mDataCounter << " bytes.");
}
Format NullOutputDevice::getFormat()
{
assert(Format().sizeFromTime(AUDIO_SPK_BUFFER_LENGTH) == AUDIO_SPK_BUFFER_SIZE);
return Format();
assert (Format().sizeFromTime(AUDIO_SPK_BUFFER_LENGTH) == AUDIO_SPK_BUFFER_SIZE);
return Format();
}
void NullOutputDevice::onTimerSignal(NullTimer& timer)
void NullOutputDevice::onTimerSignal(NullTimer &timer)
{
mTimeCounter += AUDIO_SPK_BUFFER_LENGTH;
mDataCounter += AUDIO_SPK_BUFFER_SIZE;
if (mConnection)
mConnection->onSpkData(getFormat(), mBuffer, AUDIO_SPK_BUFFER_SIZE);
mTimeCounter += AUDIO_SPK_BUFFER_LENGTH;
mDataCounter += AUDIO_SPK_BUFFER_SIZE;
if (mConnection)
mConnection->onSpkData(getFormat(), mBuffer, AUDIO_SPK_BUFFER_SIZE);
}
// ---------------------- NullEnumerator --------------------------
NullEnumerator::NullEnumerator() {}
NullEnumerator::NullEnumerator()
{}
NullEnumerator::~NullEnumerator() {}
NullEnumerator::~NullEnumerator()
{}
void NullEnumerator::open(int direction) {}
void NullEnumerator::open(int direction)
{}
void NullEnumerator::close() {}
void NullEnumerator::close()
{}
int NullEnumerator::count()
int NullEnumerator::count()
{
return 1;
return 1;
}
std::tstring NullEnumerator::nameAt(int index)
{
#if defined(TARGET_WIN)
return L"null";
return L"null";
#else
return "null";
return "null";
#endif
}
int NullEnumerator::idAt(int index)
{
return 0;
return 0;
}
int NullEnumerator::indexOfDefaultDevice()
{
return 0;
return 0;
}
src/engine/audio/Audio_Null.h
+47 -54
View File
@@ -2,92 +2,85 @@
#define __AUDIO_NULL_H
#include <thread>
#include <chrono>
#include "Audio_Interface.h"
namespace Audio
{
class NullTimer
{
public:
class NullTimer
{
public:
class Delegate
{
public:
virtual void onTimerSignal(NullTimer& timer) = 0;
virtual void onTimerSignal(NullTimer& timer) = 0;
};
protected:
std::thread mWorkerThread;
std::atomic_bool mShutdown = {false};
Delegate* mDelegate = nullptr;
std::chrono::milliseconds mInterval; // Interval - wanted number of milliseconds
std::chrono::microseconds mTail; // Number of milliseconds that can be sent immediately to sink
std::string mThreadName;
protected:
std::thread mWorkerThread;
volatile bool mShutdown;
Delegate* mDelegate;
int mInterval, // Interval - wanted number of milliseconds
mTail; // Number of milliseconds that can be sent immediately to sink
std::string mThreadName;
void start();
void stop();
void run();
public:
void start();
void stop();
void run();
public:
/* Interval is in milliseconds. */
NullTimer(std::chrono::milliseconds interval, Delegate* delegate, const char* name = nullptr);
NullTimer(int interval, Delegate* delegate, const char* name = nullptr);
~NullTimer();
};
};
class NullInputDevice : public InputDevice, public NullTimer::Delegate
{
protected:
void* mBuffer = nullptr;
class NullInputDevice: public InputDevice, public NullTimer::Delegate
{
protected:
void* mBuffer = nullptr;
std::shared_ptr<NullTimer> mTimer;
int64_t mTimeCounter = 0, mDataCounter = 0;
void internalClose();
public:
int64_t mTimeCounter = 0, mDataCounter = 0;
public:
NullInputDevice();
virtual ~NullInputDevice();
bool open() override;
void close() override;
bool open() override;
void close() override;
Format getFormat() override;
void onTimerSignal(NullTimer& timer) override;
};
void onTimerSignal(NullTimer& timer) override;
};
class NullOutputDevice : public OutputDevice, public NullTimer::Delegate
{
protected:
class NullOutputDevice: public OutputDevice, public NullTimer::Delegate
{
protected:
std::shared_ptr<NullTimer> mTimer;
void* mBuffer = nullptr;
int64_t mDataCounter = 0, mTimeCounter = 0;
void internalClose();
public:
void* mBuffer = nullptr;
int64_t mDataCounter = 0, mTimeCounter = 0;
public:
NullOutputDevice();
virtual ~NullOutputDevice();
bool open() override;
void close() override;
bool open() override;
void close() override;
Format getFormat() override;
void onTimerSignal(NullTimer& timer) override;
};
void onTimerSignal(NullTimer& timer) override;
};
class NullEnumerator : public Enumerator
{
public:
class NullEnumerator: public Enumerator
{
public:
NullEnumerator();
~NullEnumerator();
void open(int direction) override;
void close() override;
void open(int direction) override;
void close() override;
int count() override;
int count() override;
std::tstring nameAt(int index) override;
int idAt(int index) override;
int indexOfDefaultDevice() override;
};
int idAt(int index) override;
int indexOfDefaultDevice() override;
} // namespace Audio
};
}
#endif
src/engine/audio/Audio_Player.cpp
+91 -86
View File
@@ -7,160 +7,165 @@
#include "../helper/HL_Log.h"
#define LOG_SUBSYSTEM "audio"
#define LOG_SUBSYSTEM "Player"
using namespace Audio;
// -------------- Player -----------
Player::Player() : mDelegate(nullptr), mPlayedTime(0) {}
Player::Player()
:mDelegate(nullptr), mPlayedTime(0)
{
}
Player::~Player() {}
Player::~Player()
{
}
void Player::setDelegate(EndOfAudioDelegate* d)
{
mDelegate = d;
mDelegate = d;
}
Player::EndOfAudioDelegate* Player::getDelegate() const
{
return mDelegate;
return mDelegate;
}
void Player::setOutput(POutputDevice output)
{
mOutput = output;
if (mOutput)
mOutput->setConnection(this);
mOutput = output;
if (mOutput)
mOutput->setConnection(this);
}
POutputDevice Player::getOutput() const
{
return mOutput;
return mOutput;
}
void Player::onMicData(const Format& f, const void* buffer, int length)
{
// Do nothing here - this data sink is not used in player
// Do nothing here - this data sink is not used in player
}
#define BYTES_PER_MILLISECOND (AUDIO_SAMPLERATE / 1000 * 2 * AUDIO_CHANNELS)
void Player::onSpkData(const Format& f, void* buffer, int length)
{
Lock l(mGuard);
Lock l(mGuard);
// Fill buffer by zero if player owns dedicated device
if (mOutput)
memset(buffer, 0, length);
// Fill buffer by zero if player owns dedicated device
if (mOutput)
memset(buffer, 0, length);
// See if there is item in playlist
int produced = 0;
while (mPlaylist.size() && produced < length)
// See if there is item in playlist
int produced = 0;
while (mPlaylist.size() && produced < length)
{
PlaylistItem& item = mPlaylist.front();
// Check for timelength
if (item.mTimelength > 0 && item.mTimelength < mPlayedTime)
{
PlaylistItem& item = mPlaylist.front();
// Check for timelength
if (item.mTimelength > 0 && item.mTimelength < mPlayedTime)
{
onFilePlayed();
continue;
}
onFilePlayed();
continue;
}
int wasread = item.mFile->read((char*)buffer + produced, length - produced);
int wasread = item.mFile->read((char*)buffer+produced, length-produced);
mPlayedTime += float(wasread) / BYTES_PER_MILLISECOND;
produced += wasread;
if (wasread < length-produced)
{
if (item.mLoop)
{
item.mFile->rewind();
wasread = item.mFile->read((char*)buffer+produced, (length - produced));
mPlayedTime += float(wasread) / BYTES_PER_MILLISECOND;
produced += wasread;
if (wasread < length - produced)
{
if (item.mLoop)
{
item.mFile->rewind();
wasread = item.mFile->read((char*)buffer + produced, (length - produced));
mPlayedTime += float(wasread) / BYTES_PER_MILLISECOND;
produced += wasread;
}
else
onFilePlayed();
}
}
else
onFilePlayed();
}
}
}
void Player::onFilePlayed()
{
// Save usage id to release later from main loop
mFinishedUsages.push_back(mPlaylist.front().mUsageId);
// Save usage id to release later from main loop
mFinishedUsages.push_back(mPlaylist.front().mUsageId);
// Send event
if (mDelegate)
mDelegate->onFilePlayed(mPlaylist.front());
// Send event
if (mDelegate)
mDelegate->onFilePlayed(mPlaylist.front());
// Remove played item & reset played time
mPlaylist.pop_front();
mPlayedTime = 0;
// Remove played item & reset played time
mPlaylist.pop_front();
mPlayedTime = 0;
}
void Player::obtain(int usage)
{
Lock l(mGuard);
auto usageIter = mUsage.find(usage);
if (usageIter == mUsage.end())
mUsage[usage] = 1;
else
usageIter->second = usageIter->second + 1;
Lock l(mGuard);
auto usageIter = mUsage.find(usage);
if (usageIter == mUsage.end())
mUsage[usage] = 1;
else
usageIter->second = usageIter->second + 1;
if (mUsage.size() == 1 && mOutput)
mOutput->open();
if (mUsage.size() == 1 && mOutput)
mOutput->open();
}
void Player::release(int usage)
{
Lock l(mGuard);
UsageMap::iterator usageIter = mUsage.find(usage);
if (usageIter == mUsage.end())
return;
Lock l(mGuard);
UsageMap::iterator usageIter = mUsage.find(usage);
if (usageIter == mUsage.end())
return;
usageIter->second = usageIter->second - 1;
if (!usageIter->second)
mUsage.erase(usageIter);
usageIter->second = usageIter->second - 1;
if (!usageIter->second)
mUsage.erase(usageIter);
for (unsigned i = 0; i < mPlaylist.size(); i++)
if (mPlaylist[i].mUsageId == usage)
mPlaylist.erase(mPlaylist.begin() + i);
for (unsigned i=0; i<mPlaylist.size(); i++)
if (mPlaylist[i].mUsageId == usage)
mPlaylist.erase(mPlaylist.begin() + i);
if (mUsage.empty() && mOutput)
mOutput->close();
if (mUsage.empty() && mOutput)
mOutput->close();
}
int Player::releasePlayed()
{
Lock l(mGuard);
int result = mFinishedUsages.size();
while (!mFinishedUsages.empty())
{
release(mFinishedUsages.front());
mFinishedUsages.erase(mFinishedUsages.begin());
}
return result;
Lock l(mGuard);
int result = mFinishedUsages.size();
while (!mFinishedUsages.empty())
{
release(mFinishedUsages.front());
mFinishedUsages.erase(mFinishedUsages.begin());
}
return result;
}
void Player::add(int usageId, PWavFileReader file, bool loop, int timelength)
{
Lock l(mGuard);
PlaylistItem item;
item.mFile = file;
item.mLoop = loop;
item.mTimelength = timelength;
item.mUsageId = usageId;
mPlaylist.push_back(item);
Lock l(mGuard);
PlaylistItem item;
item.mFile = file;
item.mLoop = loop;
item.mTimelength = timelength;
item.mUsageId = usageId;
mPlaylist.push_back(item);
obtain(usageId);
obtain(usageId);
}
void Player::clear()
{
Lock l(mGuard);
while (mPlaylist.size())
onFilePlayed();
Lock l(mGuard);
while (mPlaylist.size())
onFilePlayed();
}
void Player::retrieveUsageIds(std::vector<int>& ids)
{
ids.assign(mFinishedUsages.begin(), mFinishedUsages.end());
mFinishedUsages.clear();
ids.assign(mFinishedUsages.begin(), mFinishedUsages.end());
mFinishedUsages.clear();
}
src/engine/audio/Audio_Player.h
+32 -33
View File
@@ -16,57 +16,56 @@
namespace Audio
{
class Player : public DataConnection
{
friend class DevicePair;
public:
class Player: public DataConnection
{
friend class DevicePair;
public:
struct PlaylistItem
{
PWavFileReader mFile;
bool mLoop;
int mTimelength;
int mUsageId;
PWavFileReader mFile;
bool mLoop;
int mTimelength;
int mUsageId;
};
typedef std::deque<PlaylistItem> Playlist;
class EndOfAudioDelegate
{
public:
virtual void onFilePlayed(PlaylistItem& item) = 0;
virtual void onFilePlayed(PlaylistItem& item) = 0;
};
protected:
protected:
typedef std::map<int, int> UsageMap;
Audio::POutputDevice mOutput;
UsageMap mUsage; // References map
std::vector<int> mFinishedUsages; // Finished plays
Audio::POutputDevice mOutput;
UsageMap mUsage; // References map
std::vector<int> mFinishedUsages; // Finished plays
Mutex mGuard;
Playlist mPlaylist;
float mPlayedTime;
EndOfAudioDelegate* mDelegate;
Mutex mGuard;
Playlist mPlaylist;
float mPlayedTime;
EndOfAudioDelegate* mDelegate;
void onMicData(const Format& f, const void* buffer, int length);
void onSpkData(const Format& f, void* buffer, int length);
void onFilePlayed();
void obtain(int usageId);
void onMicData(const Format& f, const void* buffer, int length);
void onSpkData(const Format& f, void* buffer, int length);
void onFilePlayed();
void obtain(int usageId);
public:
public:
Player();
~Player();
void setDelegate(EndOfAudioDelegate* d);
void setDelegate(EndOfAudioDelegate* d);
EndOfAudioDelegate* getDelegate() const;
void setOutput(POutputDevice output);
POutputDevice getOutput() const;
void setOutput(POutputDevice output);
POutputDevice getOutput() const;
void add(int usageId, PWavFileReader file, bool loop, int timelength);
void release(int usageId);
void clear();
int releasePlayed();
void retrieveUsageIds(std::vector<int>& ids);
};
} // namespace Audio
void add(int usageId, PWavFileReader file, bool loop, int timelength);
void release(int usageId);
void clear();
int releasePlayed();
void retrieveUsageIds(std::vector<int>& ids);
};
}
#endif
src/engine/audio/Audio_Quality.cpp
+128 -127
View File
@@ -3,232 +3,233 @@
* 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/. */
#include "../engine_config.h"
#include "../config.h"
#include "Audio_Quality.h"
#include "../helper/HL_Exception.h"
#include "../helper/HL_Types.h"
#include "speex/speex_preprocess.h"
#ifdef WIN32
#include <malloc.h>
# include <malloc.h>
#endif
#include <assert.h>
#include <string.h>
using namespace Audio;
#ifndef SHRT_MAX
#define SHRT_MAX 32767 /* maximum (signed) short value */
#endif
#define SHRT_MAX 32767 /* maximum (signed) short value */
AgcFilter::AgcFilter(int channels)
{
static const float DefaultLevel = 0.8f;
static const float DefaultLevel = 0.8f;
for (int i = 0; i < channels; i++)
{
Channel c;
float level = DefaultLevel;
c.mSampleMax = 1;
c.mCounter = 0;
c.mIgain = 65536;
if (level > 1.0f)
level = 1.0f;
else if (level < 0.5f)
level = 0.5f;
for (int i=0; i<channels; i++)
{
Channel c;
float level = DefaultLevel;
c.mSampleMax = 1;
c.mCounter = 0;
c.mIgain = 65536;
if (level > 1.0f)
level = 1.0f;
else
if (level < 0.5f)
level = 0.5f;
c.mIpeak = (int)(SHRT_MAX * level * 65536);
c.mIpeak = (int)(SHRT_MAX * level * 65536);
c.mSilenceCounter = 0;
mChannelList.push_back(c);
}
c.mSilenceCounter = 0;
mChannelList.push_back(c);
}
}
AgcFilter::~AgcFilter() {}
void AgcFilter::process(void* pcm, int length)
AgcFilter::~AgcFilter()
{
for (size_t i = 0; i < mChannelList.size(); i++)
processChannel((short*)pcm, length / (sizeof(short) * mChannelList.size()), i);
}
void AgcFilter::process(void *pcm, int length)
{
for (size_t i=0; i<mChannelList.size(); i++)
processChannel((short*)pcm, length / (sizeof(short) * mChannelList.size()), i);
}
void AgcFilter::processChannel(short* pcm, int nrOfSamples, int channelIndex)
{
int i;
int i;
for (i = 0; i < nrOfSamples; i++)
for(i=0; i<nrOfSamples; i++)
{
long gain_new;
int sample;
int sampleIndex = mChannelList.size() * i + channelIndex;
Channel& channel = mChannelList[channelIndex];
/* get the abs of buffer[i] */
sample = pcm[sampleIndex];
sample = (sample < 0 ? -(sample):sample);
if(sample > (int)channel.mSampleMax)
{
long gain_new;
int sample;
int sampleIndex = mChannelList.size() * i + channelIndex;
Channel& channel = mChannelList[channelIndex];
/* get the abs of buffer[i] */
sample = pcm[sampleIndex];
sample = (sample < 0 ? -(sample) : sample);
if (sample > (int)channel.mSampleMax)
{
/* update the max */
channel.mSampleMax = (unsigned int)sample;
}
channel.mCounter++;
/* Will we get an overflow with the current gain factor? */
if (((sample * channel.mIgain) >> 16) > channel.mIpeak)
{
/* Yes: Calculate new gain. */
channel.mIgain = ((channel.mIpeak / channel.mSampleMax) * 62259) >> 16;
channel.mSilenceCounter = 0;
pcm[sampleIndex] = (short)((pcm[sampleIndex] * channel.mIgain) >> 16);
continue;
}
/* Calculate new gain factor 10x per second */
if (channel.mCounter >= AUDIO_SAMPLERATE / 10)
{
if (channel.mSampleMax > AUDIO_SAMPLERATE / 10) /* speaking? */
{
gain_new = ((channel.mIpeak / channel.mSampleMax) * 62259) >> 16;
if (channel.mSilenceCounter > 40) /* pause -> speaking */
channel.mIgain += (gain_new - channel.mIgain) >> 2;
else
channel.mIgain += (gain_new - channel.mIgain) / 20;
channel.mSilenceCounter = 0;
}
else /* silence */
{
channel.mSilenceCounter++;
/* silence > 2 seconds: reduce gain */
if ((channel.mIgain > 65536) && (channel.mSilenceCounter >= 20))
channel.mIgain = (channel.mIgain * 62259) >> 16;
}
channel.mCounter = 0;
channel.mSampleMax = 1;
}
pcm[sampleIndex] = (short)((pcm[sampleIndex] * channel.mIgain) >> 16);
/* update the max */
channel.mSampleMax = (unsigned int)sample;
}
channel.mCounter ++;
/* Will we get an overflow with the current gain factor? */
if (((sample * channel.mIgain) >> 16) > channel.mIpeak)
{
/* Yes: Calculate new gain. */
channel.mIgain = ((channel.mIpeak / channel.mSampleMax) * 62259) >> 16;
channel.mSilenceCounter = 0;
pcm[sampleIndex] = (short) ((pcm[sampleIndex] * channel.mIgain) >> 16);
continue;
}
/* Calculate new gain factor 10x per second */
if (channel.mCounter >= AUDIO_SAMPLERATE / 10)
{
if (channel.mSampleMax > AUDIO_SAMPLERATE / 10) /* speaking? */
{
gain_new = ((channel.mIpeak / channel.mSampleMax) * 62259) >> 16;
if (channel.mSilenceCounter > 40) /* pause -> speaking */
channel.mIgain += (gain_new - channel.mIgain) >> 2;
else
channel.mIgain += (gain_new - channel.mIgain) / 20;
channel.mSilenceCounter = 0;
}
else /* silence */
{
channel.mSilenceCounter++;
/* silence > 2 seconds: reduce gain */
if ((channel.mIgain > 65536) && (channel.mSilenceCounter >= 20))
channel.mIgain = (channel.mIgain * 62259) >> 16;
}
channel.mCounter = 0;
channel.mSampleMax = 1;
}
pcm[sampleIndex] = (short) ((pcm[sampleIndex] * channel.mIgain) >> 16);
}
}
// --- AecFilter ---
#ifdef USE_SPEEX_AEC
#include "speex/speex_echo.h"
# include "speex/speex_echo.h"
#include "Audio_Interface.h"
#if !defined(TARGET_WIN)
#include <alloca.h>
# include <alloca.h>
#endif
#endif
#ifdef USE_WEBRTC_AEC
#include "aec/echo_cancellation.h"
# include "aec/echo_cancellation.h"
#endif
#ifdef USE_WEBRTC_AEC
static void CheckWRACode(unsigned errorcode)
{
if (errorcode)
throw Exception(ERR_WEBRTC, errorcode);
if (errorcode)
throw Exception(ERR_WEBRTC, errorcode);
}
#endif
AecFilter::AecFilter(int tailTime, int frameTime, int rate) : mCtx(nullptr), mFrameTime(frameTime), mRate(rate)
AecFilter::AecFilter(int tailTime, int frameTime, int rate)
:mCtx(nullptr), mFrameTime(frameTime), mRate(rate)
{
#ifdef USE_SPEEX_AEC
if (AUDIO_CHANNELS == 2)
mCtx = speex_echo_state_init_mc(frameTime * (mRate / 1000), tailTime * (mRate / 1000), AUDIO_CHANNELS,
AUDIO_CHANNELS);
else
mCtx = speex_echo_state_init(frameTime * (mRate / 1000), tailTime * (mRate / 1000));
int tmp = rate;
speex_echo_ctl((SpeexEchoState*)mCtx, SPEEX_ECHO_SET_SAMPLING_RATE, &tmp);
if (AUDIO_CHANNELS == 2)
mCtx = speex_echo_state_init_mc(frameTime * (mRate / 1000), tailTime * (mRate / 1000), AUDIO_CHANNELS, AUDIO_CHANNELS );
else
mCtx = speex_echo_state_init(frameTime * (mRate / 1000), tailTime * (mRate / 1000));
int tmp = rate;
speex_echo_ctl((SpeexEchoState*)mCtx, SPEEX_ECHO_SET_SAMPLING_RATE, &tmp);
#endif
#ifdef USE_WEBRTC_AEC
CheckWRACode(WebRtcAec_Create(&mCtx));
CheckWRACode(WebRtcAec_Init(mCtx, rate, rate));
CheckWRACode(WebRtcAec_Create(&mCtx));
CheckWRACode(WebRtcAec_Init(mCtx, rate, rate));
#endif
}
AecFilter::~AecFilter()
{
#ifdef USE_SPEEX_AEC
if (mCtx)
{
// speex_echo_state_destroy((SpeexEchoState*)mCtx);
mCtx = nullptr;
}
if (mCtx)
{
//speex_echo_state_destroy((SpeexEchoState*)mCtx);
mCtx = nullptr;
}
#endif
#ifdef USE_WEBRTC_AEC
CheckWRACode(WebRtcAec_Free(mCtx));
mCtx = NULL;
CheckWRACode(WebRtcAec_Free(mCtx));
mCtx = NULL;
#endif
}
void AecFilter::fromMic(void* data)
void AecFilter::fromMic(void *data)
{
#ifdef USE_SPEEX_AEC
short* output = (short*)alloca(Format().sizeFromTime(AUDIO_MIC_BUFFER_LENGTH));
speex_echo_capture((SpeexEchoState*)mCtx, (short*)data, (short*)output);
memmove(data, output, AUDIO_MIC_BUFFER_SIZE);
short* output = (short*)alloca(Format().sizeFromTime(AUDIO_MIC_BUFFER_LENGTH));
speex_echo_capture((SpeexEchoState*)mCtx, (short*)data, (short*)output);
memmove(data, output, AUDIO_MIC_BUFFER_SIZE);
#endif
#ifdef USE_WEBRTC_AEC
short* inputframe = (short*)ALLOCA(framesize);
memcpy(inputframe, (char*)data + framesize * i, framesize);
CheckWRACode(WebRtcAec_Process(mCtx, (short*)inputframe, NULL, (short*)data + framesize / 2 * i, NULL,
mFrameTime * mRate / 1000, 0, 0));
memcpy(inputframe, (char*)data+framesize*i, framesize);
CheckWRACode(WebRtcAec_Process(mCtx, (short*)inputframe, NULL, (short*)data+framesize/2*i, NULL, mFrameTime * mRate / 1000, 0,0));
#endif
}
void AecFilter::toSpeaker(void* data)
void AecFilter::toSpeaker(void *data)
{
#ifdef USE_SPEEX_AEC
speex_echo_playback((SpeexEchoState*)mCtx, (short*)data);
speex_echo_playback((SpeexEchoState*)mCtx, (short*)data);
#endif
#ifdef USE_WEBRTC_AEC
CheckWRACode(WebRtcAec_BufferFarend(mCtx, (short*)data, length / 2 / AUDIO_CHANNELS));
CheckWRACode(WebRtcAec_BufferFarend(mCtx, (short*)data, length / 2 / AUDIO_CHANNELS));
#endif
}
int AecFilter::frametime()
{
return mFrameTime;
return mFrameTime;
}
DenoiseFilter::DenoiseFilter(int rate) : mRate(rate)
DenoiseFilter::DenoiseFilter(int rate)
:mRate(rate)
{
mCtx = speex_preprocess_state_init(mRate / 100, mRate);
mCtx = speex_preprocess_state_init(mRate/100, mRate);
}
DenoiseFilter::~DenoiseFilter()
{
if (mCtx)
speex_preprocess_state_destroy((SpeexPreprocessState*)mCtx);
if (mCtx)
speex_preprocess_state_destroy((SpeexPreprocessState*)mCtx);
}
void DenoiseFilter::fromMic(void* data, int timelength)
{
assert(timelength % 10 == 0);
assert(timelength % 10 == 0);
// Process by 10-ms blocks
spx_int16_t* in = (spx_int16_t*)data;
// Process by 10-ms blocks
spx_int16_t* in = (spx_int16_t*)data;
for (int blockIndex = 0; blockIndex < timelength / 10; blockIndex++)
{
spx_int16_t* block = in + blockIndex * (mRate / 100) * AUDIO_CHANNELS;
speex_preprocess_run((SpeexPreprocessState*)mCtx, block);
}
for (int blockIndex=0; blockIndex<timelength/10; blockIndex++)
{
spx_int16_t* block = in + blockIndex * (mRate / 100) * AUDIO_CHANNELS;
speex_preprocess_run((SpeexPreprocessState*)mCtx, block);
}
}
int DenoiseFilter::rate()
{
return mRate;
return mRate;
}
src/engine/audio/Audio_Quality.h
+33 -34
View File
@@ -5,66 +5,65 @@
#ifndef __AUDIO_QUALITY_H
#define __AUDIO_QUALITY_H
#include "../engine_config.h"
#include "../config.h"
#include "../helper/HL_Sync.h"
#include <vector>
namespace Audio
{
class AgcFilter
{
protected:
class AgcFilter
{
protected:
struct Channel
{
unsigned int mSampleMax;
int mCounter;
long mIgain;
int mIpeak;
int mSilenceCounter;
unsigned int mSampleMax;
int mCounter;
long mIgain;
int mIpeak;
int mSilenceCounter;
};
std::vector<Channel> mChannelList;
void processChannel(short* pcm, int nrOfSamples, int channelIndex);
public:
void processChannel(short* pcm, int nrOfSamples, int channelIndex);
public:
AgcFilter(int channels);
~AgcFilter();
void process(void* pcm, int length);
};
void process(void* pcm, int length);
};
class AecFilter
{
public:
class AecFilter
{
public:
AecFilter(int tailTime, int frameTime, int rate);
~AecFilter();
// These methods accept input block with timelength "frameTime" used in constructor.
void toSpeaker(void* data);
void fromMic(void* data);
int frametime();
int frametime();
protected:
void* mCtx; /// The echo canceller context's pointer.
Mutex mGuard; /// Mutex to protect this instance.
int mFrameTime; /// Duration of single audio frame (in milliseconds)
int mRate;
};
protected:
void* mCtx; /// The echo canceller context's pointer.
Mutex mGuard; /// Mutex to protect this instance.
int mFrameTime; /// Duration of single audio frame (in milliseconds)
int mRate;
};
class DenoiseFilter
{
public:
class DenoiseFilter
{
public:
DenoiseFilter(int rate);
~DenoiseFilter();
void fromMic(void* data, int timelength);
int rate();
int rate();
protected:
Mutex mGuard; /// Mutex to protect this instance.
void* mCtx; /// The denoiser context pointer.
int mRate; /// Duration of single audio frame (in milliseconds)
};
protected:
Mutex mGuard; /// Mutex to protect this instance.
void* mCtx; /// The denoiser context pointer.
int mRate; /// Duration of single audio frame (in milliseconds)
};
} // namespace Audio
}
#endif
src/engine/audio/Audio_Resampler.cpp
+58 -54
View File
@@ -3,7 +3,7 @@
* 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/. */
#include "../engine_config.h"
#include "../config.h"
#include "Audio_Resampler.h"
#include <stdlib.h>
#include <assert.h>
@@ -17,7 +17,10 @@ namespace Audio
{
SpeexResampler::SpeexResampler() {}
SpeexResampler::SpeexResampler()
:mContext(NULL), mErrorCode(0), mSourceRate(0), mDestRate(0), mLastSample(0)
{
}
void SpeexResampler::start(int channels, int sourceRate, int destRate)
{
@@ -34,8 +37,8 @@ void SpeexResampler::start(int channels, int sourceRate, int destRate)
if (sourceRate != destRate)
{
// Defer context creation until first request
// mContext = speex_resampler_init(channels, sourceRate, destRate, AUDIO_RESAMPLER_QUALITY, &mErrorCode);
// assert(mContext != NULL);
//mContext = speex_resampler_init(channels, sourceRate, destRate, AUDIO_RESAMPLER_QUALITY, &mErrorCode);
//assert(mContext != NULL);
}
}
@@ -48,35 +51,28 @@ void SpeexResampler::stop()
}
}
bool SpeexResampler::isOpened() const
{
return mContext != nullptr;
}
SpeexResampler::~SpeexResampler()
{
stop();
}
size_t SpeexResampler::processBuffer(const void* src, size_t sourceLength, size_t& sourceProcessed, void* dest,
size_t destCapacity)
size_t SpeexResampler::processBuffer(const void* src, size_t sourceLength, size_t& sourceProcessed,
void* dest, size_t destCapacity)
{
assert(mSourceRate != 0 && mDestRate != 0);
if (mDestRate == mSourceRate)
{
// Pass-through, but never write past the caller's buffer: clamp to its
// capacity instead of trusting sourceLength (which is caller/file driven).
assert(destCapacity >= sourceLength);
size_t copied = std::min(sourceLength, destCapacity);
memcpy(dest, src, copied);
sourceProcessed = copied;
return copied;
memcpy(dest, src, sourceLength);
sourceProcessed = sourceLength;
return sourceLength;
}
if (!mContext)
{
mContext = speex_resampler_init(mChannels, mSourceRate, mDestRate, AUDIO_RESAMPLER_QUALITY, &mErrorCode);
mContext = speex_resampler_init(mChannels, mSourceRate, mDestRate,
AUDIO_RESAMPLER_QUALITY, &mErrorCode);
if (!mContext)
return 0;
}
@@ -101,9 +97,11 @@ size_t SpeexResampler::processBuffer(const void* src, size_t sourceLength, size_
unsigned inLen = sourceLength / (sizeof(short) * mChannels);
outLen /= sizeof(short) * mChannels;
assert(mContext != NULL);
spx_uint32_t in_len = static_cast<spx_uint32_t>(inLen), out_len = static_cast<spx_uint32_t>(outLen);
spx_uint32_t in_len = static_cast<spx_uint32_t>(inLen),
out_len = static_cast<spx_uint32_t>(outLen);
int speexCode = speex_resampler_process_interleaved_int((SpeexResamplerState*)mContext, (spx_int16_t*)src, &in_len,
int speexCode = speex_resampler_process_interleaved_int((SpeexResamplerState *)mContext,
(spx_int16_t*)src, &in_len,
(spx_int16_t*)dest, &out_len);
assert(speexCode == RESAMPLER_ERR_SUCCESS);
@@ -115,25 +113,24 @@ size_t SpeexResampler::processBuffer(const void* src, size_t sourceLength, size_
return outLen * sizeof(short) * mChannels;
}
int SpeexResampler::sourceRate() const
int SpeexResampler::sourceRate()
{
return mSourceRate;
}
int SpeexResampler::destRate() const
int SpeexResampler::destRate()
{
return mDestRate;
}
size_t SpeexResampler::getDestLength(size_t sourceLen) const
size_t SpeexResampler::getDestLength(size_t sourceLen)
{
return size_t(sourceLen * (float(mDestRate) / mSourceRate) + 0.5f);
return size_t(sourceLen * (float(mDestRate) / mSourceRate) + 0.5f) / 2 * 2;
}
size_t SpeexResampler::getSourceLength(size_t destLen) const
size_t SpeexResampler::getSourceLength(size_t destLen)
{
// Here we want to get 'destLen' number of samples
return size_t(destLen * (float(mSourceRate) / mDestRate) + 0.5f);
return size_t(destLen * (float(mSourceRate) / mDestRate) + 0.5f) / 2 * 2;
}
// Returns instance + speex resampler size in bytes
@@ -143,27 +140,27 @@ size_t SpeexResampler::getSize() const
}
// -------------------------- ChannelConverter --------------------
int ChannelConverter::stereoToMono(const void* source, int sourceLength, void* dest, int destLength)
int ChannelConverter::stereoToMono(const void *source, int sourceLength, void *dest, int destLength)
{
assert(destLength == sourceLength / 2);
const short* input = (const short*)source;
short* output = (short*)dest;
for (int sampleIndex = 0; sampleIndex < destLength / 2; sampleIndex++)
short* output = (short*)dest;
for (int sampleIndex = 0; sampleIndex < destLength/2; sampleIndex++)
{
output[sampleIndex] = (input[sampleIndex * 2] + input[sampleIndex * 2 + 1]) >> 1;
output[sampleIndex] = (input[sampleIndex*2] + input[sampleIndex*2+1]) >> 1;
}
return sourceLength / 2;
}
int ChannelConverter::monoToStereo(const void* source, int sourceLength, void* dest, int destLength)
int ChannelConverter::monoToStereo(const void *source, int sourceLength, void *dest, int destLength)
{
assert(destLength == sourceLength * 2);
assert (destLength == sourceLength * 2);
const short* input = (const short*)source;
short* output = (short*)dest;
short* output = (short*)dest;
// Convert starting from the end of buffer to allow inplace conversion
for (int sampleIndex = sourceLength / 2 - 1; sampleIndex >= 0; sampleIndex--)
for (int sampleIndex = sourceLength/2 - 1; sampleIndex >= 0; sampleIndex--)
{
output[2 * sampleIndex] = output[2 * sampleIndex + 1] = input[sampleIndex];
output[2*sampleIndex] = output[2*sampleIndex+1] = input[sampleIndex];
}
return sourceLength * 2;
}
@@ -180,14 +177,13 @@ Resampler48kTo16k::~Resampler48kTo16k()
WebRtcSpl_ResetResample48khzTo16khz(&mContext);
}
int Resampler48kTo16k::process(const void* source, int sourceLen, void* dest, int destLen)
int Resampler48kTo16k::process(const void *source, int sourceLen, void *dest, int destLen)
{
const short* input = (const short*)source;
int inputLen = sourceLen / 2;
short* output = (short*)dest; // int outputCapacity = destLen / 2;
const short* input = (const short*)source; int inputLen = sourceLen / 2;
short* output = (short*)dest; //int outputCapacity = destLen / 2;
assert(inputLen % 480 == 0);
int frames = inputLen / 480;
for (int i = 0; i < frames; i++)
for (int i=0; i<frames; i++)
WebRtcSpl_Resample48khzTo16khz(input + i * 480, output + i * 160, &mContext, mTemp);
return sourceLen / 3;
@@ -204,14 +200,13 @@ Resampler16kto48k::~Resampler16kto48k()
WebRtcSpl_ResetResample16khzTo48khz(&mContext);
}
int Resampler16kto48k::process(const void* source, int sourceLen, void* dest, int destLen)
int Resampler16kto48k::process(const void *source, int sourceLen, void *dest, int destLen)
{
const WebRtc_Word16* input = (const WebRtc_Word16*)source;
int inputLen = sourceLen / 2;
WebRtc_Word16* output = (WebRtc_Word16*)dest; // int outputCapacity = destLen / 2;
const WebRtc_Word16* input = (const WebRtc_Word16*)source; int inputLen = sourceLen / 2;
WebRtc_Word16* output = (WebRtc_Word16*)dest; //int outputCapacity = destLen / 2;
assert(inputLen % 160 == 0);
int frames = inputLen / 160;
for (int i = 0; i < frames; i++)
for (int i=0; i<frames; i++)
WebRtcSpl_Resample16khzTo48khz(input + i * 160, output + i * 480, &mContext, mTemp);
return sourceLen * 3;
@@ -220,12 +215,18 @@ int Resampler16kto48k::process(const void* source, int sourceLen, void* dest, in
#endif
// ---------------- UniversalResampler -------------------
UniversalResampler::UniversalResampler() {}
UniversalResampler::UniversalResampler()
{
UniversalResampler::~UniversalResampler() {}
}
size_t UniversalResampler::resample(int sourceRate, const void* sourceBuffer, size_t sourceLength,
size_t& sourceProcessed, int destRate, void* destBuffer, size_t destCapacity)
UniversalResampler::~UniversalResampler()
{
}
size_t UniversalResampler::resample(int sourceRate, const void *sourceBuffer, size_t sourceLength,
size_t& sourceProcessed, int destRate, void *destBuffer, size_t destCapacity)
{
assert(destBuffer && sourceBuffer);
size_t result;
@@ -244,7 +245,10 @@ size_t UniversalResampler::resample(int sourceRate, const void* sourceBuffer, si
return result;
}
void UniversalResampler::preload() {}
void UniversalResampler::preload()
{
}
size_t UniversalResampler::getDestLength(int sourceRate, int destRate, size_t sourceLength)
{
@@ -266,10 +270,10 @@ PResampler UniversalResampler::findResampler(int sourceRate, int destRate)
{
assert(sourceRate != destRate);
ResamplerMap::iterator resamplerIter = mResamplerMap.find(RatePair(sourceRate, destRate));
PResampler r;
PResampler r;
if (resamplerIter == mResamplerMap.end())
{
r = std::make_shared<Resampler>();
r = PResampler(new Resampler());
r->start(AUDIO_CHANNELS, sourceRate, destRate);
mResamplerMap[RatePair(sourceRate, destRate)] = r;
}
@@ -278,4 +282,4 @@ PResampler UniversalResampler::findResampler(int sourceRate, int destRate)
return r;
}
} // namespace Audio
} // end of namespace
src/engine/audio/Audio_Resampler.h
+73 -74
View File
@@ -7,7 +7,7 @@
#define __AUDIO_RESAMPLER_H
#ifdef USE_WEBRTC_RESAMPLER
#include "signal_processing_library/signal_processing_library.h"
# include "signal_processing_library/signal_processing_library.h"
#endif
#include <vector>
@@ -16,90 +16,89 @@
namespace Audio
{
class SpeexResampler
{
public:
SpeexResampler();
~SpeexResampler();
class SpeexResampler
{
public:
SpeexResampler();
~SpeexResampler();
void start(int channels, int sourceRate, int destRate);
void stop();
bool isOpened() const;
void start(int channels, int sourceRate, int destRate);
void stop();
size_t processBuffer(const void* source, size_t sourceLength, size_t& sourceProcessed,
void* dest, size_t destCapacity);
int sourceRate();
int destRate();
size_t getDestLength(size_t sourceLen);
size_t getSourceLength(size_t destLen);
size_t processBuffer(const void* source, size_t sourceLength, size_t& sourceProcessed, void* dest,
size_t destCapacity);
int sourceRate() const;
int destRate() const;
size_t getDestLength(size_t sourceLen) const;
size_t getSourceLength(size_t destLen) const;
// Returns instance + speex encoder size in bytes
size_t getSize() const;
// Returns instance + speex encoder size in bytes
size_t getSize() const;
protected:
void* mContext;
int mErrorCode;
int mSourceRate,
mDestRate,
mChannels;
short mLastSample;
};
protected:
void* mContext = nullptr;
int mErrorCode = 0;
int mSourceRate = 0, mDestRate = 0, mChannels = 0;
short mLastSample = 0;
};
typedef SpeexResampler Resampler;
typedef std::shared_ptr<Resampler> PResampler;
typedef SpeexResampler Resampler;
typedef std::shared_ptr<Resampler> PResampler;
class ChannelConverter
{
public:
static int stereoToMono(const void* source, int sourceLength, void* dest, int destLength);
static int monoToStereo(const void* source, int sourceLength, void* dest, int destLength);
};
class ChannelConverter
{
public:
static int stereoToMono(const void* source, int sourceLength, void* dest, int destLength);
static int monoToStereo(const void* source, int sourceLength, void* dest, int destLength);
};
// Operates with AUDIO_CHANNELS number of channels
class UniversalResampler
{
public:
UniversalResampler();
~UniversalResampler();
// Operates with AUDIO_CHANNELS number of channels
class UniversalResampler
{
public:
UniversalResampler();
~UniversalResampler();
size_t resample(int sourceRate, const void* sourceBuffer, size_t sourceLength, size_t& sourceProcessed,
int destRate, void* destBuffer, size_t destCapacity);
size_t getDestLength(int sourceRate, int destRate, size_t sourceLength);
size_t getSourceLength(int sourceRate, int destRate, size_t destLength);
size_t resample(int sourceRate, const void* sourceBuffer, size_t sourceLength, size_t& sourceProcessed,
int destRate, void* destBuffer, size_t destCapacity);
size_t getDestLength(int sourceRate, int destRate, size_t sourceLength);
size_t getSourceLength(int sourceRate, int destRate, size_t destLength);
protected:
typedef std::pair<int, int> RatePair;
typedef std::map<RatePair, PResampler> ResamplerMap;
ResamplerMap mResamplerMap;
PResampler findResampler(int sourceRate, int destRate);
protected:
typedef std::pair<int, int> RatePair;
typedef std::map<RatePair, PResampler> ResamplerMap;
ResamplerMap mResamplerMap;
PResampler findResampler(int sourceRate, int destRate);
void preload();
};
void preload();
};
#ifdef USE_WEBRTC_RESAMPLER
// n*10 milliseconds buffers required!
class Resampler48kTo16k
{
public:
Resampler48kTo16k();
~Resampler48kTo16k();
int process(const void* source, int sourceLen, void* dest, int destLen);
protected:
WebRtc_Word32 mTemp[496];
WebRtcSpl_State48khzTo16khz mContext;
};
#ifdef USE_WEBRTC_RESAMPLER
// n*10 milliseconds buffers required!
class Resampler48kTo16k
{
public:
Resampler48kTo16k();
~Resampler48kTo16k();
int process(const void* source, int sourceLen, void* dest, int destLen);
class Resampler16kto48k
{
public:
Resampler16kto48k();
~Resampler16kto48k();
int process(const void* source, int sourceLen, void* dest, int destLen);
protected:
WebRtc_Word32 mTemp[496];
WebRtcSpl_State48khzTo16khz mContext;
};
class Resampler16kto48k
{
public:
Resampler16kto48k();
~Resampler16kto48k();
int process(const void* source, int sourceLen, void* dest, int destLen);
protected:
WebRtc_Word32 mTemp[336];
WebRtcSpl_State16khzTo48khz mContext;
};
#endif
} // namespace Audio
protected:
WebRtc_Word32 mTemp[336];
WebRtcSpl_State16khzTo48khz mContext;
};
#endif
} // end of namespace
#endif
src/engine/audio/Audio_WavFile.cpp
+259 -297
View File
@@ -7,426 +7,388 @@
#include "helper/HL_Exception.h"
#include "helper/HL_String.h"
#include "helper/HL_Log.h"
#include "../engine_config.h"
#include "../config.h"
#include <memory.h>
#include <assert.h>
#ifndef WORD
#define WORD unsigned short
# define WORD unsigned short
#endif
#ifndef DWORD
#define DWORD unsigned int
# define DWORD unsigned int
#endif
typedef struct
{
WORD wFormatTag;
WORD nChannels;
DWORD nSamplesPerSec;
DWORD nAvgBytesPerSec;
WORD nBlockAlign;
WORD wBitsPerSample;
WORD cbSize;
} WaveFormatEx;
typedef struct {
WORD wFormatTag;
WORD nChannels;
DWORD nSamplesPerSec;
DWORD nAvgBytesPerSec;
WORD nBlockAlign;
WORD wBitsPerSample;
WORD cbSize;
}
WaveFormatEx;
#define WAVE_FORMAT_PCM 1
#define LOG_SUBSYSTEM "audio"
#define LOG_SUBSYSTEM "WavFileReader"
#define LOCK std::unique_lock<std::recursive_mutex> lock(mFileMtx);
using namespace Audio;
// ---------------------- WavFileReader -------------------------
WavFileReader::WavFileReader() : mSamplerate(0), mLastError(0), mChannels(0), mBits(0), mDataLength(0)
WavFileReader::WavFileReader()
:mHandle(nullptr), mRate(0), mLastError(0)
{
mDataOffset = 0;
mDataOffset = 0;
}
WavFileReader::~WavFileReader() {}
WavFileReader::~WavFileReader()
{
}
#define THROW_READERROR throw Exception(ERR_WAVFILE_FAILED);
#define THROW_READERROR throw Exception(ERR_WAVFILE_FAILED);
std::string WavFileReader::readChunk()
{
char name[5] = {0};
readBuffer(name, 4);
char name[5];
if (fread(name, 1, 4, mHandle) != 4)
THROW_READERROR;
std::string result = name;
uint32_t size = 0;
readBuffer(&size, 4);
name[4] = 0;
std::string result = name;
unsigned size;
if (fread(&size, 4, 1, mHandle) != 1)
THROW_READERROR;
if (result == "data")
mDataLength = size;
else
// Skip the chunk body; RIFF chunks are word-aligned, so odd sizes carry a pad byte
mInput->seekg(std::streamoff(size + (size & 1)), std::ios_base::cur);
if (result == "fact")
fread(&mDataLength, 4, 1, mHandle);
else
if (result != "data")
fseek(mHandle, size, SEEK_CUR);
else
mDataLength = size;
return result;
return result;
}
void WavFileReader::readBuffer(void* buffer, size_t sz)
bool WavFileReader::open(const std::tstring& filename)
{
auto p = mInput->tellg();
mInput->read(reinterpret_cast<char*>(buffer), sz);
if (mInput->tellg() - p != sz)
throw Exception(ERR_WAVFILE_FAILED);
}
size_t WavFileReader::tryReadBuffer(void* buffer, size_t sz)
{
auto p = mInput->tellg();
mInput->read(reinterpret_cast<char*>(buffer), sz);
return mInput->tellg() - p;
}
bool WavFileReader::open(const std::filesystem::path& p)
{
LOCK;
try
LOCK;
try
{
#ifdef WIN32
mHandle = _wfopen(filename.c_str(), L"rb");
#else
mHandle = fopen(StringHelper::makeUtf8(filename).c_str(), "rb");
#endif
if (NULL == mHandle)
{
mPath = p;
mInput = std::make_unique<std::ifstream>(p, std::ios::binary | std::ios::in);
if (!mInput->is_open())
{
#if defined(TARGET_ANDROID) || defined(TARGET_LINUX) || defined(TARGET_OSX)
mLastError = errno;
mLastError = errno;
#endif
#if defined(TARGET_WIN)
mLastError = GetLastError();
mLastError = GetLastError();
#endif
return false;
}
mLastError = 0;
// Read the .WAV header
char riff[4];
readBuffer(riff, sizeof riff);
if (!(riff[0] == 'R' && riff[1] == 'I' && riff[2] == 'F' && riff[3] == 'F'))
THROW_READERROR;
// Read the file size
uint32_t filesize = 0;
readBuffer(&filesize, sizeof(filesize));
char wavefmt[9] = {0};
readBuffer(wavefmt, 8);
if (strcmp(wavefmt, "WAVEfmt ") != 0)
THROW_READERROR;
uint32_t fmtSize = 0;
readBuffer(&fmtSize, sizeof(fmtSize));
auto fmtStart = mInput->tellg();
uint16_t formattag = 0;
readBuffer(&formattag, sizeof(formattag));
if (formattag != 1 /*WAVE_FORMAT_PCM*/)
THROW_READERROR;
mChannels = 0;
readBuffer(&mChannels, sizeof(mChannels));
mSamplerate = 0;
readBuffer(&mSamplerate, sizeof(mSamplerate));
uint32_t avgbytespersec = 0;
readBuffer(&avgbytespersec, sizeof(avgbytespersec));
uint16_t blockalign = 0;
readBuffer(&blockalign, sizeof(blockalign));
mBits = 0;
readBuffer(&mBits, sizeof(mBits));
// Only 16-bit PCM is supported: the read path feeds the data
// directly into a 16-bit resampler.
if (mBits != 16)
THROW_READERROR;
// The read path is mono-only: it divides byte counts by AUDIO_CHANNELS
// and starts the resampler with AUDIO_CHANNELS. Reject anything else -
// a multi-channel file would make read() copy more source bytes than the
// caller's (mono-sized) output buffer can hold. Also reject a zero rate,
// which would divide by zero in readRaw() / poison the resampler ratio.
if (mChannels != AUDIO_CHANNELS || mSamplerate == 0)
THROW_READERROR;
// Look for the chunk 'data'
mInput->seekg(fmtStart + std::streampos(fmtSize));
mDataLength = 0;
while (readChunk() != "data")
;
mDataOffset = mInput->tellg();
mResampler.start(AUDIO_CHANNELS, mSamplerate, AUDIO_SAMPLERATE);
return false;
}
catch (...)
{
mInput.reset();
mLastError = static_cast<unsigned>(-1);
}
return isOpened();
mLastError = 0;
// Read the .WAV header
char riff[4];
if (fread(riff, 4, 1, mHandle) < 1)
THROW_READERROR;
if (!(riff[0] == 'R' && riff[1] == 'I' && riff[2] == 'F' && riff[3] == 'F'))
THROW_READERROR;
// Read the file size
unsigned int filesize = 0;
if (fread(&filesize, 4, 1, mHandle) < 1)
THROW_READERROR;
char wavefmt[9];
if (fread(wavefmt, 8, 1, mHandle) < 1)
THROW_READERROR;
wavefmt[8] = 0;
if (strcmp(wavefmt, "WAVEfmt ") != 0)
THROW_READERROR;
unsigned fmtSize = 0;
if (fread(&fmtSize, 4, 1, mHandle) < 1)
THROW_READERROR;
unsigned fmtStart = ftell(mHandle);
unsigned short formattag = 0;
if (fread(&formattag, 2, 1, mHandle) < 1)
THROW_READERROR;
if (formattag != 1/*WAVE_FORMAT_PCM*/)
THROW_READERROR;
mChannels = 0;
if (fread(&mChannels, 2, 1, mHandle) < 1)
THROW_READERROR;
mRate = 0;
if (fread(&mRate, 4, 1, mHandle) < 1)
THROW_READERROR;
unsigned int avgbytespersec = 0;
if (fread(&avgbytespersec, 4, 1, mHandle) < 1)
THROW_READERROR;
unsigned short blockalign = 0;
if (fread(&blockalign, 2, 1, mHandle) < 1)
THROW_READERROR;
mBits = 0;
if (fread(&mBits, 2, 1, mHandle) < 1)
THROW_READERROR;
if (mBits !=8 && mBits != 16)
THROW_READERROR;
// Read the "chunk"
fseek(mHandle, fmtStart + fmtSize, SEEK_SET);
//unsigned pos = ftell(mHandle);
mDataLength = 0;
while (readChunk() != "data")
;
mFileName = filename;
mDataOffset = ftell(mHandle);
mResampler.start(AUDIO_CHANNELS, mRate, AUDIO_SAMPLERATE);
}
catch(...)
{
fclose(mHandle); mHandle = nullptr;
mLastError = static_cast<unsigned>(-1);
}
return isOpened();
}
void WavFileReader::close()
{
LOCK;
mInput.reset();
LOCK;
if (nullptr != mHandle)
fclose(mHandle);
mHandle = nullptr;
}
int WavFileReader::samplerate() const
int WavFileReader::rate() const
{
return mSamplerate;
return mRate;
}
int WavFileReader::channels() const
unsigned WavFileReader::read(void* buffer, unsigned bytes)
{
return mChannels;
return read((short*)buffer, bytes / (AUDIO_CHANNELS * 2)) * AUDIO_CHANNELS * 2;
}
size_t WavFileReader::read(void* buffer, size_t bytes)
unsigned WavFileReader::read(short* buffer, unsigned samples)
{
return read((short*)buffer, bytes / (AUDIO_CHANNELS * 2)) * AUDIO_CHANNELS * 2;
}
LOCK;
size_t WavFileReader::readRaw(void* buffer, size_t bytes)
{
return readRaw((short*)buffer, bytes / channels() / sizeof(short)) * channels() * sizeof(short);
}
if (!mHandle)
return 0;
size_t WavFileReader::read(short* buffer, size_t samples)
{
LOCK;
// Get number of samples that must be read from source file
int requiredBytes = mResampler.getSourceLength(samples) * mChannels * mBits / 8;
void* temp = alloca(requiredBytes);
memset(temp, 0, requiredBytes);
if (!mInput)
return 0;
// Find required size of input buffer
if (mDataLength)
{
unsigned filePosition = ftell(mHandle);
// Get number of samples that must be read from source file
size_t requiredBytes = mResampler.getSourceLength(samples) * mChannels * mBits / 8;
bool useHeap = requiredBytes > sizeof mTempBuffer;
void* temp;
if (useHeap)
temp = malloc(requiredBytes);
else
temp = mTempBuffer;
// Check how much data we can read
unsigned fileAvailable = mDataLength + mDataOffset - filePosition;
requiredBytes = (int)fileAvailable < requiredBytes ? (int)fileAvailable : requiredBytes;
}
memset(temp, 0, requiredBytes);
/*int readSamples = */fread(temp, 1, requiredBytes, mHandle);// / mChannels / (mBits / 8);
size_t processedBytes = 0;
size_t result = mResampler.processBuffer(temp, requiredBytes, processedBytes,
buffer, samples * 2 * AUDIO_CHANNELS);
// Find required size of input buffer
if (mDataLength)
{
auto filePosition = mInput->tellg();
// Check how much data we can read
std::streamoff dataEnd = std::streamoff(mDataLength) + mDataOffset;
size_t fileAvailable = filePosition < dataEnd ? size_t(dataEnd - filePosition) : 0;
requiredBytes = fileAvailable < requiredBytes ? fileAvailable : requiredBytes;
}
size_t readBytes = tryReadBuffer(temp, requiredBytes);
size_t processedBytes = 0;
size_t result = mResampler.processBuffer(temp, readBytes, processedBytes, buffer, samples * 2 * AUDIO_CHANNELS);
if (useHeap)
free(temp);
return result / 2 / AUDIO_CHANNELS;
}
size_t WavFileReader::readRaw(short* buffer, size_t samples)
{
LOCK;
if (!mInput)
return 0;
// Get number of samples that must be read from source file
size_t requiredBytes = samples * channels() * sizeof(short);
// Find required size of input buffer
if (mDataLength)
{
auto filePosition = mInput->tellg();
// Check how much data we can read
std::streamoff dataEnd = std::streamoff(mDataLength) + mDataOffset;
size_t fileAvailable = filePosition < dataEnd ? size_t(dataEnd - filePosition) : 0;
requiredBytes = fileAvailable < requiredBytes ? fileAvailable : requiredBytes;
}
size_t readBytes = tryReadBuffer(buffer, requiredBytes);
return readBytes / channels() / sizeof(short);
return result / 2 / AUDIO_CHANNELS;
}
bool WavFileReader::isOpened()
{
LOCK;
if (!mInput)
return false;
return mInput->is_open();
LOCK;
return (mHandle != 0);
}
void WavFileReader::rewind()
{
LOCK;
if (mInput)
mInput->seekg(mDataOffset);
LOCK;
if (mHandle)
fseek(mHandle, mDataOffset, SEEK_SET);
}
std::filesystem::path WavFileReader::path() const
std::tstring WavFileReader::filename() const
{
LOCK;
return mPath;
LOCK;
return mFileName;
}
size_t WavFileReader::size() const
unsigned WavFileReader::size() const
{
LOCK;
return mDataLength;
LOCK;
return mDataLength;
}
unsigned WavFileReader::lastError() const
{
return mLastError;
return mLastError;
}
// ------------------------- WavFileWriter -------------------------
#define LOG_SUBSYTEM "WavFileWriter"
#define BITS_PER_CHANNEL 16
#define BITS_PER_CHANNEL 16
WavFileWriter::WavFileWriter() : mLengthOffset(0), mSamplerate(AUDIO_SAMPLERATE), mChannels(1), mWritten(0) {}
WavFileWriter::WavFileWriter()
:mHandle(nullptr), mLengthOffset(0), mRate(AUDIO_SAMPLERATE), mChannels(1), mWritten(0)
{
}
WavFileWriter::~WavFileWriter()
{
close();
close();
}
void WavFileWriter::checkWriteResult(int result)
{
if (result < 1)
throw Exception(ERR_WAVFILE_FAILED, errno);
if (result < 1)
throw Exception(ERR_WAVFILE_FAILED, errno);
}
void WavFileWriter::writeBuffer(const void* buffer, size_t sz)
bool WavFileWriter::open(const std::tstring& filename, int rate, int channels)
{
if (!mOutput)
return;
LOCK;
auto p = mOutput->tellp();
mOutput->write(reinterpret_cast<const char*>(buffer), sz);
if (mOutput->tellp() - p != sz)
throw Exception(ERR_WAVFILE_FAILED);
}
close();
bool WavFileWriter::open(const std::filesystem::path& p, int samplerate, int channels)
{
LOCK;
close();
mSamplerate = samplerate;
mChannels = channels;
mRate = rate;
mChannels = channels;
mOutput = std::make_unique<std::ofstream>(p, std::ios::binary | std::ios::trunc);
if (!mOutput->is_open())
{
int errorcode = errno;
ICELogError(<< "Failed to create .wav file: filename = " << p << " , error = " << errorcode);
mOutput.reset();
return false;
}
#ifdef WIN32
mHandle = _wfopen(filename.c_str(), L"wb");
#else
mHandle = fopen(StringHelper::makeUtf8(filename).c_str(), "wb");
#endif
if (nullptr == mHandle)
{
ICELogError(<< "Failed to create .wav file: filename = " << StringHelper::makeUtf8(filename) << " , error = " << errno);
return false;
}
// Write the .WAV header
const char* riff = "RIFF";
writeBuffer(riff, 4);
// Write the .WAV header
const char* riff = "RIFF";
checkWriteResult( fwrite(riff, 4, 1, mHandle) );
// Write the file size
uint32_t filesize = 0;
writeBuffer(&filesize, sizeof filesize);
// Write the file size
unsigned int filesize = 0;
checkWriteResult( fwrite(&filesize, 4, 1, mHandle) );
const char* wavefmt = "WAVEfmt ";
writeBuffer(wavefmt, 8);
const char* wavefmt = "WAVEfmt ";
checkWriteResult( fwrite(wavefmt, 8, 1, mHandle) );
// Set the format description
uint32_t dwFmtSize = 16; /*= 16L*/
;
writeBuffer(&dwFmtSize, sizeof(dwFmtSize));
// Set the format description
DWORD dwFmtSize = 16; /*= 16L*/;
checkWriteResult( fwrite(&dwFmtSize, sizeof(dwFmtSize), 1, mHandle) );
WaveFormatEx format;
format.wFormatTag = WAVE_FORMAT_PCM;
writeBuffer(&format.wFormatTag, sizeof(format.wFormatTag));
WaveFormatEx format;
format.wFormatTag = WAVE_FORMAT_PCM;
checkWriteResult( fwrite(&format.wFormatTag, sizeof(format.wFormatTag), 1, mHandle) );
format.nChannels = mChannels;
writeBuffer(&format.nChannels, sizeof(format.nChannels));
format.nChannels = mChannels;
checkWriteResult( fwrite(&format.nChannels, sizeof(format.nChannels), 1, mHandle) );
format.nSamplesPerSec = mSamplerate;
writeBuffer(&format.nSamplesPerSec, sizeof(format.nSamplesPerSec));
format.nSamplesPerSec = mRate;
checkWriteResult( fwrite(&format.nSamplesPerSec, sizeof(format.nSamplesPerSec), 1, mHandle) );
format.nAvgBytesPerSec = mSamplerate * 2 * mChannels;
writeBuffer(&format.nAvgBytesPerSec, sizeof(format.nAvgBytesPerSec));
format.nAvgBytesPerSec = mRate * 2 * mChannels;
checkWriteResult( fwrite(&format.nAvgBytesPerSec, sizeof(format.nAvgBytesPerSec), 1, mHandle) );
format.nBlockAlign = 2 * mChannels;
writeBuffer(&format.nBlockAlign, sizeof(format.nBlockAlign));
format.nBlockAlign = 2 * mChannels;
checkWriteResult( fwrite(&format.nBlockAlign, sizeof(format.nBlockAlign), 1, mHandle) );
format.wBitsPerSample = BITS_PER_CHANNEL;
writeBuffer(&format.wBitsPerSample, sizeof(format.wBitsPerSample));
format.wBitsPerSample = BITS_PER_CHANNEL;
checkWriteResult( fwrite(&format.wBitsPerSample, sizeof(format.wBitsPerSample), 1, mHandle) );
const char* data = "data";
writeBuffer(data, 4);
const char* data = "data";
checkWriteResult( fwrite(data, 4, 1, mHandle));
mPath = p;
mWritten = 0;
mFileName = filename;
mWritten = 0;
mLengthOffset = mOutput->tellp();
writeBuffer(&mWritten, sizeof mWritten);
mLengthOffset = ftell(mHandle);
checkWriteResult( fwrite(&mWritten, 4, 1, mHandle) );
return isOpened();
return isOpened();
}
void WavFileWriter::close()
{
LOCK;
mOutput.reset();
LOCK;
if (mHandle)
{
fclose(mHandle);
mHandle = nullptr;
}
}
size_t WavFileWriter::write(const void* buffer, size_t bytes)
{
LOCK;
LOCK;
if (!mOutput)
return 0;
if (!mHandle)
return 0;
// Seek the end of file - here new data will be written
mOutput->seekp(0, std::ios_base::end);
mWritten += bytes;
// Seek the end of file
fseek(mHandle, 0, SEEK_END);
mWritten += bytes;
// Write the data
writeBuffer(buffer, bytes);
// Write the data
fwrite(buffer, bytes, 1, mHandle);
// Write file length
mOutput->seekp(4, std::ios_base::beg);
uint32_t fl = mWritten + 36;
writeBuffer(&fl, sizeof(fl));
// Write file length
fseek(mHandle, 4, SEEK_SET);
int32_t fl = mWritten + 36;
fwrite(&fl, sizeof(fl), 1, mHandle);
// Write data length
mOutput->seekp(mLengthOffset, std::ios_base::beg);
writeBuffer(&mWritten, sizeof(mWritten));
// Write data length
fseek(mHandle, static_cast<long>(mLengthOffset), SEEK_SET);
checkWriteResult( fwrite(&mWritten, 4, 1, mHandle) );
return bytes;
return bytes;
}
bool WavFileWriter::isOpened() const
bool WavFileWriter::isOpened()
{
LOCK;
return mOutput && mOutput->is_open();
LOCK;
return (mHandle != nullptr);
}
std::filesystem::path WavFileWriter::path() const
std::tstring WavFileWriter::filename()
{
LOCK;
return mPath;
LOCK;
return mFileName;
}
src/engine/audio/Audio_WavFile.h
+47 -57
View File
@@ -12,85 +12,75 @@
#include <string>
#include <memory>
#include <mutex>
#include <filesystem>
#include <fstream>
namespace Audio
{
class WavFileReader
{
protected:
uint16_t mChannels = 0;
uint16_t mBits = 0;
int mSamplerate = 0;
std::filesystem::path mPath;
mutable std::recursive_mutex mFileMtx;
size_t mDataOffset = 0;
size_t mDataLength = 0;
Resampler mResampler;
unsigned mLastError = 0;
std::unique_ptr<std::ifstream> mInput;
uint8_t mTempBuffer[16384];
class WavFileReader
{
protected:
FILE* mHandle;
short mChannels;
short mBits;
int mRate;
std::tstring mFileName;
mutable std::recursive_mutex mFileMtx;
unsigned mDataOffset;
unsigned mDataLength;
Resampler mResampler;
unsigned mLastError;
std::string readChunk();
void readBuffer(void* buffer, size_t sz); // This raises an exception if sz bytes are not read
size_t tryReadBuffer(void* buffer, size_t sz); // This doesn't raise an exception
public:
std::string readChunk();
public:
WavFileReader();
~WavFileReader();
bool open(const std::filesystem::path& p);
void close();
bool isOpened();
void rewind();
int samplerate() const;
int channels() const;
bool open(const std::tstring& filename);
void close();
bool isOpened();
void rewind();
int rate() const;
// This method returns number of read bytes
size_t read(void* buffer, size_t bytes);
size_t readRaw(void* buffer, size_t bytes);
unsigned read(void* buffer, unsigned bytes);
// This method returns number of read samples
size_t read(short* buffer, size_t samples);
size_t readRaw(short* buffer, size_t samples);
unsigned read(short* buffer, unsigned samples);
std::tstring filename() const;
unsigned size() const;
std::filesystem::path path() const;
size_t size() const;
unsigned lastError() const;
};
unsigned lastError() const;
};
typedef std::shared_ptr<WavFileReader> PWavFileReader;
typedef std::shared_ptr<WavFileReader> PWavFileReader;
class WavFileWriter
{
protected:
FILE* mHandle; /// Handle of audio file.
std::tstring mFileName; /// Path to requested audio file.
std::recursive_mutex mFileMtx; /// Mutex to protect this instance.
int mWritten; /// Amount of written data (in bytes)
int mLengthOffset; /// Position of length field.
int mRate,
mChannels;
class WavFileWriter
{
protected:
std::unique_ptr<std::ofstream> mOutput; /// Handle of audio file.
std::filesystem::path mPath; /// Path to requested audio file.
mutable std::recursive_mutex mFileMtx; /// Mutex to protect this instance.
size_t mWritten = 0; /// Amount of written data (in bytes)
size_t mLengthOffset = 0; /// Position of length field.
int mSamplerate = 0, mChannels = 0;
void checkWriteResult(int result);
void checkWriteResult(int result);
void writeBuffer(const void* buffer, size_t sz);
public:
public:
WavFileWriter();
~WavFileWriter();
bool open(const std::filesystem::path& p, int samplerate, int channels);
void close();
bool isOpened() const;
size_t write(const void* buffer, size_t bytes);
std::filesystem::path path() const;
};
bool open(const std::tstring& filename, int rate, int channels);
void close();
bool isOpened();
size_t write(const void* buffer, size_t bytes);
std::tstring filename();
};
typedef std::shared_ptr<WavFileWriter> PWavFileWriter;
typedef std::shared_ptr<WavFileWriter> PWavFileWriter;
} // namespace Audio
}
#endif
src/engine/audio/Audio_Wmme.cpp
+334 -333
View File
@@ -15,540 +15,541 @@ using namespace Audio;
WmmeInputDevice::Buffer::Buffer()
{
// Do not use WAVEHDR allocated on stack!
mHeaderHandle = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE, sizeof WAVEHDR);
if (!mHeaderHandle)
throw Exception(ERR_WMME_FAILED, GetLastError());
mHeader = (WAVEHDR*)GlobalLock(mHeaderHandle);
// Do not use WAVEHDR allocated on stack!
mHeaderHandle = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE, sizeof WAVEHDR);
if (!mHeaderHandle)
throw Exception(ERR_WMME_FAILED, GetLastError());
mHeader = (WAVEHDR*)GlobalLock(mHeaderHandle);
mDataHandle = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE, AUDIO_MIC_BUFFER_SIZE);
if (!mDataHandle)
throw Exception(ERR_WMME_FAILED, GetLastError());
mData = GlobalLock(mDataHandle);
mDataHandle = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE, AUDIO_MIC_BUFFER_SIZE);
if (!mDataHandle)
throw Exception(ERR_WMME_FAILED, GetLastError());
mData = GlobalLock(mDataHandle);
memset(mHeader, 0, sizeof *mHeader);
mHeader->dwBufferLength = AUDIO_MIC_BUFFER_SIZE;
mHeader->dwFlags = 0;
mHeader->lpData = (LPSTR)mData;
memset(mHeader, 0, sizeof *mHeader);
mHeader->dwBufferLength = AUDIO_MIC_BUFFER_SIZE;
mHeader->dwFlags = 0;
mHeader->lpData = (LPSTR)mData;
}
WmmeInputDevice::Buffer::~Buffer()
{
if (mDataHandle)
{
GlobalUnlock(mDataHandle);
GlobalFree(mDataHandle);
}
if (mHeaderHandle)
{
GlobalUnlock(mHeaderHandle);
GlobalFree(mHeaderHandle);
}
if (mDataHandle)
{
GlobalUnlock(mDataHandle);
GlobalFree(mDataHandle);
}
if (mHeaderHandle)
{
GlobalUnlock(mHeaderHandle);
GlobalFree(mHeaderHandle);
}
}
bool WmmeInputDevice::Buffer::prepare(HWAVEIN device)
{
MMRESULT resCode = MMSYSERR_NOERROR;
mHeader->dwFlags = 0;
mHeader->dwBufferLength = AUDIO_MIC_BUFFER_SIZE;
mHeader->lpData = (LPSTR)mData;
MMRESULT resCode = MMSYSERR_NOERROR;
mHeader->dwFlags = 0;
mHeader->dwBufferLength = AUDIO_MIC_BUFFER_SIZE;
mHeader->lpData = (LPSTR)mData;
resCode = waveInPrepareHeader(device, mHeader, sizeof *mHeader);
// if (resCode != MMSYSERR_NOERROR)
// LogCritical("Audio", << "Failed to prepare source header. Error code " << resCode << ".");
resCode = waveInPrepareHeader(device, mHeader, sizeof *mHeader);
//if (resCode != MMSYSERR_NOERROR)
// LogCritical("Audio", << "Failed to prepare source header. Error code " << resCode << ".");
return resCode == MMSYSERR_NOERROR;
return resCode == MMSYSERR_NOERROR;
}
bool WmmeInputDevice::Buffer::unprepare(HWAVEIN device)
{
if (mHeader->dwFlags & WHDR_PREPARED)
{
MMRESULT resCode = waveInUnprepareHeader(device, mHeader, sizeof *mHeader);
// if (resCode != MMSYSERR_NOERROR)
// LogCritical("Audio", << "Failed to unprepare source header. Error code " << resCode << ".");
return resCode == MMSYSERR_NOERROR;
}
return true;
if (mHeader->dwFlags & WHDR_PREPARED)
{
MMRESULT resCode = waveInUnprepareHeader(device, mHeader, sizeof *mHeader);
//if (resCode != MMSYSERR_NOERROR)
// LogCritical("Audio", << "Failed to unprepare source header. Error code " << resCode << ".");
return resCode == MMSYSERR_NOERROR;
}
return true;
}
bool WmmeInputDevice::Buffer::isFinished()
{
return (mHeader->dwFlags & WHDR_DONE) != 0;
return (mHeader->dwFlags & WHDR_DONE) != 0;
}
bool WmmeInputDevice::Buffer::addToDevice(HWAVEIN device)
{
MMRESULT resCode = waveInAddBuffer(device, mHeader, sizeof(*mHeader));
// if (resCode != MMSYSERR_NOERROR)
// LogCritical("Audio", << "Failed to add buffer to source audio device. Error code is " << resCode << ".");
return resCode == MMSYSERR_NOERROR;
MMRESULT resCode = waveInAddBuffer(device, mHeader, sizeof(*mHeader));
//if (resCode != MMSYSERR_NOERROR)
// LogCritical("Audio", << "Failed to add buffer to source audio device. Error code is " << resCode << ".");
return resCode == MMSYSERR_NOERROR;
}
void* WmmeInputDevice::Buffer::data()
{
return mData;
return mData;
}
WmmeInputDevice::WmmeInputDevice(int deviceId)
: mDevHandle(NULL), mDoneSignal(INVALID_HANDLE_VALUE), mFakeMode(false), mBufferIndex(0), mDeviceIndex(deviceId),
mThreadHandle(0)
:mDevHandle(NULL), mDoneSignal(INVALID_HANDLE_VALUE), mFakeMode(false),
mBufferIndex(0), mDeviceIndex(deviceId), mThreadHandle(0)
{
mDoneSignal = ::CreateEvent(NULL, FALSE, FALSE, NULL);
mShutdownSignal = ::CreateEvent(NULL, FALSE, FALSE, NULL);
mRefCount = 0;
mDoneSignal = ::CreateEvent(NULL, FALSE, FALSE, NULL);
mShutdownSignal = ::CreateEvent(NULL, FALSE, FALSE, NULL);
mRefCount = 0;
}
WmmeInputDevice::~WmmeInputDevice()
{
close();
::CloseHandle(mDoneSignal);
::CloseHandle(mShutdownSignal);
close();
::CloseHandle(mDoneSignal);
::CloseHandle(mShutdownSignal);
}
bool WmmeInputDevice::fakeMode()
{
return mFakeMode;
return mFakeMode;
}
void CALLBACK WmmeInputDevice::callbackProc(HWAVEIN hwi, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1,
DWORD_PTR dwParam2)
void CALLBACK WmmeInputDevice::callbackProc(HWAVEIN hwi, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
WmmeInputDevice* impl;
switch (uMsg)
{
case WIM_DATA:
impl = (WmmeInputDevice*)dwInstance;
SetEvent(impl->mDoneSignal);
break;
WmmeInputDevice* impl;
switch(uMsg)
{
case WIM_DATA:
impl = (WmmeInputDevice*)dwInstance;
SetEvent(impl->mDoneSignal);
break;
case WIM_CLOSE:
break;
case WIM_CLOSE:
break;
case WIM_OPEN:
break;
}
case WIM_OPEN:
break;
}
}
void WmmeInputDevice::openDevice()
{
// Build WAVEFORMATEX structure
WAVEFORMATEX wfx;
memset(&wfx, 0, sizeof(wfx));
// Build WAVEFORMATEX structure
WAVEFORMATEX wfx;
memset(&wfx, 0, sizeof(wfx));
wfx.wFormatTag = WAVE_FORMAT_PCM;
wfx.nChannels = AUDIO_CHANNELS;
wfx.nSamplesPerSec = AUDIO_SAMPLERATE;
wfx.wBitsPerSample = 16;
wfx.cbSize = 0;
wfx.nBlockAlign = wfx.wBitsPerSample * wfx.nChannels / 8;
wfx.nAvgBytesPerSec = wfx.nBlockAlign * wfx.nSamplesPerSec;
wfx.wFormatTag = WAVE_FORMAT_PCM;
wfx.nChannels = AUDIO_CHANNELS;
wfx.nSamplesPerSec = AUDIO_SAMPLERATE;
wfx.wBitsPerSample = 16;
wfx.cbSize = 0;
wfx.nBlockAlign = wfx.wBitsPerSample * wfx.nChannels / 8;
wfx.nAvgBytesPerSec = wfx.nBlockAlign * wfx.nSamplesPerSec;
// Open wavein
// Open wavein
MMRESULT mmres =
waveInOpen(&mDevHandle, mDeviceIndex, &wfx, (DWORD_PTR)callbackProc, (DWORD_PTR)this, CALLBACK_FUNCTION);
if (mmres != MMSYSERR_NOERROR)
{
mFakeMode = true;
return;
}
else
mFakeMode = false;
MMRESULT mmres = waveInOpen(&mDevHandle, mDeviceIndex, &wfx, (DWORD_PTR)callbackProc, (DWORD_PTR)this, CALLBACK_FUNCTION);
if (mmres != MMSYSERR_NOERROR)
{
mFakeMode = true;
return;
}
else
mFakeMode = false;
// Create the buffers for running
mBufferIndex = 0;
for (int i = 0; i < AUDIO_MIC_BUFFER_COUNT; i++)
mBufferList[i].prepare(mDevHandle);
// Create the buffers for running
mBufferIndex = 0;
for (int i=0; i<AUDIO_MIC_BUFFER_COUNT; i++)
mBufferList[i].prepare(mDevHandle);
for (int i = 0; i < AUDIO_MIC_BUFFER_COUNT; i++)
mBufferList[i].addToDevice(mDevHandle);
for (int i=0; i<AUDIO_MIC_BUFFER_COUNT; i++)
mBufferList[i].addToDevice(mDevHandle);
/*mmres = */ waveInStart(mDevHandle);
/*mmres = */waveInStart(mDevHandle);
}
bool WmmeInputDevice::open()
{
Lock lock(mGuard);
Lock lock(mGuard);
mRefCount++;
if (mRefCount > 1)
return true;
mThreadHandle = (HANDLE)_beginthread(&threadProc, 0, this);
mRefCount++;
if (mRefCount > 1)
return true;
mThreadHandle = (HANDLE)_beginthread(&threadProc, 0, this);
return true;
}
void WmmeInputDevice::closeDevice()
{
// Stop device
if (mDevHandle)
{
MMRESULT mmres = MMSYSERR_NOERROR;
waveInReset(mDevHandle);
waveInStop(mDevHandle);
}
// Stop device
if (mDevHandle)
{
MMRESULT mmres = MMSYSERR_NOERROR;
waveInReset(mDevHandle);
waveInStop(mDevHandle);
}
// Close buffers
for (int i = 0; i < AUDIO_MIC_BUFFER_COUNT; i++)
mBufferList[i].unprepare(mDevHandle);
// Close buffers
for (int i=0; i<AUDIO_MIC_BUFFER_COUNT; i++)
mBufferList[i].unprepare(mDevHandle);
// Close device
if (mDevHandle)
{
waveInClose(mDevHandle);
mDevHandle = NULL;
}
// Close device
if (mDevHandle)
{
waveInClose(mDevHandle);
mDevHandle = NULL;
}
}
void WmmeInputDevice::close()
{
Lock l(mGuard);
Lock l(mGuard);
mRefCount--;
if (mRefCount != 0)
return;
mRefCount--;
if (mRefCount != 0)
return;
// Set shutdown signal
if (!mThreadHandle)
return;
// Set shutdown signal
if (!mThreadHandle)
return;
::SetEvent(mShutdownSignal);
::WaitForSingleObject(mThreadHandle, INFINITE);
mThreadHandle = 0;
::SetEvent(mShutdownSignal);
::WaitForSingleObject(mThreadHandle, INFINITE);
mThreadHandle = 0;
}
bool WmmeInputDevice::tryReadBuffer(void* buffer)
{
Buffer& devBuffer = mBufferList[mBufferIndex];
Buffer& devBuffer = mBufferList[mBufferIndex];
if (!devBuffer.isFinished())
return false;
memcpy(buffer, devBuffer.data(), AUDIO_MIC_BUFFER_SIZE);
devBuffer.unprepare(mDevHandle);
devBuffer.prepare(mDevHandle);
if (!devBuffer.addToDevice(mDevHandle))
setFakeMode(true);
else
{
}
mBufferIndex = (mBufferIndex + 1) % AUDIO_MIC_BUFFER_COUNT;
return true;
if (!devBuffer.isFinished())
return false;
memcpy(buffer, devBuffer.data(), AUDIO_MIC_BUFFER_SIZE);
devBuffer.unprepare(mDevHandle);
devBuffer.prepare(mDevHandle);
if (!devBuffer.addToDevice(mDevHandle))
setFakeMode(true);
else
{
}
mBufferIndex = (mBufferIndex + 1) % AUDIO_MIC_BUFFER_COUNT;
return true;
}
void WmmeInputDevice::setFakeMode(bool fakeMode)
{
mFakeMode = fakeMode;
mFakeMode = fakeMode;
}
int WmmeInputDevice::readBuffer(void* buffer)
{
// Lock lock(mGuard);
//Lock lock(mGuard);
if (mRefCount <= 0 || mFakeMode)
return 0;
if (mRefCount <= 0 || mFakeMode)
return 0;
// Check for finished buffer
while (!tryReadBuffer(buffer))
WaitForSingleObject(mDoneSignal, 50);
// Check for finished buffer
while (!tryReadBuffer(buffer))
WaitForSingleObject(mDoneSignal, 50);
return AUDIO_MIC_BUFFER_SIZE;
return AUDIO_MIC_BUFFER_SIZE;
}
HWAVEIN WmmeInputDevice::handle()
{
Lock lock(mGuard);
return mDevHandle;
Lock lock(mGuard);
return mDevHandle;
}
void WmmeInputDevice::threadProc(void* arg)
{
WmmeInputDevice* impl = (WmmeInputDevice*)arg;
impl->openDevice();
void* buffer = _alloca(AUDIO_MIC_BUFFER_SIZE);
WmmeInputDevice* impl = (WmmeInputDevice*)arg;
impl->openDevice();
void* buffer = _alloca(AUDIO_MIC_BUFFER_SIZE);
DWORD waitResult = 0;
HANDLE waitArray[2] = {impl->mDoneSignal, impl->mShutdownSignal};
DWORD wr;
do
DWORD waitResult = 0;
HANDLE waitArray[2] = {impl->mDoneSignal, impl->mShutdownSignal};
DWORD wr;
do
{
wr = ::WaitForMultipleObjects(2, waitArray, FALSE, INFINITE);
if (wr == WAIT_OBJECT_0)
{
wr = ::WaitForMultipleObjects(2, waitArray, FALSE, INFINITE);
impl->readBuffer(buffer);
if (impl->connection())
impl->connection()->onMicData(Format(), buffer, AUDIO_MIC_BUFFER_SIZE);
}
} while (wr == WAIT_OBJECT_0);
if (wr == WAIT_OBJECT_0)
{
impl->readBuffer(buffer);
if (impl->connection())
impl->connection()->onMicData(Format(), buffer, AUDIO_MIC_BUFFER_SIZE);
}
} while (wr == WAIT_OBJECT_0);
impl->closeDevice();
impl->closeDevice();
}
// --- WmmeOutputDevice ---
WmmeOutputDevice::Buffer::Buffer() : mHeaderHandle(NULL), mDataHandle(NULL), mData(NULL), mHeader(NULL)
WmmeOutputDevice::Buffer::Buffer()
:mHeaderHandle(NULL), mDataHandle(NULL), mData(NULL), mHeader(NULL)
{
mHeaderHandle = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE, AUDIO_SPK_BUFFER_SIZE);
if (!mHeaderHandle)
throw Exception(ERR_NOMEM);
mHeaderHandle = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE, AUDIO_SPK_BUFFER_SIZE);
if (!mHeaderHandle)
throw Exception(ERR_NOMEM);
mDataHandle = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE, AUDIO_SPK_BUFFER_SIZE);
if (!mDataHandle)
throw Exception(ERR_NOMEM);
mDataHandle = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE, AUDIO_SPK_BUFFER_SIZE);
if (!mDataHandle)
throw Exception(ERR_NOMEM);
mHeader = (WAVEHDR*)GlobalLock(mHeaderHandle);
mData = GlobalLock(mDataHandle);
memset(mHeader, 0, sizeof *mHeader);
mHeader->dwBufferLength = AUDIO_SPK_BUFFER_SIZE;
mHeader->lpData = (LPSTR)mData;
mHeader = (WAVEHDR*)GlobalLock(mHeaderHandle);
mData = GlobalLock(mDataHandle);
memset(mHeader, 0, sizeof *mHeader);
mHeader->dwBufferLength = AUDIO_SPK_BUFFER_SIZE;
mHeader->lpData = (LPSTR)mData;
}
WmmeOutputDevice::Buffer::~Buffer()
{
if (mHeaderHandle)
{
GlobalUnlock(mHeaderHandle);
GlobalFree(mHeaderHandle);
}
if (mDataHandle)
{
GlobalUnlock(mDataHandle);
GlobalFree(mDataHandle);
}
if (mHeaderHandle)
{
GlobalUnlock(mHeaderHandle);
GlobalFree(mHeaderHandle);
}
if (mDataHandle)
{
GlobalUnlock(mDataHandle);
GlobalFree(mDataHandle);
}
}
bool WmmeOutputDevice::Buffer::prepare(HWAVEOUT device)
{
MMRESULT result;
result = ::waveOutPrepareHeader(device, mHeader, sizeof *mHeader);
return result == MMSYSERR_NOERROR;
MMRESULT result;
result = ::waveOutPrepareHeader(device, mHeader, sizeof *mHeader);
return result == MMSYSERR_NOERROR;
}
bool WmmeOutputDevice::Buffer::unprepare(HWAVEOUT device)
{
MMRESULT result;
result = ::waveOutUnprepareHeader(device, mHeader, sizeof *mHeader);
return result == MMSYSERR_NOERROR;
MMRESULT result;
result = ::waveOutUnprepareHeader(device, mHeader, sizeof *mHeader);
return result == MMSYSERR_NOERROR;
}
bool WmmeOutputDevice::Buffer::write(HWAVEOUT device)
{
MMRESULT result;
result = ::waveOutWrite(device, mHeader, sizeof *mHeader);
return result == MMSYSERR_NOERROR;
MMRESULT result;
result = ::waveOutWrite(device, mHeader, sizeof *mHeader);
return result == MMSYSERR_NOERROR;
}
WmmeOutputDevice::WmmeOutputDevice(int index)
: mDevice(NULL), mDeviceIndex(index), mPlayedTime(0), mPlayedCount(0), mBufferIndex(0), mThreadHandle(NULL),
mFailed(false), mShutdownMarker(false)
:mDevice(NULL), mDeviceIndex(index), mPlayedTime(0), mPlayedCount(0), mBufferIndex(0), mThreadHandle(NULL),
mFailed(false), mShutdownMarker(false)
{
mDoneSignal = ::CreateEvent(NULL, FALSE, FALSE, NULL);
mShutdownSignal = ::CreateEvent(NULL, FALSE, FALSE, NULL);
mDoneSignal = ::CreateEvent(NULL, FALSE, FALSE, NULL);
mShutdownSignal = ::CreateEvent(NULL, FALSE, FALSE, NULL);
}
WmmeOutputDevice::~WmmeOutputDevice()
{
close();
close();
// Destroy used signals
CloseHandle(mDoneSignal);
CloseHandle(mShutdownSignal);
// Destroy used signals
CloseHandle(mDoneSignal); CloseHandle(mShutdownSignal);
}
bool WmmeOutputDevice::open()
{
// Start thread
mThreadHandle = (HANDLE)_beginthread(&threadProc, 0, this);
return true;
// Start thread
mThreadHandle = (HANDLE)_beginthread(&threadProc, 0, this);
return true;
}
void WmmeOutputDevice::close()
{
// Tell the thread to exit
SetEvent(mShutdownSignal);
mShutdownMarker = true;
// Tell the thread to exit
SetEvent(mShutdownSignal);
mShutdownMarker = true;
// Wait for thread
if (mThreadHandle)
WaitForSingleObject(mThreadHandle, INFINITE);
mThreadHandle = 0;
// Wait for thread
if (mThreadHandle)
WaitForSingleObject(mThreadHandle, INFINITE);
mThreadHandle = 0;
}
void WmmeOutputDevice::openDevice()
{
mClosing = false;
MMRESULT mmres = 0;
WAVEFORMATEX wfx;
memset(&wfx, 0, sizeof(wfx));
wfx.wFormatTag = 0x0001;
wfx.nChannels = AUDIO_CHANNELS;
wfx.nSamplesPerSec = AUDIO_SAMPLERATE;
wfx.wBitsPerSample = 16;
wfx.cbSize = 0;
wfx.nBlockAlign = wfx.wBitsPerSample * wfx.nChannels / 8;
wfx.nAvgBytesPerSec = wfx.nBlockAlign * wfx.nSamplesPerSec;
mClosing = false;
MMRESULT mmres = 0;
WAVEFORMATEX wfx;
memset(&wfx, 0, sizeof(wfx));
wfx.wFormatTag = 0x0001;
wfx.nChannels = AUDIO_CHANNELS;
wfx.nSamplesPerSec = AUDIO_SAMPLERATE;
wfx.wBitsPerSample = 16;
wfx.cbSize = 0;
wfx.nBlockAlign = wfx.wBitsPerSample * wfx.nChannels / 8;
wfx.nAvgBytesPerSec = wfx.nBlockAlign * wfx.nSamplesPerSec;
mmres = waveOutOpen(&mDevice, mDeviceIndex, &wfx, (DWORD_PTR)&callbackProc, (DWORD_PTR)this, CALLBACK_FUNCTION);
if (mmres != MMSYSERR_NOERROR)
throw Exception(ERR_WMME_FAILED, mmres);
mmres = waveOutOpen(&mDevice, mDeviceIndex, &wfx, (DWORD_PTR)&callbackProc, (DWORD_PTR)this, CALLBACK_FUNCTION);
if (mmres != MMSYSERR_NOERROR)
throw Exception(ERR_WMME_FAILED, mmres);
// Prebuffer silence
for (unsigned i = 0; i < AUDIO_SPK_BUFFER_COUNT; i++)
{
// bool dumb = false;
// mCallback(mBufferList[i].mData, SPK_BUFFER_SIZE, dumb, dumb);
memset(mBufferList[i].mData, 0, AUDIO_SPK_BUFFER_SIZE);
mBufferList[i].prepare(mDevice);
mBufferList[i].write(mDevice);
}
// Prebuffer silence
for (unsigned i=0; i<AUDIO_SPK_BUFFER_COUNT; i++)
{
//bool dumb = false;
//mCallback(mBufferList[i].mData, SPK_BUFFER_SIZE, dumb, dumb);
memset(mBufferList[i].mData, 0, AUDIO_SPK_BUFFER_SIZE);
mBufferList[i].prepare(mDevice);
mBufferList[i].write(mDevice);
}
}
void WmmeOutputDevice::closeDevice()
{
Lock l(mGuard);
Lock l(mGuard);
mClosing = true;
bool finished = false;
while (!finished)
{
WaitForSingleObject(mDoneSignal, 10);
finished = areBuffersFinished();
}
mClosing = true;
bool finished = false;
while (!finished)
{
WaitForSingleObject(mDoneSignal, 10);
finished = areBuffersFinished();
}
if (mDevice)
{
waveOutReset(mDevice);
waveOutClose(mDevice);
}
if (mDevice)
{
waveOutReset(mDevice);
waveOutClose(mDevice);
}
mDevice = NULL;
mDevice = NULL;
}
bool WmmeOutputDevice::areBuffersFinished()
{
Lock l(mGuard);
bool result = true;
for (unsigned i = 0; i < AUDIO_SPK_BUFFER_COUNT && result; i++)
Lock l(mGuard);
bool result = true;
for (unsigned i=0; i<AUDIO_SPK_BUFFER_COUNT && result; i++)
{
bool finished = mBufferList[i].mHeader->dwFlags & WHDR_DONE ||
!mBufferList[i].mHeader->dwFlags;
if (finished)
{
bool finished = mBufferList[i].mHeader->dwFlags & WHDR_DONE || !mBufferList[i].mHeader->dwFlags;
if (finished)
{
/* if (mBufferList[i].mHeader->dwFlags & WHDR_PREPARED)
mBufferList[i].Unprepare(mDevice); */
}
result &= finished;
/* if (mBufferList[i].mHeader->dwFlags & WHDR_PREPARED)
mBufferList[i].Unprepare(mDevice); */
}
result &= finished;
}
return result;
return result;
}
void WmmeOutputDevice::threadProc(void* arg)
{
WmmeOutputDevice* impl = (WmmeOutputDevice*)arg;
impl->openDevice();
WmmeOutputDevice* impl = (WmmeOutputDevice*)arg;
impl->openDevice();
DWORD waitResult = 0;
HANDLE waitArray[2] = {impl->mDoneSignal, impl->mShutdownSignal};
unsigned index, i;
unsigned exitCount = 0;
bool exitSignal = false;
do
DWORD waitResult = 0;
HANDLE waitArray[2] = {impl->mDoneSignal, impl->mShutdownSignal};
unsigned index, i;
unsigned exitCount = 0;
bool exitSignal = false;
do
{
// Poll for exit signal
if (!exitSignal)
exitSignal = impl->mShutdownMarker;
// Wait for played buffer
WaitForSingleObject(impl->mDoneSignal, 500);
// Iterate buffers to find played
for (i=0; i<AUDIO_SPK_BUFFER_COUNT; i++)
{
// Poll for exit signal
if (!exitSignal)
exitSignal = impl->mShutdownMarker;
index = (impl->mBufferIndex + i) % AUDIO_SPK_BUFFER_COUNT;
Buffer& buffer = impl->mBufferList[index];
if (!(buffer.mHeader->dwFlags & WHDR_DONE))
break;
// Wait for played buffer
WaitForSingleObject(impl->mDoneSignal, 500);
buffer.unprepare(impl->mDevice);
if (!exitSignal)
{
bool useAEC = true;
if (impl->connection())
impl->connection()->onSpkData(Format(), buffer.mData, AUDIO_SPK_BUFFER_SIZE);
else
memset(buffer.mData, 0, AUDIO_SPK_BUFFER_SIZE);
// Iterate buffers to find played
for (i = 0; i < AUDIO_SPK_BUFFER_COUNT; i++)
{
index = (impl->mBufferIndex + i) % AUDIO_SPK_BUFFER_COUNT;
Buffer& buffer = impl->mBufferList[index];
if (!(buffer.mHeader->dwFlags & WHDR_DONE))
break;
buffer.unprepare(impl->mDevice);
if (!exitSignal)
{
bool useAEC = true;
if (impl->connection())
impl->connection()->onSpkData(Format(), buffer.mData, AUDIO_SPK_BUFFER_SIZE);
else
memset(buffer.mData, 0, AUDIO_SPK_BUFFER_SIZE);
buffer.prepare(impl->mDevice);
buffer.write(impl->mDevice);
}
else
exitCount++;
}
impl->mBufferIndex = (impl->mBufferIndex + i) % AUDIO_SPK_BUFFER_COUNT;
} while (!exitSignal || exitCount < AUDIO_SPK_BUFFER_COUNT);
impl->closeDevice();
buffer.prepare(impl->mDevice);
buffer.write(impl->mDevice);
}
else
exitCount++;
}
impl->mBufferIndex = (impl->mBufferIndex + i) % AUDIO_SPK_BUFFER_COUNT;
}
while (!exitSignal || exitCount < AUDIO_SPK_BUFFER_COUNT);
impl->closeDevice();
}
HWAVEOUT WmmeOutputDevice::handle()
{
return mDevice;
return mDevice;
}
unsigned WmmeOutputDevice::playedTime()
{
if (!mDevice)
return 0;
unsigned result = 0;
if (!mDevice)
return 0;
unsigned result = 0;
MMTIME mmt;
memset(&mmt, 0, sizeof(mmt));
mmt.wType = TIME_SAMPLES;
MMRESULT rescode = waveOutGetPosition(mDevice, &mmt, sizeof(mmt));
if (rescode != MMSYSERR_NOERROR || mmt.wType != TIME_SAMPLES)
closeDevice();
MMTIME mmt;
memset(&mmt, 0, sizeof(mmt));
mmt.wType = TIME_SAMPLES;
MMRESULT rescode = waveOutGetPosition(mDevice, &mmt, sizeof(mmt));
if (rescode != MMSYSERR_NOERROR || mmt.wType != TIME_SAMPLES)
closeDevice();
else
{
if (mmt.u.ms < mPlayedTime)
result = 0;
else
{
if (mmt.u.ms < mPlayedTime)
result = 0;
else
{
result = mmt.u.ms - mPlayedTime;
mPlayedTime = mmt.u.ms - result % 8;
}
result = mmt.u.ms - mPlayedTime;
mPlayedTime = mmt.u.ms - result % 8;
}
}
return result / 8;
return result / 8;
}
void WmmeOutputDevice::setFakeMode(bool fakemode)
{
closeDevice();
closeDevice();
}
bool WmmeOutputDevice::fakeMode()
{
return mFailed;
return mFailed;
}
bool WmmeOutputDevice::closing()
{
return mClosing;
return mClosing;
}
void CALLBACK WmmeOutputDevice::callbackProc(HWAVEOUT hwo, UINT msg, DWORD_PTR dwInstance, DWORD_PTR dwParam1,
DWORD_PTR dwParam2)
void CALLBACK WmmeOutputDevice::callbackProc(HWAVEOUT hwo, UINT msg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
WmmeOutputDevice* impl;
WmmeOutputDevice* impl;
if (msg == WOM_DONE)
{
impl = (WmmeOutputDevice*)dwInstance;
InterlockedIncrement(&impl->mPlayedCount);
SetEvent(impl->mDoneSignal);
}
if (msg == WOM_DONE)
{
impl = (WmmeOutputDevice*)dwInstance;
InterlockedIncrement(&impl->mPlayedCount);
SetEvent(impl->mDoneSignal);
}
}
#endif
src/engine/audio/Audio_Wmme.h
+80 -80
View File
@@ -8,7 +8,7 @@
#ifdef TARGET_WIN
#include "../engine_config.h"
#include "../config.h"
#include <winsock2.h>
#include <windows.h>
@@ -30,118 +30,118 @@
namespace Audio
{
class WmmeInputDevice : public InputDevice
{
public:
class WmmeInputDevice: public InputDevice
{
public:
WmmeInputDevice(int index);
~WmmeInputDevice();
bool open();
void close();
bool open();
void close();
bool fakeMode();
void setFakeMode(bool fakeMode);
bool fakeMode();
void setFakeMode(bool fakeMode);
int readBuffer(void* buffer);
int readBuffer(void* buffer);
HWAVEIN handle();
protected:
protected:
class Buffer
{
public:
Buffer();
~Buffer();
bool prepare(HWAVEIN device);
bool unprepare(HWAVEIN device);
bool isFinished();
bool addToDevice(HWAVEIN device);
void* data();
Buffer();
~Buffer();
bool prepare(HWAVEIN device);
bool unprepare(HWAVEIN device);
bool isFinished();
bool addToDevice(HWAVEIN device);
void* data();
protected:
HGLOBAL mDataHandle;
void* mData;
HGLOBAL mHeaderHandle;
WAVEHDR* mHeader;
HGLOBAL mDataHandle;
void* mData;
HGLOBAL mHeaderHandle;
WAVEHDR* mHeader;
};
Mutex mGuard; /// Mutex to protect this instance.
HWAVEIN mDevHandle; /// Handle of opened capture device.
HANDLE mThreadHandle;
HANDLE mShutdownSignal;
HANDLE mDoneSignal; /// Event handle to signal about finished capture.
Buffer mBufferList[AUDIO_MIC_BUFFER_COUNT];
unsigned mBufferIndex;
int mDeviceIndex; /// Index of capture device.
volatile bool mFakeMode; /// Marks if fake mode is active.
int mRefCount;
Mutex mGuard; /// Mutex to protect this instance.
HWAVEIN mDevHandle; /// Handle of opened capture device.
HANDLE mThreadHandle;
HANDLE mShutdownSignal;
HANDLE mDoneSignal; /// Event handle to signal about finished capture.
Buffer mBufferList[AUDIO_MIC_BUFFER_COUNT];
unsigned mBufferIndex;
int mDeviceIndex; /// Index of capture device.
volatile bool mFakeMode; /// Marks if fake mode is active.
int mRefCount;
bool tryReadBuffer(void* buffer);
void openDevice();
void closeDevice();
bool tryReadBuffer(void* buffer);
void openDevice();
void closeDevice();
static void CALLBACK callbackProc(HWAVEIN hwi, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1,
DWORD_PTR dwParam2);
static void threadProc(void* arg);
};
static void CALLBACK callbackProc(HWAVEIN hwi, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2);
static void threadProc(void* arg);
};
class WmmeOutputDevice : public OutputDevice
{
public:
class WmmeOutputDevice: public OutputDevice
{
public:
WmmeOutputDevice(int index);
~WmmeOutputDevice();
bool open();
void close();
bool open();
void close();
HWAVEOUT handle();
unsigned playedTime();
void setFakeMode(bool fakemode);
bool fakeMode();
bool closing();
HWAVEOUT handle();
unsigned playedTime();
void setFakeMode(bool fakemode);
bool fakeMode();
bool closing();
protected:
protected:
class Buffer
{
friend class WmmeOutputDevice;
friend class WmmeOutputDevice;
public:
Buffer();
~Buffer();
bool prepare(HWAVEOUT device);
bool unprepare(HWAVEOUT device);
bool write(HWAVEOUT device);
Buffer();
~Buffer();
bool prepare(HWAVEOUT device);
bool unprepare(HWAVEOUT device);
bool write(HWAVEOUT device);
protected:
WAVEHDR* mHeader;
void* mData;
HGLOBAL mHeaderHandle;
HGLOBAL mDataHandle;
WAVEHDR* mHeader;
void* mData;
HGLOBAL mHeaderHandle;
HGLOBAL mDataHandle;
};
Mutex mGuard; /// Mutex to protect this instance
int mDeviceIndex;
HWAVEOUT mDevice; /// Handle of opened audio device
Buffer mBufferList[AUDIO_SPK_BUFFER_COUNT];
unsigned mPlayedTime; /// Amount of played time in milliseconds
bool mClosing;
HANDLE mDoneSignal, mShutdownSignal, mThreadHandle;
volatile bool mShutdownMarker;
Mutex mGuard; /// Mutex to protect this instance
int mDeviceIndex;
HWAVEOUT mDevice; /// Handle of opened audio device
Buffer mBufferList[AUDIO_SPK_BUFFER_COUNT];
unsigned mPlayedTime; /// Amount of played time in milliseconds
bool mClosing;
HANDLE mDoneSignal,
mShutdownSignal,
mThreadHandle;
volatile bool mShutdownMarker;
volatile LONG mPlayedCount;
unsigned mBufferIndex;
bool mFailed;
volatile LONG mPlayedCount;
unsigned mBufferIndex;
bool mFailed;
void openDevice();
void closeDevice();
bool areBuffersFinished();
void openDevice();
void closeDevice();
bool areBuffersFinished();
static void CALLBACK callbackProc(HWAVEOUT hwo, UINT msg, DWORD_PTR dwInstance, DWORD_PTR dwParam1,
DWORD_PTR dwParam2);
static void threadProc(void* arg);
};
static void CALLBACK callbackProc(HWAVEOUT hwo, UINT msg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2);
static void threadProc(void* arg);
};
} // namespace Audio
}
#endif
src/engine/audio/Audio_iOS.cpp
+1
View File
@@ -1 +1,2 @@
#include "Audio_iOS.h"
src/engine/audio/Audio_iOS.h
+20 -18
View File
@@ -1,36 +1,38 @@
#ifndef __AUDIO_IOS
#define __AUDIO_IOS
class IosInputDevice : public InputDevice
class IosInputDevice: public InputDevice
{
protected:
public:
IosInputDevice();
~IosInputDevice();
IosInputDevice();
~IosInputDevice();
void open();
void close();
void open();
void close();
};
class IosOutputDevice : public OutputDevice
class IosOutputDevice: public OutputDevice
{
protected:
public:
IosOutputDevice();
~IosOutputDevice();
enum
{
Receiver,
Speaker,
Bluetooth
};
IosOutputDevice();
~IosOutputDevice();
enum
{
Receiver,
Speaker,
Bluetooth
};
int route();
void setRoute(int route);
int route();
void setRoute(int route);
void open();
void close();
void open();
void close();
};
#endif
src/engine/audio/CMakeLists.txt
+1 -16
View File
@@ -1,42 +1,27 @@
project (audio_lib)
# Rely on C++ 11
set (CMAKE_CXX_STANDARD 20)
set (CMAKE_CXX_STANDARD 11)
set (CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
set (AUDIOLIB_SOURCES
Audio_Resampler.cpp
Audio_Resampler.h
Audio_Quality.cpp
Audio_Quality.h
Audio_Mixer.cpp
Audio_Mixer.h
Audio_Interface.cpp
Audio_Interface.h
Audio_Helper.cpp
Audio_Helper.h
Audio_DataWindow.cpp
Audio_DataWindow.h
Audio_DevicePair.cpp
Audio_DevicePair.h
Audio_Player.cpp
Audio_Player.h
Audio_Null.cpp
Audio_Null.h
Audio_CoreAudio.cpp
Audio_CoreAudio.h
Audio_DirectSound.cpp
Audio_DirectSound.h
Audio_AndroidOboe.cpp
Audio_AndroidOboe.h
Audio_WavFile.cpp
Audio_WavFile.h
)
add_library(audio_lib ${AUDIOLIB_SOURCES})
set_property(TARGET audio_lib PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
##
target_include_directories(audio_lib
src/engine/config.h
+113
View File
@@ -0,0 +1,113 @@
/* Copyright(C) 2007-2020 VoIP objects (voipobjects.com)
* 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 __TOOLKIT_CONFIG_H
#define __TOOLKIT_CONFIG_H
#define USE_SPEEX_AEC
// TODO: test implementation with webrtc aec; be careful - it needs fixes!
//#define USE_WEBRTC_AEC
#define USER
#define AUDIO_SAMPLE_WIDTH 16
#define AUDIO_CHANNELS 1
// Samplerate must be 8 / 16 / 24 / 32 / 48 KHz
#define AUDIO_SAMPLERATE 8000
#define AUDIO_MIC_BUFFER_COUNT 16
#define AUDIO_MIC_BUFFER_LENGTH 10
#define AUDIO_MIC_BUFFER_SIZE (AUDIO_MIC_BUFFER_LENGTH * AUDIO_SAMPLERATE / 1000 * 2 * AUDIO_CHANNELS)
#define AUDIO_SPK_BUFFER_COUNT 16
#define AUDIO_SPK_BUFFER_LENGTH 10
#define AUDIO_SPK_BUFFER_SIZE (AUDIO_SPK_BUFFER_LENGTH * AUDIO_SAMPLERATE / 1000 * 2 * AUDIO_CHANNELS)
#define AUDIO_MIX_CHANNEL_COUNT 16
#define AUDIO_DEVICEPAIR_INPUTBUFFER 16384
// Avoid too high resampler quality - it can take many CPU and cause gaps in playing
#define AUDIO_RESAMPLER_QUALITY 1
#define AEC_FRAME_TIME 10
#define AEC_TAIL_TIME 160
// Defined these two lines to get dumping of audio input/output
//#define AUDIO_DUMPINPUT
//#define AUDIO_DUMPOUTPUT
#define UA_REGISTRATION_TIME 3600
#define UA_MEDIA_PORT_START 20000
#define UA_MEDIA_PORT_FINISH 30000
#define UA_MAX_UDP_PACKET_SIZE 576
#define UA_PUBLICATION_ID "314"
#define MT_SAMPLERATE AUDIO_SAMPLERATE
#define MT_MAXAUDIOFRAME 1440
#define MT_MAXRTPPACKET 1500
#define MT_DTMF_END_PACKETS 3
#define RTP_BUFFER_HIGH 24480
#define RTP_BUFFER_LOW 10
#define RTP_BUFFER_PREBUFFER 80
#define RTP_DECODED_CAPACITY 2048
#define DEFAULT_SUBSCRIPTION_TIME 1200
#define DEFAULT_SUBSCRIPTION_REFRESHTIME 500
#define PRESENCE_IN_REG_HEADER "PresenceInReg"
// Maximum UDP packet length
#define MAX_UDPPACKET_SIZE 65535
#define MAX_VALID_UDPPACKET_SIZE 2048
// AMR codec defines - it requires USE_AMR_CODEC defined
// #define USE_AMR_CODEC
#define MT_AMRNB_PAYLOADTYPE 112
#define MT_AMRNB_CODECNAME "amr"
#define MT_AMRNB_OCTET_PAYLOADTYPE 113
#define MT_AMRWB_PAYLOADTYPE 96
#define MT_AMRWB_CODECNAME "amr-wb"
#define MT_AMRWB_OCTET_PAYLOADTYPE 97
#define MT_GSMEFR_PAYLOADTYPE 126
#define MT_GSMEFR_CODECNAME "GERAN-EFR"
#define MT_EVS_PAYLOADTYPE 127
#define MT_EVS_CODECNAME "EVS"
// OPUS codec defines
// #define USE_OPUS_CODEC
#define MT_OPUS_CODEC_PT 106
// ILBC codec defines
#define MT_ILBC20_PAYLOADTYPE -1
#define MT_ILBC30_PAYLOADTYPE -1
// ISAC codec defines
#define MT_ISAC16K_PAYLOADTYPE -1
#define MT_ISAC32K_PAYLOADTYPE -1
// GSM HR payload type
#define MT_GSMHR_PAYLOADTYPE -1
// Mirror buffer capacity
#define MT_MIRROR_CAPACITY 32768
// Mirror buffer readiness threshold - 50 milliseconds
#define MT_MIRROR_PREBUFFER (MT_SAMPLERATE / 10)
#if defined(TARGET_OSX) || defined(TARGET_LINUX)
# define TEXT(X) X
#endif
// In milliseconds
#define MT_SEVANA_FRAME_TIME 680
#endif
src/engine/endpoint/EP_Account.cpp
+518 -513
View File
File diff suppressed because it is too large Load Diff
src/engine/endpoint/EP_Account.h
+83 -84
View File
@@ -22,121 +22,120 @@
class UserAgent;
class Session;
class Account : public resip::DnsResultSink
class Account: public resip::DnsResultSink
{
friend class UserAgent;
friend class NATDecorator;
friend class UserAgent;
friend class NATDecorator;
public:
Account(PVariantMap config, UserAgent& agent);
~Account();
Account(PVariantMap config, UserAgent& agent);
~Account();
void start();
void stop();
void refresh();
bool active();
int id() const;
void start();
void stop();
void refresh();
bool active();
int id() const;
enum class RegistrationState
{
None,
Registering,
Reregistering,
Registered,
Unregistering
};
RegistrationState registrationState();
enum class RegistrationState
{
None,
Registering,
Reregistering,
Registered,
Unregistering
};
RegistrationState registrationState();
/* Publishes new presence information */
void publishPresence(bool online, const std::string& content, int seconds = 600);
/* Publishes new presence information */
void publishPresence(bool online, const std::string& content, int seconds = 600);
/* Stops publishing of presence */
void stopPublish();
/* Stops publishing of presence */
void stopPublish();
/* Starts observing on specified target / package */
PClientObserver observe(const std::string& target, const std::string& package, void* tag);
/* Starts observing on specified target / package */
PClientObserver observe(const std::string& target, const std::string& package, void* tag);
/* Queues message to peer with specified mime type. Returns ID of message. */
int sendMsg(const std::string& peer, const void* ptr, unsigned length, const std::string& mime, void* tag);
/* Queues message to peer with specified mime type. Returns ID of message. */
int sendMsg(const std::string& peer, const void* ptr, unsigned length, const std::string& mime, void* tag);
/* Returns name of account - <sip:user@domain> */
std::string name();
/* Returns name of account - <sip:user@domain> */
std::string name();
/* Updates account with configuration */
void setup(VariantMap& config);
/* Updates account with configuration */
void setup(VariantMap& config);
/* Returns corresponding resiprocate profile */
std::shared_ptr<resip::UserProfile> getUserProfile() const { return mProfile; }
/* Returns corresponding resiprocate profile */
resip::SharedPtr<resip::UserProfile> getUserProfile() const { return mProfile; }
typedef std::map<std::string, std::string> UserInfo;
void setUserInfo(const UserInfo& info);
UserInfo getUserInfo() const;
typedef std::map<std::string, std::string> UserInfo;
void setUserInfo(const UserInfo& info);
UserInfo getUserInfo() const;
protected:
PVariantMap mConfig;
PVariantMap mConfig;
// Registration
ResipSession* mRegistration;
resip::ClientRegistrationHandle mRegistrationHandle;
resip::ClientPublicationHandle mPublication;
resip::TransportType mUsedTransport;
// Registration
ResipSession* mRegistration;
resip::ClientRegistrationHandle mRegistrationHandle;
resip::ClientPublicationHandle mPublication;
resip::TransportType mUsedTransport;
RegistrationState mRegistrationState;
RegistrationState mRegistrationState;
ice::NetworkAddress mExternalAddress;
std::shared_ptr<resip::UserProfile> mProfile;
UserAgent& mAgent;
bool mPresenceOnline;
std::string mPresenceContent;
ice::NetworkAddress mExternalAddress;
resip::SharedPtr<resip::UserProfile> mProfile;
UserAgent& mAgent;
bool mPresenceOnline;
std::string mPresenceContent;
// Timer to refresh STUN server IP
ice::ICEScheduleTimer mRefreshStunServerIpTimer;
// Timer to refresh STUN server IP
ice::ICEScheduleTimer mRefreshStunServerIpTimer;
// Cached auth
resip::Auth mCachedAuth;
// Cached auth
resip::Auth mCachedAuth;
// Id of account
int mId;
// Id of account
int mId;
// User info about current state
UserInfo mUserInfo;
// User info about current state
UserInfo mUserInfo;
// List of client subscriptions sent from this account
typedef std::set<PClientObserver> ClientObserverSet;
ClientObserverSet mClientObserverSet;
// List of client subscriptions sent from this account
typedef std::set<PClientObserver> ClientObserverSet;
ClientObserverSet mClientObserverSet;
void process();
// Method queries new stun server ip from dns (if stun server is specified as dns name)
void queryStunServerIp();
void process();
// Method queries new stun server ip from dns (if stun server is specified as dns name)
void queryStunServerIp();
bool isResponsibleFor(const resip::NameAddr& addr);
enum class SecureScheme
{
SipsAndTls,
SipsOnly,
TlsOnly,
Nothing
};
bool isResponsibleFor(const resip::NameAddr& addr);
enum class SecureScheme
{
SipsAndTls,
SipsOnly,
TlsOnly,
Nothing
};
resip::NameAddr contact(SecureScheme ss = SecureScheme::SipsOnly);
resip::NameAddr contact(SecureScheme ss = SecureScheme::SipsOnly);
// This method prepares configuration, creates ice stack and sets ownership to session
void prepareIceStack(Session* session, ice::AgentRole role);
void onSuccess(resip::ClientRegistrationHandle h, const resip::SipMessage& response);
void onRemoved(resip::ClientRegistrationHandle h, const resip::SipMessage& response);
void onFailure(resip::ClientRegistrationHandle, const resip::SipMessage& response);
// This method prepares configuration, creates ice stack and sets ownership to session
void prepareIceStack(Session* session, ice::AgentRole role);
void onSuccess(resip::ClientRegistrationHandle h, const resip::SipMessage& response);
void onRemoved(resip::ClientRegistrationHandle h, const resip::SipMessage& response);
void onFailure(resip::ClientRegistrationHandle, const resip::SipMessage& response);
#pragma region DnsResultSink implementation
void onDnsResult(const resip::DNSResult<resip::DnsHostRecord>&);
void onDnsResult(const resip::DNSResult<resip::DnsAAAARecord>&);
void onDnsResult(const resip::DNSResult<resip::DnsSrvRecord>&);
void onDnsResult(const resip::DNSResult<resip::DnsNaptrRecord>&);
void onDnsResult(const resip::DNSResult<resip::DnsCnameRecord>&);
void onDnsResult(const resip::DNSResult<resip::DnsHostRecord>&);
void onDnsResult(const resip::DNSResult<resip::DnsAAAARecord>&);
void onDnsResult(const resip::DNSResult<resip::DnsSrvRecord>&);
void onDnsResult(const resip::DNSResult<resip::DnsNaptrRecord>&);
void onDnsResult(const resip::DNSResult<resip::DnsCnameRecord>&);
#pragma endregion
static int generateId();
static std::atomic_int IdGenerator;
static int generateId();
static resip::AtomicCounter IdGenerator;
};
typedef std::shared_ptr<Account> PAccount;
src/engine/endpoint/EP_AudioProvider.cpp
+63 -60
View File
@@ -14,10 +14,11 @@
#include "../helper/HL_Log.h"
#include "../helper/HL_String.h"
#define LOG_SUBSYSTEM "engine"
#define LOG_SUBSYSTEM "AudioProvider"
AudioProvider::AudioProvider(UserAgent& agent, MT::Terminal& terminal)
: mUserAgent(agent), mTerminal(terminal), mState(0), mRemoteTelephoneCodec(0), mRemoteNoSdp(false)
:mUserAgent(agent), mTerminal(terminal), mState(0),
mRemoteTelephoneCodec(0), mRemoteNoSdp(false)
{
mActive = mfActive;
mRemoteState = msSendRecv;
@@ -25,11 +26,12 @@ AudioProvider::AudioProvider(UserAgent& agent, MT::Terminal& terminal)
if (mUserAgent.config().exists(CONFIG_CODEC_PRIORITY))
mCodecPriority.setupFrom(mUserAgent.config()[CONFIG_CODEC_PRIORITY].asVMap());
mSrtpSuite = SRTP_NONE;
setStateImpl((int)StreamState::SipRecv | (int)StreamState::SipSend | (int)StreamState::Receiving |
(int)StreamState::Sending);
setStateImpl((int)StreamState::SipRecv | (int)StreamState::SipSend | (int)StreamState::Receiving | (int)StreamState::Sending);
}
AudioProvider::~AudioProvider() {}
AudioProvider::~AudioProvider()
{
}
std::string AudioProvider::streamName()
{
@@ -45,7 +47,7 @@ std::string AudioProvider::streamProfile()
}
// Sets destination IP address
void AudioProvider::setDestinationAddress(const RtpPair<InternetAddress>& addr)
void AudioProvider::setDestinationAddress(const RtpPair<InternetAddress>& addr)
{
if (!mActiveStream)
return;
@@ -53,7 +55,7 @@ void AudioProvider::setDestinationAddress(const RtpPair<InternetAddress>& addr)
mActiveStream->setDestination(addr);
}
void AudioProvider::configureMediaObserver(MT::Stream::MediaObserver* observer, void* userTag)
void AudioProvider::configureMediaObserver(MT::Stream::MediaObserver *observer, void* userTag)
{
mMediaObserver = observer;
mMediaObserverTag = userTag;
@@ -62,21 +64,20 @@ void AudioProvider::configureMediaObserver(MT::Stream::MediaObserver* observer,
}
// Processes incoming data
void AudioProvider::processData(const PDatagramSocket& s, const void* dataBuffer, int dataSize, InternetAddress& source)
void AudioProvider::processData(PDatagramSocket s, const void* dataBuffer, int dataSize, InternetAddress& source)
{
if (!mActiveStream)
return;
if (RtpHelper::isRtpOrRtcp(dataBuffer, dataSize))
{
ICELogMedia(<< "Adding new data to stream processing");
ICELogMedia(<<"Adding new data to stream processing");
mActiveStream->dataArrived(s, dataBuffer, dataSize, source);
}
}
// This method is called by user agent to send ICE packet from mediasocket
void AudioProvider::sendData(const PDatagramSocket& s, InternetAddress& destination, const void* buffer,
unsigned int size)
void AudioProvider::sendData(PDatagramSocket s, InternetAddress& destination, const void* buffer, unsigned int size)
{
s->sendDatagram(destination, buffer, size);
}
@@ -92,19 +93,18 @@ void AudioProvider::updateSdpOffer(resip::SdpContents::Session::Medium& sdp, Sdp
// Check if SRTP suite is found already or not
if (mSrtpSuite == SRTP_NONE)
{
// RFC 4568 requires a unique tag per crypto attribute; use the suite id.
for (int suite = SRTP_AES_128_AUTH_80; suite <= SRTP_LAST; suite++)
sdp.addAttribute("crypto", resip::Data(createCryptoAttribute((SrtpSuite)suite, suite)));
sdp.addAttribute("crypto", resip::Data(createCryptoAttribute((SrtpSuite)suite)));
}
else
// Answer/re-offer: echo the tag of the negotiated attribute.
sdp.addAttribute("crypto", resip::Data(createCryptoAttribute(mSrtpSuite, mSrtpTag)));
sdp.addAttribute("crypto", resip::Data(createCryptoAttribute(mSrtpSuite)));
}
#if defined(USE_RESIP_INTEGRATION)
// Use CodecListPriority mCodecPriority adapter to work with codec priorities
if (mAvailableCodecs.empty())
{
for (int i = 0; i < mCodecPriority.count(mTerminal.codeclist()); i++)
for (int i=0; i<mCodecPriority.count(mTerminal.codeclist()); i++)
mCodecPriority.codecAt(mTerminal.codeclist(), i).updateSdp(sdp.codecs(), direction);
sdp.addCodec(resip::SdpContents::Session::Codec::TelephoneEvent);
}
@@ -114,42 +114,27 @@ void AudioProvider::updateSdpOffer(resip::SdpContents::Session::Medium& sdp, Sdp
if (mRemoteTelephoneCodec)
sdp.addCodec(resip::SdpContents::Session::Codec::TelephoneEvent);
}
#endif
// Publish stream state
const char* attr = nullptr;
switch (mActive)
{
case mfActive:
switch (mRemoteState)
switch(mRemoteState)
{
case msSendonly:
attr = "recvonly";
break;
case msInactive:
attr = "recvonly";
break;
case msRecvonly:
case msSendRecv:
break; // Do nothing here
case msSendonly: attr = "recvonly"; break;
case msInactive: attr = "recvonly"; break;
}
break;
case mfPaused:
switch (mRemoteState)
{
case msRecvonly:
attr = "sendonly";
break;
case msSendonly:
attr = "inactive";
break;
case msInactive:
attr = "inactive";
break;
case msSendRecv:
attr = "sendonly";
break;
case msRecvonly: attr = "sendonly"; break;
case msSendonly: attr = "inactive"; break;
case msInactive: attr = "inactive"; break;
case msSendRecv: attr = "sendonly"; break;
}
break;
}
@@ -239,11 +224,13 @@ bool AudioProvider::processSdpOffer(const resip::SdpContents::Session::Medium& m
// Use CodecListPriority mCodecPriority to work with codec priorities
int pt;
for (int localIndex = 0; localIndex < mCodecPriority.count(mTerminal.codeclist()); localIndex++)
for (int localIndex=0; localIndex<mCodecPriority.count(mTerminal.codeclist()); localIndex++)
{
MT::Codec::Factory& factory = mCodecPriority.codecAt(mTerminal.codeclist(), localIndex);
#if defined(USE_RESIP_INTEGRATION)
if ((pt = factory.processSdp(media.codecs(), sdpDirection)) != -1)
mAvailableCodecs.push_back(RemoteCodec(&factory, pt));
#endif
}
if (!mAvailableCodecs.size())
@@ -254,19 +241,17 @@ bool AudioProvider::processSdpOffer(const resip::SdpContents::Session::Medium& m
{
// Find the most strong crypt suite
const std::list<resip::Data>& vl = media.getValues("crypto");
SrtpSuite ss = SRTP_NONE;
ByteBuffer key;
SrtpSuite ss = SRTP_NONE;
ByteBuffer key;
for (std::list<resip::Data>::const_iterator attrIter = vl.begin(); attrIter != vl.end(); attrIter++)
{
const resip::Data& attr = *attrIter;
ByteBuffer tempkey;
int tag = 1;
SrtpSuite suite = processCryptoAttribute(attr, tempkey, &tag);
if (srtpSuiteStrength(suite) > srtpSuiteStrength(ss))
ByteBuffer tempkey;
SrtpSuite suite = processCryptoAttribute(attr, tempkey);
if (suite > ss)
{
ss = suite;
mSrtpSuite = suite;
mSrtpTag = tag;
key = tempkey;
}
}
@@ -311,30 +296,40 @@ MT::PStream AudioProvider::activeStream()
return mActiveStream;
}
std::string AudioProvider::createCryptoAttribute(SrtpSuite suite, int tag)
std::string AudioProvider::createCryptoAttribute(SrtpSuite suite)
{
if (!mActiveStream)
return "";
// Use tag 1 - it is ok, as we use only single crypto attribute
int srtpTag = 1;
// Print key to base64 string
PByteBuffer keyBuffer = mActiveStream->srtp().outgoingKey(suite).first;
if (!keyBuffer)
return "";
resip::Data d(keyBuffer->data(), keyBuffer->size());
resip::Data keyText = d.base64encode();
return std::format("{} {} inline:{}", tag, toString(suite), keyText.c_str());
// Create "crypto" attribute value
char buffer[512];
const char* suiteName = NULL;
switch (suite)
{
case SRTP_AES_128_AUTH_80: suiteName = SRTP_SUITE_NAME_1; break;
case SRTP_AES_256_AUTH_80: suiteName = SRTP_SUITE_NAME_2; break;
default: assert(0);
}
sprintf(buffer, "%d %s inline:%s", srtpTag, suiteName, keyText.c_str());
return buffer;
}
SrtpSuite AudioProvider::processCryptoAttribute(const resip::Data& value, ByteBuffer& key, int* tag)
SrtpSuite AudioProvider::processCryptoAttribute(const resip::Data& value, ByteBuffer& key)
{
int srtpTag = 0;
int srtpTag = 0;
char suite[64], keyChunk[256];
int components = sscanf(value.c_str(), "%d %63s inline: %255s", &srtpTag, suite, keyChunk);
int components = sscanf(value.c_str(), "%d %63s inline: %255s", &srtpTag, suite, keyChunk);
if (components != 3)
return SRTP_NONE;
if (tag)
*tag = srtpTag;
const char* delimiter = strchr(keyChunk, '|');
resip::Data keyText;
@@ -346,7 +341,15 @@ SrtpSuite AudioProvider::processCryptoAttribute(const resip::Data& value, ByteBu
resip::Data rawkey = keyText.base64decode();
key = ByteBuffer(rawkey.c_str(), rawkey.size());
return toSrtpSuite(suite);
// Open srtp
SrtpSuite result = SRTP_NONE;
if (strcmp(suite, SRTP_SUITE_NAME_1) == 0)
result = SRTP_AES_128_AUTH_80;
else
if (strcmp(suite, SRTP_SUITE_NAME_2) == 0)
result = SRTP_AES_256_AUTH_80;
return result;
}
void AudioProvider::findRfc2833(const resip::SdpContents::Session::Medium::CodecContainer& codecs)
@@ -355,7 +358,7 @@ void AudioProvider::findRfc2833(const resip::SdpContents::Session::Medium::Codec
for (codecIter = codecs.begin(); codecIter != codecs.end(); codecIter++)
{
if (strcmp("TELEPHONE-EVENT", codecIter->getName().c_str()) == 0 ||
strcmp("telephone-event", codecIter->getName().c_str()) == 0)
strcmp("telephone-event", codecIter->getName().c_str()) == 0)
mRemoteTelephoneCodec = codecIter->payloadType();
}
}
@@ -379,9 +382,9 @@ void AudioProvider::setupMirror(bool enable)
mActiveStream->setupMirror(enable);
}
void AudioProvider::setStateImpl(unsigned int state)
{
void AudioProvider::setStateImpl(unsigned int state) {
mState = state;
if (mActiveStream)
mActiveStream->setState(state);
}
src/engine/endpoint/EP_AudioProvider.h
+73 -71
View File
@@ -1,4 +1,4 @@
/* Copyright(C) 2007-2023 VoIP objects (voipobjects.com)
/* Copyright(C) 2007-2014 VoIP objects (voipobjects.com)
* 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/. */
@@ -12,109 +12,111 @@
#include "../media/MT_Box.h"
#include "../media/MT_Stream.h"
#include "../media/MT_Codec.h"
#include "../audio/Audio_Interface.h"
#include "rutil/ThreadIf.hxx"
#include <vector>
#include <string>
class UserAgent;
class AudioProvider : public DataProvider
class AudioProvider: public DataProvider
{
public:
AudioProvider(UserAgent& agent, MT::Terminal& terminal);
virtual ~AudioProvider();
// Returns provider RTP name
std::string streamName() override;
AudioProvider(UserAgent& agent, MT::Terminal& terminal);
virtual ~AudioProvider();
// Returns provider RTP profile name
std::string streamProfile() override;
// Returns provider RTP name
std::string streamName() override;
// Sets destination IP address
void setDestinationAddress(const RtpPair<InternetAddress>& addr) override;
// Returns provider RTP profile name
std::string streamProfile() override;
// Processes incoming data
void processData(const PDatagramSocket& s, const void* dataBuffer, int dataSize, InternetAddress& source) override;
// Sets destination IP address
void setDestinationAddress(const RtpPair<InternetAddress>& addr) override;
// This method is called by user agent to send ICE packet from mediasocket
void sendData(const PDatagramSocket& s, InternetAddress& destination, const void* dataBuffer,
unsigned int datasize) override;
// Processes incoming data
void processData(PDatagramSocket s, const void* dataBuffer, int dataSize, InternetAddress& source) override;
// Updates SDP offer
void updateSdpOffer(resip::SdpContents::Session::Medium& sdp, SdpDirection direction) override;
// This method is called by user agent to send ICE packet from mediasocket
void sendData(PDatagramSocket s, InternetAddress& destination, const void* dataBuffer, unsigned int datasize) override;
// Called by user agent when session is deleted.
void sessionDeleted() override;
// Updates SDP offer
void updateSdpOffer(resip::SdpContents::Session::Medium& sdp, SdpDirection direction) override;
// Called by user agent when session is terminated.
void sessionTerminated() override;
// Called by user agent when session is deleted.
void sessionDeleted() override;
// Called by user agent when session is started.
void sessionEstablished(int conntype) override;
// Called by user agent when session is terminated.
void sessionTerminated() override;
// Called by user agent to save media socket for this provider
void setSocket(const RtpPair<PDatagramSocket>& p4, const RtpPair<PDatagramSocket>& p6) override;
// Called by user agent when session is started.
void sessionEstablished(int conntype) override;
// Called by user agent to get media socket for this provider
RtpPair<PDatagramSocket>& socket(int family) override;
// Called by user agent to save media socket for this provider
void setSocket(const RtpPair<PDatagramSocket>& p4, const RtpPair<PDatagramSocket>& p6) override;
// Called by user agent to process media stream description from remote peer.
// Returns true if description is processed succesfully. Otherwise method returns false.
// myAnswer sets if the answer will be sent after.
bool processSdpOffer(const resip::SdpContents::Session::Medium& media, SdpDirection sdpDirection) override;
// Called by user agent to get media socket for this provider
RtpPair<PDatagramSocket>& socket(int family) override;
// Called by user agent to process media stream description from remote peer.
// Returns true if description is processed succesfully. Otherwise method returns false.
// myAnswer sets if the answer will be sent after.
bool processSdpOffer(const resip::SdpContents::Session::Medium& media, SdpDirection sdpDirection) override;
void setState(unsigned state) override;
unsigned state() override;
MT::Statistics getStatistics() override;
MT::PStream activeStream();
void setState(unsigned state) override;
unsigned state() override;
MT::Statistics getStatistics() override;
MT::PStream activeStream();
void readFile(const Audio::PWavFileReader& stream, MT::Stream::MediaDirection direction);
void writeFile(const Audio::PWavFileWriter& stream, MT::Stream::MediaDirection direction);
void setupMirror(bool enable);
void readFile(const Audio::PWavFileReader& stream, MT::Stream::MediaDirection direction);
void writeFile(const Audio::PWavFileWriter& stream, MT::Stream::MediaDirection direction);
void setupMirror(bool enable);
void configureMediaObserver(MT::Stream::MediaObserver* observer, void* userTag);
static SrtpSuite processCryptoAttribute(const resip::Data& value, ByteBuffer& key, int* tag = nullptr);
void configureMediaObserver(MT::Stream::MediaObserver* observer, void* userTag);
protected:
// SDP's stream name
std::string mStreamName;
// SDP's stream name
std::string mStreamName;
// Socket handles to operate
RtpPair<PDatagramSocket> mSocket4, mSocket6;
// Socket handles to operate
RtpPair<PDatagramSocket> mSocket4, mSocket6;
// Destination IP4/6 address
RtpPair<InternetAddress> mDestination;
// Destination IP4/6 address
RtpPair<InternetAddress> mDestination;
MT::PStream mActiveStream;
UserAgent& mUserAgent;
MT::Terminal& mTerminal;
MT::Statistics mBackupStats;
MT::PStream mActiveStream;
UserAgent& mUserAgent;
MT::Terminal& mTerminal;
MT::Statistics mBackupStats;
unsigned mState;
SrtpSuite mSrtpSuite;
int mSrtpTag = 1; // RFC 4568 tag of the negotiated crypto attribute
struct RemoteCodec
{
RemoteCodec(MT::Codec::Factory* factory, int payloadType) : mFactory(factory), mRemotePayloadType(payloadType)
{
}
unsigned mState;
SrtpSuite mSrtpSuite;
struct RemoteCodec
{
RemoteCodec(MT::Codec::Factory* factory, int payloadType)
:mFactory(factory), mRemotePayloadType(payloadType)
{ }
MT::Codec::Factory* mFactory;
int mRemotePayloadType;
};
std::vector<RemoteCodec> mAvailableCodecs;
int mRemoteTelephoneCodec; // Payload type of remote rfc2833 codec
bool mRemoteNoSdp; // Marks if we got no-sdp offer
MT::CodecListPriority mCodecPriority;
MT::Stream::MediaObserver* mMediaObserver = nullptr;
void* mMediaObserverTag = nullptr;
MT::Codec::Factory* mFactory;
int mRemotePayloadType;
};
std::vector<RemoteCodec> mAvailableCodecs;
int mRemoteTelephoneCodec; // Payload type of remote rfc2833 codec
bool mRemoteNoSdp; // Marks if we got no-sdp offer
MT::CodecListPriority mCodecPriority;
MT::Stream::MediaObserver* mMediaObserver = nullptr;
void* mMediaObserverTag = nullptr;
std::string createCryptoAttribute(SrtpSuite suite, int tag);
void findRfc2833(const resip::SdpContents::Session::Medium::CodecContainer& codecs);
std::string createCryptoAttribute(SrtpSuite suite);
SrtpSuite processCryptoAttribute(const resip::Data& value, ByteBuffer& key);
void findRfc2833(const resip::SdpContents::Session::Medium::CodecContainer& codecs);
// Implements setState() logic. This allows to be called from constructor (it is not virtual function)
void setStateImpl(unsigned state);
// Implements setState() logic. This allows to be called from constructor (it is not virtual function)
void setStateImpl(unsigned state);
};
#endif
src/engine/endpoint/EP_DataProvider.cpp
+42 -40
View File
@@ -8,65 +8,67 @@
bool DataProvider::isSupported(const char* name)
{
return !strcmp(name, "audio");
return !strcmp(name, "audio");
// return (!strcmp(name, "screen") || !strcmp(name, "data") || !strcmp(name, "audio") || !strcmp(name, "video"));
//return (!strcmp(name, "screen") || !strcmp(name, "data") || !strcmp(name, "audio") || !strcmp(name, "video"));
}
void DataProvider::pause()
{
/*if (state() & STATE_SIPRECV)
/*if (state() & STATE_SIPRECV)
setState( state() & ~STATE_SIPRECV );*/
// Stop receive RTP stream
if (state() & (int)StreamState::Receiving)
setState(state() & ~(int)StreamState::Receiving);
// Stop receive RTP stream
if (state() & (int)StreamState::Receiving)
setState( state() & ~(int)StreamState::Receiving );
mActive = mfPaused;
mActive = mfPaused;
}
void DataProvider::resume()
{
// Tell remote peer about resumed receiving in SDP
// setState( state() | STATE_SIPRECV );
// Tell remote peer about resumed receiving in SDP
//setState( state() | STATE_SIPRECV );
// Start receive RTP stream
setState(state() | (int)StreamState::Receiving);
// Start receive RTP stream
setState( state() | (int)StreamState::Receiving );
mActive = mfActive;
mActive = mfActive;
}
bool DataProvider::processSdpOffer(const resip::SdpContents::Session::Medium& media, SdpDirection sdpDirection)
{
// Process paused and inactive calls
if (media.exists("sendonly"))
// Process paused and inactive calls
if (media.exists("sendonly"))
{
mRemoteState = msSendonly;
setState(state() & ~(int)StreamState::Sending);
}
else
if (media.exists("recvonly"))
{
mRemoteState = msRecvonly;
setState(state() & ~(int)StreamState::Receiving);
}
else
if (media.exists("inactive"))
{
mRemoteState = msInactive;
setState(state() & ~((int)StreamState::Sending | (int)StreamState::Receiving) );
}
else
{
mRemoteState = msSendRecv;
switch (mActive)
{
mRemoteState = msSendonly;
setState(state() & ~(int)StreamState::Sending);
}
else if (media.exists("recvonly"))
{
mRemoteState = msRecvonly;
setState(state() & ~(int)StreamState::Receiving);
}
else if (media.exists("inactive"))
{
mRemoteState = msInactive;
setState(state() & ~((int)StreamState::Sending | (int)StreamState::Receiving));
}
else
{
mRemoteState = msSendRecv;
switch (mActive)
{
case mfActive:
setState(state() | (int)StreamState::Sending | (int)StreamState::Receiving);
break;
case mfActive:
setState(state() | (int)StreamState::Sending | (int)StreamState::Receiving);
break;
case mfPaused:
setState(state() | (int)StreamState::Sending);
break;
}
case mfPaused:
setState(state() | (int)StreamState::Sending );
break;
}
return true;
}
return true;
}
src/engine/endpoint/EP_DataProvider.h
+47 -48
View File
@@ -10,6 +10,7 @@
#include <vector>
#include "resip/stack/SdpContents.hxx"
#include "rutil/SharedPtr.hxx"
#include "../helper/HL_InternetAddress.h"
#include "../helper/HL_NetworkSocket.h"
@@ -19,75 +20,73 @@
class DataProvider
{
public:
enum MediaFlow
{
mfActive,
mfPaused
};
enum MediaFlow
{
mfActive,
mfPaused
};
enum MediaState
{
msSendRecv,
msSendonly,
msRecvonly,
msInactive
};
enum MediaState
{
msSendRecv,
msSendonly,
msRecvonly,
msInactive
};
static bool isSupported(const char* name);
static bool isSupported(const char* name);
// Returns provider RTP name
virtual std::string streamName() = 0;
// Returns provider RTP name
virtual std::string streamName() = 0;
// Returns provider RTP profile name
virtual std::string streamProfile() = 0;
// Returns provider RTP profile name
virtual std::string streamProfile() = 0;
// Sets destination IP address
virtual void setDestinationAddress(const RtpPair<InternetAddress>& addr) = 0;
// Sets destination IP address
virtual void setDestinationAddress(const RtpPair<InternetAddress>& addr) = 0;
// Processes incoming data
virtual void processData(const PDatagramSocket& s, const void* dataBuffer, int dataSize,
InternetAddress& address) = 0;
// Processes incoming data
virtual void processData(PDatagramSocket s, const void* dataBuffer, int dataSize, InternetAddress& address) = 0;
// This method is called by user agent to send ICE packet from mediasocket
virtual void sendData(const PDatagramSocket& s, InternetAddress& destination, const void* dataBuffer,
unsigned int datasize) = 0;
// This method is called by user agent to send ICE packet from mediasocket
virtual void sendData(PDatagramSocket s, InternetAddress& destination, const void* dataBuffer, unsigned int datasize) = 0;
// Updates SDP offer
virtual void updateSdpOffer(resip::SdpContents::Session::Medium& sdp, SdpDirection direction) = 0;
// Updates SDP offer
virtual void updateSdpOffer(resip::SdpContents::Session::Medium& sdp, SdpDirection direction) = 0;
// Called by user agent when session is deleted. Comes after sessionTerminated().
virtual void sessionDeleted() = 0;
// Called by user agent when session is deleted. Comes after sessionTerminated().
virtual void sessionDeleted() = 0;
// Called by user agent when session is terminated.
virtual void sessionTerminated() = 0;
// Called by user agent when session is terminated.
virtual void sessionTerminated() = 0;
// Called by user agent when session is started.
virtual void sessionEstablished(int conntype) = 0;
// Called by user agent when session is started.
virtual void sessionEstablished(int conntype) = 0;
// Called by user agent to save media socket for this provider
virtual void setSocket(const RtpPair<PDatagramSocket>& p4, const RtpPair<PDatagramSocket>& p6) = 0;
// Called by user agent to save media socket for this provider
virtual void setSocket(const RtpPair<PDatagramSocket>& p4, const RtpPair<PDatagramSocket>& p6) = 0;
// Called by user agent to get media socket for this provider
virtual RtpPair<PDatagramSocket>& socket(int family) = 0;
// Called by user agent to get media socket for this provider
virtual RtpPair<PDatagramSocket>& socket(int family) = 0;
// Called by user agent to process media stream description from remote peer.
// Returns true if description is processed succesfully. Otherwise method returns false.
virtual bool processSdpOffer(const resip::SdpContents::Session::Medium& media, SdpDirection sdpDirection) = 0;
// Called by user agent to process media stream description from remote peer.
// Returns true if description is processed succesfully. Otherwise method returns false.
virtual bool processSdpOffer(const resip::SdpContents::Session::Medium& media, SdpDirection sdpDirection) = 0;
virtual unsigned state() = 0;
virtual void setState(unsigned state) = 0;
virtual unsigned state() = 0;
virtual void setState(unsigned state) = 0;
virtual void pause();
virtual void resume();
virtual void pause();
virtual void resume();
virtual MT::Statistics getStatistics() = 0;
virtual MT::Statistics getStatistics() = 0;
protected:
MediaFlow mActive;
MediaState mRemoteState;
MediaFlow mActive;
MediaState mRemoteState;
};
typedef std::shared_ptr<DataProvider> PDataProvider;
typedef std::shared_ptr<DataProvider> PDataProvider;
typedef std::vector<PDataProvider> DataProviderVector;
#endif
src/engine/endpoint/EP_Engine.cpp
+1026 -1088
View File
File diff suppressed because it is too large Load Diff
src/engine/endpoint/EP_Engine.h
+280 -290
View File
@@ -47,7 +47,7 @@
#include "../ice/ICETime.h"
#include <sstream>
#include <time.h>
#include "../engine_config.h"
#include "../config.h"
#include "EP_Session.h"
#include "EP_Observer.h"
#include "EP_DataProvider.h"
@@ -70,54 +70,52 @@ enum
enum
{
CONFIG_IPV4 = 0, // Use IP4
CONFIG_IPV6, // Use IP6.
CONFIG_USERNAME, // Username. String value.
CONFIG_DOMAIN, // Domain. String value.
CONFIG_PASSWORD, // Password. String value.
CONFIG_RINSTANCE, // Determines if SIP rinstance field has to be used during registration. Boolean value.
CONFIG_INSTANCE_ID, // Instance id. It is alternative option to rinstance.
CONFIG_DISPLAYNAME, // Optional user display name. String value.
CONFIG_DOMAINPORT, // Optional domain port number. Integer value.
CONFIG_REGISTERDURATION, // Wanted duration for registration. Integer value. It is MANDATORY value.
CONFIG_RPORT, // Use SIP rport field. Recommended to set it to true. Boolean value.
CONFIG_KEEPALIVETIME, // Interval between UDP keep-alive messages. Boolean value.
CONFIG_RELAY, // Sets if TURN server must be used instead of STUN. Boolean value.
CONFIG_ICETIMEOUT, // Optional timeout for ICE connectivity checks and candidate gathering. Integer value.
CONFIG_ICEUSERNAME, // Optional username for TURN server. String value.
CONFIG_ICEPASSWORD, // Optional password for TURN server. String value.
CONFIG_SIPS, // Marks if account credentials are sips: scheme. Boolean value.
CONFIG_STUNSERVER_IP, // Optional IP address of STUN/TURN server. String value. It is better to use
// CONFIG_STUNSERVER_NAME.
CONFIG_STUNSERVER_NAME, // Host name of STUN/TURN server. stun.xten.com for example. String value.
CONFIG_STUNSERVER_PORT, // Port number of STUN/TURN server. Integer value.
CONFIG_USERAGENT, // Name of user agent in SIP headers. String value.
CONFIG_ICEREQUIRED, // ICE MUST be present in remote peer offers and answers. Boolean value.
CONFIG_TRANSPORT, // 0 - all transports, 1 - UDP, 2 - TCP, 3 - TLS,
CONFIG_SUBSCRIPTION_TIME, // Subscription time (in seconds)
CONFIG_SUBSCRIPTION_REFRESHTIME, // Refresh interval for subscriptions
CONFIG_DNS_CACHE_TIME, // DNS cache time; default is 86400 seconds
CONFIG_PRESENCE_ID, // Tuple ID used in presence publishing; determines source device
CONFIG_ROOTCERT, // Additional root cert in PEM format; string.
CONFIG_CACHECREDENTIALS, // Attempt to cache credentials that comes in response from PBX. Use them when possible to
// reduce number of steps of SIP transaction
CONFIG_RTCP_ATTR, // Use "rtcp" attribute in sdp. Default value is true.
CONFIG_MULTIPLEXING, // Do rtp/rtcp multiplexing
CONFIG_DEFERRELAYED, // Defer relayed media path
CONFIG_PROXY, // Proxy host name or IP address
CONFIG_PROXYPORT, // Proxy port number
CONFIG_CODEC_PRIORITY, // Another VariantMap with codec priorities,
CONFIG_ACCOUNT, // VariantMap with account configuration
CONFIG_EXTERNALIP, // Use external/public IP in outgoing requests
CONFIG_OWN_DNS, // Use predefined DNS servers
CONFIG_REGID // reg-id value from RFC5626,
CONFIG_IPV4 = 0, // Use IP4
CONFIG_IPV6, // Use IP6.
CONFIG_USERNAME, // Username. String value.
CONFIG_DOMAIN, // Domain. String value.
CONFIG_PASSWORD, // Password. String value.
CONFIG_RINSTANCE, // Determines if SIP rinstance field has to be used during registration. Boolean value.
CONFIG_INSTANCE_ID, // Instance id. It is alternative option to rinstance.
CONFIG_DISPLAYNAME, // Optional user display name. String value.
CONFIG_DOMAINPORT, // Optional domain port number. Integer value.
CONFIG_REGISTERDURATION, // Wanted duration for registration. Integer value. It is MANDATORY value.
CONFIG_RPORT, // Use SIP rport field. Recommended to set it to true. Boolean value.
CONFIG_KEEPALIVETIME, // Interval between UDP keep-alive messages. Boolean value.
CONFIG_RELAY, // Sets if TURN server must be used instead of STUN. Boolean value.
CONFIG_ICETIMEOUT, // Optional timeout for ICE connectivity checks and candidate gathering. Integer value.
CONFIG_ICEUSERNAME, // Optional username for TURN server. String value.
CONFIG_ICEPASSWORD, // Optional password for TURN server. String value.
CONFIG_SIPS, // Marks if account credentials are sips: scheme. Boolean value.
CONFIG_STUNSERVER_IP, // Optional IP address of STUN/TURN server. String value. It is better to use CONFIG_STUNSERVER_NAME.
CONFIG_STUNSERVER_NAME, // Host name of STUN/TURN server. stun.xten.com for example. String value.
CONFIG_STUNSERVER_PORT, // Port number of STUN/TURN server. Integer value.
CONFIG_USERAGENT, // Name of user agent in SIP headers. String value.
CONFIG_ICEREQUIRED, // ICE MUST be present in remote peer offers and answers. Boolean value.
CONFIG_TRANSPORT, // 0 - all transports, 1 - UDP, 2 - TCP, 3 - TLS,
CONFIG_SUBSCRIPTION_TIME, // Subscription time (in seconds)
CONFIG_SUBSCRIPTION_REFRESHTIME, // Refresh interval for subscriptions
CONFIG_DNS_CACHE_TIME, // DNS cache time; default is 86400 seconds
CONFIG_PRESENCE_ID, // Tuple ID used in presence publishing; determines source device
CONFIG_ROOTCERT, // Additional root cert in PEM format; string.
CONFIG_CACHECREDENTIALS, // Attempt to cache credentials that comes in response from PBX. Use them when possible to reduce number of steps of SIP transaction
CONFIG_RTCP_ATTR, // Use "rtcp" attribute in sdp. Default value is true.
CONFIG_MULTIPLEXING, // Do rtp/rtcp multiplexing
CONFIG_DEFERRELAYED, // Defer relayed media path
CONFIG_PROXY, // Proxy host name or IP address
CONFIG_PROXYPORT, // Proxy port number
CONFIG_CODEC_PRIORITY, // Another VariantMap with codec priorities,
CONFIG_ACCOUNT, // VariantMap with account configuration
CONFIG_EXTERNALIP, // Use external/public IP in outgoing requests
CONFIG_OWN_DNS, // Use predefined DNS servers
CONFIG_REGID // reg-id value from RFC5626
};
// Conntype parameter for OnSessionEstablished event
enum
{
EV_SIP = 1,
EV_ICE = 2
EV_SIP = 1,
EV_ICE = 2
};
class UserAgent;
@@ -126,7 +124,7 @@ class UserAgent;
class SIPAction
{
public:
virtual void Run(UserAgent& ua) = 0;
virtual void Run(UserAgent& ua) = 0;
};
typedef std::vector<SIPAction*> SIPActionVector;
@@ -134,18 +132,18 @@ typedef std::vector<SIPAction*> SIPActionVector;
// Session termination reason
enum
{
Error,
Timeout,
Replaced,
LocalBye,
RemoteBye,
LocalCancel,
RemoteCancel,
Rejected, // Only as UAS, UAC has distinct onFailure callback
Referred
Error,
Timeout,
Replaced,
LocalBye,
RemoteBye,
LocalCancel,
RemoteCancel,
Rejected, //Only as UAS, UAC has distinct onFailure callback
Referred
};
class UserAgent : public resip::ClientRegistrationHandler,
class UserAgent: public resip::ClientRegistrationHandler,
public resip::InviteSessionHandler,
public resip::DumShutdownHandler,
public resip::ExternalLogger,
@@ -154,244 +152,238 @@ class UserAgent : public resip::ClientRegistrationHandler,
public resip::ServerSubscriptionHandler,
public resip::ClientPagerMessageHandler,
public resip::ServerPagerMessageHandler,
public resip::ClientPublicationHandler
// public resip::InternalTransport::TransportLogger
public resip::ClientPublicationHandler,
public resip::InternalTransport::TransportLogger
{
friend class Account;
friend class Session;
friend class ResipSession;
friend class NATDecorator;
friend class WatcherQueue;
friend class Account;
friend class Session;
friend class ResipSession;
friend class NATDecorator;
friend class WatcherQueue;
public:
/* Compares two sip addresses. Returns true if they represent the same entity - user and domain are the same.
* Otherwise returns false. */
static bool compareSipAddresses(const std::string& sip1, const std::string& sip2);
static std::string formatSipAddress(const std::string& sip);
static bool isSipAddressValid(const std::string& sip);
struct SipAddress
{
bool mValid;
std::string mScheme;
std::string mUsername;
std::string mDomain;
std::string mDisplayname;
};
/* Compares two sip addresses. Returns true if they represent the same entity - user and domain are the same. Otherwise returns false. */
static bool compareSipAddresses(std::string sip1, std::string sip2);
static std::string formatSipAddress(std::string sip);
static bool isSipAddressValid(std::string sip);
struct SipAddress
{
bool mValid;
std::string mScheme;
std::string mUsername;
std::string mDomain;
std::string mDisplayname;
};
static SipAddress parseSipAddress(const std::string& sip);
static SipAddress parseSipAddress(const std::string& sip);
UserAgent();
virtual ~UserAgent();
UserAgent();
virtual ~UserAgent();
/* Brings user agent online. Basically it creates a signalling socket(s).
/* Brings user agent online. Basically it creates a signalling socket(s).
This is asynchronous method. */
void start();
void start();
/* Shutdowns user agent. It closes all sessions, tries to unregister from server and disconnects from it.
/* Shutdowns user agent. It closes all sessions, tries to unregister from server and disconnects from it.
This is asynchronous method. onStop() event will be called later */
void shutdown();
void shutdown();
/* Emergency stop. Please always call shutdown() before this. Kills registration, sessions & presence - everything.
* onStop() is called in context of this method. */
void stop();
/* Emergency stop. Please always call shutdown() before this. Kills registration, sessions & presence - everything. onStop() is called in context of this method. */
void stop();
/* Checks if user agent is active (started). */
bool active();
/* Checks if user agent is active (started). */
bool active();
/* Used to refresh existing registration(s), publication, subscriptions. */
void refresh();
/* Used to refresh existing registration(s), publication, subscriptions. */
void refresh();
/* Runs sip & ice stacks. Event handlers are called in its context. */
void process();
/* Runs sip & ice stacks. Event handlers are called in its context. */
void process();
/* Adds root cert in PEM format. Usable after start() call. */
void addRootCert(const ByteBuffer& data);
/* Adds root cert in PEM format. Usable after start() call. */
void addRootCert(const ByteBuffer& data);
PAccount createAccount(PVariantMap config);
void deleteAccount(PAccount account);
PAccount createAccount(PVariantMap config);
void deleteAccount(PAccount account);
/* Creates session. Returns session ID. */
PSession createSession(PAccount account);
/* Creates session. Returns session ID. */
PSession createSession(PAccount account);
// Must be called when IP interface list is changed
void updateInterfaceList();
// Must be called when IP interface list is changed
void updateInterfaceList();
// Called on new incoming session; providers shoukld
virtual PDataProvider onProviderNeeded(const std::string& name) = 0;
// Called on new incoming session; providers shoukld
virtual PDataProvider onProviderNeeded(const std::string& name) = 0;
// Called on new session offer
virtual void onNewSession(PSession s) = 0;
// Called on new session offer
virtual void onNewSession(PSession s) = 0;
// Called when session is terminated
virtual void onSessionTerminated(PSession s, int responsecode, int reason) = 0;
// Called when session is terminated
virtual void onSessionTerminated(PSession s, int responsecode, int reason) = 0;
// Called when session is established ok i.e. after all ICE signalling is finished
// Conntype is type of establish event - EV_SIP or EV_ICE
virtual void onSessionEstablished(PSession s, int conntype, const RtpPair<InternetAddress>& p) = 0;
// Called when session is established ok i.e. after all ICE signalling is finished
// Conntype is type of establish event - EV_SIP or EV_ICE
virtual void onSessionEstablished(PSession s, int conntype, const RtpPair<InternetAddress>& p) = 0;
// Called when client session gets
virtual void onSessionProvisional(PSession s, int code) = 0;
// Called when client session gets
virtual void onSessionProvisional(PSession s, int code) = 0;
// Called when user agent started
virtual void onStart(int errorcode) = 0;
// Called when user agent started
virtual void onStart(int errorcode) = 0;
// Called when user agent stopped
virtual void onStop() = 0;
// Called when user agent stopped
virtual void onStop() = 0;
// Called when account registered
virtual void onAccountStart(PAccount account) = 0;
// Called when account registered
virtual void onAccountStart(PAccount account) = 0;
// Called when account removed or failed (non zero error code)
virtual void onAccountStop(PAccount account, int error) = 0;
// Called when account removed or failed (non zero error code)
virtual void onAccountStop(PAccount account, int error) = 0;
// Called when connectivity checks failed.
virtual void onConnectivityFailed(PSession s) = 0;
// Called when connectivity checks failed.
virtual void onConnectivityFailed(PSession s) = 0;
// Called when new candidate is gathered
virtual void onCandidateGathered(PSession s, const char* address);
// Called when new candidate is gathered
virtual void onCandidateGathered(PSession s, const char* address);
// Called when network change detected
virtual void onNetworkChange(PSession s) = 0;
// Called when network change detected
virtual void onNetworkChange(PSession s) = 0;
// Called when all candidates are gathered
virtual void onGathered(PSession s);
// Called when all candidates are gathered
virtual void onGathered(PSession s);
// Called when new connectivity check is finished
virtual void onCheckFinished(PSession s, const char* description);
// Called when new connectivity check is finished
virtual void onCheckFinished(PSession s, const char* description);
// Called when log message must be recorded
virtual void onLog(const char* msg);
// Called when log message must be recorded
virtual void onLog(const char* msg);
// Called when problem with SIP connection(s) detected
virtual void onSipConnectionFailed() = 0;
// Called when problem with SIP connection(s) detected
virtual void onSipConnectionFailed() = 0;
// Subscribe/publish presence methods
virtual void onPublicationSuccess(PAccount acc);
virtual void onPublicationTerminated(PAccount acc, int code);
virtual void onClientObserverStart(PClientObserver observer);
virtual void onServerObserverStart(PServerObserver observer);
virtual void onClientObserverStop(PClientObserver observer, int code);
virtual void onServerObserverStop(PServerObserver observer, int code);
// Subscribe/publish presence methods
virtual void onPublicationSuccess(PAccount acc);
virtual void onPublicationTerminated(PAccount acc, int code);
virtual void onClientObserverStart(PClientObserver observer);
virtual void onServerObserverStart(PServerObserver observer);
virtual void onClientObserverStop(PClientObserver observer, int code);
virtual void onServerObserverStop(PServerObserver observer, int code);
virtual void onPresenceUpdate(PClientObserver observer, const std::string& peer, bool online,
const std::string& content);
virtual void onMessageArrived(PAccount account, const std::string& peer, const void* ptr, unsigned length);
virtual void onMessageFailed(PAccount account, int id, const std::string& peer, int code, void* tag);
virtual void onMessageSent(PAccount account, int id, const std::string& peer, void* tag);
virtual void onPresenceUpdate(PClientObserver observer, const std::string& peer, bool online, const std::string& content);
virtual void onMessageArrived(PAccount account, const std::string& peer, const void* ptr, unsigned length);
virtual void onMessageFailed(PAccount account, int id, const std::string& peer, int code, void* tag);
virtual void onMessageSent(PAccount account, int id, const std::string& peer, void* tag);
// Configuration methods
VariantMap& config();
// Configuration methods
VariantMap& config();
public:
// InviteSessionHandler implementation
// InviteSessionHandler implementation
#pragma region InviteSessionHandler implementation
/// called when an initial INVITE or the intial response to an outoing invite
virtual void onNewSession(resip::ClientInviteSessionHandle, resip::InviteSession::OfferAnswerType oat,
const resip::SipMessage& msg) override;
virtual void onNewSession(resip::ServerInviteSessionHandle, resip::InviteSession::OfferAnswerType oat,
const resip::SipMessage& msg) override;
/// called when an initial INVITE or the intial response to an outoing invite
virtual void onNewSession(resip::ClientInviteSessionHandle, resip::InviteSession::OfferAnswerType oat, const resip::SipMessage& msg) override;
virtual void onNewSession(resip::ServerInviteSessionHandle, resip::InviteSession::OfferAnswerType oat, const resip::SipMessage& msg) override;
/// Received a failure response from UAS
virtual void onFailure(resip::ClientInviteSessionHandle, const resip::SipMessage& msg) override;
/// Received a failure response from UAS
virtual void onFailure(resip::ClientInviteSessionHandle, const resip::SipMessage& msg) override;
/// called when an in-dialog provisional response is received that contains an SDP body
virtual void onEarlyMedia(resip::ClientInviteSessionHandle, const resip::SipMessage&,
const resip::SdpContents&) override;
/// called when an in-dialog provisional response is received that contains an SDP body
virtual void onEarlyMedia(resip::ClientInviteSessionHandle, const resip::SipMessage&, const resip::SdpContents&) override;
/// called when dialog enters the Early state - typically after getting 18x
virtual void onProvisional(resip::ClientInviteSessionHandle, const resip::SipMessage&) override;
/// called when dialog enters the Early state - typically after getting 18x
virtual void onProvisional(resip::ClientInviteSessionHandle, const resip::SipMessage&) override;
/// called when a dialog initiated as a UAC enters the connected state
virtual void onConnected(resip::ClientInviteSessionHandle, const resip::SipMessage& msg) override;
/// called when a dialog initiated as a UAC enters the connected state
virtual void onConnected(resip::ClientInviteSessionHandle, const resip::SipMessage& msg) override;
/// called when a dialog initiated as a UAS enters the connected state
virtual void onConnected(resip::InviteSessionHandle, const resip::SipMessage& msg) override;
/// called when a dialog initiated as a UAS enters the connected state
virtual void onConnected(resip::InviteSessionHandle, const resip::SipMessage& msg) override;
virtual void onTerminated(resip::InviteSessionHandle, resip::InviteSessionHandler::TerminatedReason reason,
const resip::SipMessage* related = 0) override;
virtual void onTerminated(resip::InviteSessionHandle, resip::InviteSessionHandler::TerminatedReason reason, const resip::SipMessage* related=0) override;
/// called when a fork that was created through a 1xx never receives a 2xx
/// because another fork answered and this fork was canceled by a proxy.
virtual void onForkDestroyed(resip::ClientInviteSessionHandle) override;
/// called when a fork that was created through a 1xx never receives a 2xx
/// because another fork answered and this fork was canceled by a proxy.
virtual void onForkDestroyed(resip::ClientInviteSessionHandle) override;
/// called when a 3xx with valid targets is encountered in an early dialog
/// This is different then getting a 3xx in onTerminated, as another
/// request will be attempted, so the DialogSet will not be destroyed.
/// Basically an onTermintated that conveys more information.
/// checking for 3xx respones in onTerminated will not work as there may
/// be no valid targets.
virtual void onRedirected(resip::ClientInviteSessionHandle, const resip::SipMessage& msg) override;
/// called when a 3xx with valid targets is encountered in an early dialog
/// This is different then getting a 3xx in onTerminated, as another
/// request will be attempted, so the DialogSet will not be destroyed.
/// Basically an onTermintated that conveys more information.
/// checking for 3xx respones in onTerminated will not work as there may
/// be no valid targets.
virtual void onRedirected(resip::ClientInviteSessionHandle, const resip::SipMessage& msg) override;
/// called when an SDP answer is received - has nothing to do with user
/// answering the call
virtual void onAnswer(resip::InviteSessionHandle, const resip::SipMessage& msg, const resip::SdpContents&) override;
/// called when an SDP answer is received - has nothing to do with user
/// answering the call
virtual void onAnswer(resip::InviteSessionHandle, const resip::SipMessage& msg, const resip::SdpContents&) override;
/// called when an SDP offer is received - must send an answer soon after this
virtual void onOffer(resip::InviteSessionHandle, const resip::SipMessage& msg, const resip::SdpContents&) override;
/// called when an SDP offer is received - must send an answer soon after this
virtual void onOffer(resip::InviteSessionHandle, const resip::SipMessage& msg, const resip::SdpContents&) override;
/// called when an Invite w/out SDP is sent, or any other context which
/// requires an SDP offer from the user
virtual void onOfferRequired(resip::InviteSessionHandle, const resip::SipMessage& msg) override;
/// called when an Invite w/out SDP is sent, or any other context which
/// requires an SDP offer from the user
virtual void onOfferRequired(resip::InviteSessionHandle, const resip::SipMessage& msg) override;
/// called if an offer in a UPDATE or re-INVITE was rejected - not real
/// useful. A SipMessage is provided if one is available
virtual void onOfferRejected(resip::InviteSessionHandle, const resip::SipMessage* msg) override;
/// called if an offer in a UPDATE or re-INVITE was rejected - not real
/// useful. A SipMessage is provided if one is available
virtual void onOfferRejected(resip::InviteSessionHandle, const resip::SipMessage* msg) override;
/// called when INFO message is received
virtual void onInfo(resip::InviteSessionHandle, const resip::SipMessage& msg) override;
/// called when INFO message is received
virtual void onInfo(resip::InviteSessionHandle, const resip::SipMessage& msg) override;
/// called when response to INFO message is received
virtual void onInfoSuccess(resip::InviteSessionHandle, const resip::SipMessage& msg) override;
virtual void onInfoFailure(resip::InviteSessionHandle, const resip::SipMessage& msg) override;
/// called when response to INFO message is received
virtual void onInfoSuccess(resip::InviteSessionHandle, const resip::SipMessage& msg) override;
virtual void onInfoFailure(resip::InviteSessionHandle, const resip::SipMessage& msg) override;
/// called when MESSAGE message is received
virtual void onMessage(resip::InviteSessionHandle, const resip::SipMessage& msg) override;
/// called when MESSAGE message is received
virtual void onMessage(resip::InviteSessionHandle, const resip::SipMessage& msg) override;
/// called when response to MESSAGE message is received
virtual void onMessageSuccess(resip::InviteSessionHandle, const resip::SipMessage& msg) override;
virtual void onMessageFailure(resip::InviteSessionHandle, const resip::SipMessage& msg) override;
/// called when response to MESSAGE message is received
virtual void onMessageSuccess(resip::InviteSessionHandle, const resip::SipMessage& msg) override;
virtual void onMessageFailure(resip::InviteSessionHandle, const resip::SipMessage& msg) override;
/// called when an REFER message is received. The refer is accepted or
/// rejected using the server subscription. If the offer is accepted,
/// DialogUsageManager::makeInviteSessionFromRefer can be used to create an
/// InviteSession that will send notify messages using the ServerSubscription
virtual void onRefer(resip::InviteSessionHandle, resip::ServerSubscriptionHandle,
const resip::SipMessage& msg) override;
/// called when an REFER message is received. The refer is accepted or
/// rejected using the server subscription. If the offer is accepted,
/// DialogUsageManager::makeInviteSessionFromRefer can be used to create an
/// InviteSession that will send notify messages using the ServerSubscription
virtual void onRefer(resip::InviteSessionHandle, resip::ServerSubscriptionHandle, const resip::SipMessage& msg) override;
virtual void onReferNoSub(resip::InviteSessionHandle, const resip::SipMessage& msg) override;
virtual void onReferNoSub(resip::InviteSessionHandle, const resip::SipMessage& msg) override;
/// called when an REFER message receives a failure response
virtual void onReferRejected(resip::InviteSessionHandle, const resip::SipMessage& msg) override;
/// called when an REFER message receives a failure response
virtual void onReferRejected(resip::InviteSessionHandle, const resip::SipMessage& msg) override;
/// called when an REFER message receives an accepted response
virtual void onReferAccepted(resip::InviteSessionHandle, resip::ClientSubscriptionHandle,
const resip::SipMessage& msg) override;
/// called when an REFER message receives an accepted response
virtual void onReferAccepted(resip::InviteSessionHandle, resip::ClientSubscriptionHandle, const resip::SipMessage& msg) override;
#pragma endregion
// ClientRegistrationHandler implementation
// ClientRegistrationHandler implementation
#pragma region ClientRegistrationHandler implementation
/// Called when registraion succeeds or each time it is sucessfully
/// refreshed.
void onSuccess(resip::ClientRegistrationHandle, const resip::SipMessage& response) override;
/// Called when registraion succeeds or each time it is sucessfully
/// refreshed.
void onSuccess(resip::ClientRegistrationHandle, const resip::SipMessage& response) override;
// Called when all of my bindings have been removed
void onRemoved(resip::ClientRegistrationHandle, const resip::SipMessage& response) override;
// Called when all of my bindings have been removed
void onRemoved(resip::ClientRegistrationHandle, const resip::SipMessage& response) override;
/// call on Retry-After failure.
/// return values: -1 = fail, 0 = retry immediately, N = retry in N seconds
int onRequestRetry(resip::ClientRegistrationHandle, int retrySeconds, const resip::SipMessage& response) override;
/// call on Retry-After failure.
/// return values: -1 = fail, 0 = retry immediately, N = retry in N seconds
int onRequestRetry(resip::ClientRegistrationHandle, int retrySeconds, const resip::SipMessage& response) override;
/// Called if registration fails, usage will be destroyed (unless a
/// Registration retry interval is enabled in the Profile)
void onFailure(resip::ClientRegistrationHandle, const resip::SipMessage& response) override;
/// Called if registration fails, usage will be destroyed (unless a
/// Registration retry interval is enabled in the Profile)
void onFailure(resip::ClientRegistrationHandle, const resip::SipMessage& response) override;
#pragma endregion
#pragma region ExternalLogger implementation
/** return true to also do default logging, false to suppress default logging. */
virtual bool operator()(resip::Log::Level level, const resip::Subsystem& subsystem, const resip::Data& appName,
const char* file, int line, const resip::Data& message,
const resip::Data& messageWithHeaders, const resip::Data& instanceName) override;
/** return true to also do default logging, false to suppress default logging. */
virtual bool operator()(resip::Log::Level level,
const resip::Subsystem& subsystem,
const resip::Data& appName,
const char* file,
int line,
const resip::Data& message,
const resip::Data& messageWithHeaders) override;
#pragma endregion
#pragma region DnsResultSink implementation
@@ -405,98 +397,96 @@ public:
#pragma endregion
#pragma region TransportLogger implementation
void onSipMessage(int flow, const char* msg, unsigned int length, const sockaddr* addr, unsigned int addrlen);
#pragma endregion
void onSipMessage(int flow, const char* msg, unsigned int length, const sockaddr* addr, unsigned int addrlen) override;
#pragma endregion
#pragma region ClientPublicationHandler
void onSuccess(resip::ClientPublicationHandle, const resip::SipMessage& status) override;
void onRemove(resip::ClientPublicationHandle, const resip::SipMessage& status) override;
void onFailure(resip::ClientPublicationHandle, const resip::SipMessage& status) override;
int onRequestRetry(resip::ClientPublicationHandle, int retrySeconds, const resip::SipMessage& status) override;
void onSuccess(resip::ClientPublicationHandle, const resip::SipMessage& status) override;
void onRemove(resip::ClientPublicationHandle, const resip::SipMessage& status) override;
void onFailure(resip::ClientPublicationHandle, const resip::SipMessage& status) override;
int onRequestRetry(resip::ClientPublicationHandle, int retrySeconds, const resip::SipMessage& status) override;
#pragma endregion
#pragma region SubscriptionHandler
void onUpdate(resip::ClientSubscriptionHandle h, const resip::SipMessage& notify);
void onUpdatePending(resip::ClientSubscriptionHandle, const resip::SipMessage& notify, bool outOfOrder) override;
void onUpdateActive(resip::ClientSubscriptionHandle, const resip::SipMessage& notify, bool outOfOrder) override;
void onUpdate(resip::ClientSubscriptionHandle h, const resip::SipMessage& notify);
void onUpdatePending(resip::ClientSubscriptionHandle, const resip::SipMessage& notify, bool outOfOrder) override;
void onUpdateActive(resip::ClientSubscriptionHandle, const resip::SipMessage& notify, bool outOfOrder) override;
// unknown Subscription-State value
void onUpdateExtension(resip::ClientSubscriptionHandle, const resip::SipMessage& notify, bool outOfOrder) override;
int onRequestRetry(resip::ClientSubscriptionHandle, int retrySeconds, const resip::SipMessage& notify) override;
//unknown Subscription-State value
void onUpdateExtension(resip::ClientSubscriptionHandle, const resip::SipMessage& notify, bool outOfOrder) override;
int onRequestRetry(resip::ClientSubscriptionHandle, int retrySeconds, const resip::SipMessage& notify) override;
// subscription can be ended through a notify or a failure response.
void onTerminated(resip::ClientSubscriptionHandle, const resip::SipMessage* msg) override;
// not sure if this has any value.
void onNewSubscription(resip::ClientSubscriptionHandle, const resip::SipMessage& notify) override;
//subscription can be ended through a notify or a failure response.
void onTerminated(resip::ClientSubscriptionHandle, const resip::SipMessage* msg) override;
//not sure if this has any value.
void onNewSubscription(resip::ClientSubscriptionHandle, const resip::SipMessage& notify) override;
/// called to allow app to adorn a message.
void onReadyToSend(resip::ClientSubscriptionHandle, resip::SipMessage& msg) override;
void onNotifyNotReceived(resip::ClientSubscriptionHandle) override;
/// called to allow app to adorn a message.
void onReadyToSend(resip::ClientSubscriptionHandle, resip::SipMessage& msg) override;
void onNotifyNotReceived(resip::ClientSubscriptionHandle) override;
/// Called when a TCP or TLS flow to the server has terminated. This can be caused by socket
/// errors, or missing CRLF keep alives pong responses from the server.
// Called only if clientOutbound is enabled on the UserProfile and the first hop server
/// supports RFC5626 (outbound).
/// Default implementation is to re-form the subscription using a new flow
void onFlowTerminated(resip::ClientSubscriptionHandle) override;
void onNewSubscription(resip::ServerSubscriptionHandle, const resip::SipMessage& sub) override;
void onTerminated(resip::ServerSubscriptionHandle) override;
/// Called when a TCP or TLS flow to the server has terminated. This can be caused by socket
/// errors, or missing CRLF keep alives pong responses from the server.
// Called only if clientOutbound is enabled on the UserProfile and the first hop server
/// supports RFC5626 (outbound).
/// Default implementation is to re-form the subscription using a new flow
void onFlowTerminated(resip::ClientSubscriptionHandle) override;
void onNewSubscription(resip::ServerSubscriptionHandle, const resip::SipMessage& sub) override;
void onTerminated(resip::ServerSubscriptionHandle) override;
#pragma endregion
#pragma region PagerHandler
void onSuccess(resip::ClientPagerMessageHandle, const resip::SipMessage& status) override;
void onFailure(resip::ClientPagerMessageHandle, const resip::SipMessage& status,
std::unique_ptr<resip::Contents> contents) override;
void onMessageArrived(resip::ServerPagerMessageHandle, const resip::SipMessage& message) override;
void onSuccess(resip::ClientPagerMessageHandle, const resip::SipMessage& status) override;
void onFailure(resip::ClientPagerMessageHandle, const resip::SipMessage& status, std::unique_ptr<resip::Contents> contents) override;
void onMessageArrived(resip::ServerPagerMessageHandle, const resip::SipMessage& message) override;
#pragma endregion
void onDumCanBeDeleted() override;
void onDumCanBeDeleted() override;
protected:
// Mutex to protect this instance
Mutex mGuard;
// Mutex to protect this instance
Mutex mGuard;
// Smart pointer to resiprocate's master profile instance. The stack configuration holds here.
std::shared_ptr<resip::MasterProfile> mProfile;
// Smart pointer to resiprocate's master profile instance. The stack configuration holds here.
resip::SharedPtr<resip::MasterProfile> mProfile;
// Resiprocate's SIP stack object pointer
resip::SipStack* mStack;
// Resiprocate's SIP stack object pointer
resip::SipStack* mStack;
// Resiprocate's dialog usage manager object pointer
resip::DialogUsageManager* mDum;
// Resiprocate's dialog usage manager object pointer
resip::DialogUsageManager* mDum;
// List of available transports. They are owned by SipStack - so there is no need to delete instances in UserAgent.
std::vector<resip::InternalTransport*> mTransportList;
// List of available transports. They are owned by SipStack - so there is no need to delete instances in UserAgent.
std::vector<resip::InternalTransport*> mTransportList;
typedef std::map<int, PSession> SessionMap;
typedef std::map<int, PSession> SessionMap;
// Session's map
SessionMap mSessionMap;
// Session's map
SessionMap mSessionMap;
// Used configuration
VariantMap mConfig;
// Used configuration
VariantMap mConfig;
// Action vector
SIPActionVector mActionVector;
// Action vector
SIPActionVector mActionVector;
typedef std::map<int, PClientObserver> ClientObserverMap;
ClientObserverMap mClientObserverMap;
typedef std::map<int, PClientObserver> ClientObserverMap;
ClientObserverMap mClientObserverMap;
typedef std::map<int, PServerObserver> ServerObserverMap;
ServerObserverMap mServerObserverMap;
typedef std::map<int, PServerObserver> ServerObserverMap;
ServerObserverMap mServerObserverMap;
typedef std::set<PAccount> AccountSet;
AccountSet mAccountSet;
typedef std::set<PAccount> AccountSet;
AccountSet mAccountSet;
// Constructs and sends INVITE to remote peer. Remote peer address is stored inside session object.
void sendOffer(Session* session);
void internalStopSession(Session& session);
void processWatchingList();
bool handleMultipartRelatedNotify(const resip::SipMessage& notify);
// Constructs and sends INVITE to remote peer. Remote peer address is stored inside session object.
void sendOffer(Session* session);
void internalStopSession(Session& session);
void processWatchingList();
bool handleMultipartRelatedNotify(const resip::SipMessage& notify);
PSession getUserSession(int sessionId);
PAccount getAccount(const resip::NameAddr& myAddr);
PAccount getAccount(Account* account);
PAccount getAccount(int sessionId);
PSession getUserSession(int sessionId);
PAccount getAccount(const resip::NameAddr& myAddr);
PAccount getAccount(Account* account);
PAccount getAccount(int sessionId);
};
#endif
src/engine/endpoint/EP_NetworkQueue.cpp
+131 -125
View File
@@ -1,176 +1,182 @@
#include "EP_NetworkQueue.h"
#include "EP_Engine.h"
WatcherQueue::WatcherQueue(UserAgent& ua) : mActiveId(0), mAgent(ua) {}
WatcherQueue::WatcherQueue(UserAgent& ua)
:mActiveId(0), mAgent(ua)
{}
WatcherQueue::~WatcherQueue() {}
WatcherQueue::~WatcherQueue()
{}
int WatcherQueue::add(const std::string& peer, const std::string& package, void* tag)
int WatcherQueue::add(std::string peer, std::string package, void* tag)
{
ice::Lock l(mGuard);
ice::Lock l(mGuard);
// Check if queue has similar item
for (unsigned i = 0; i < mItemList.size(); i++)
{
Item& item = mItemList[i];
if (item.mTarget == peer && item.mPackage == package && item.mState != Item::State_Deleting)
return item.mId;
}
// Check if queue has similar item
for (unsigned i=0; i<mItemList.size(); i++)
{
Item& item = mItemList[i];
if (item.mTarget == peer && item.mPackage == package &&
item.mState != Item::State_Deleting)
return item.mId;
}
Item item;
item.mTarget = peer;
item.mPackage = package;
item.mTag = tag;
item.mState = Item::State_ScheduledToAdd;
item.mSession = new ResipSession(*mAgent.mDum);
item.mSession->setUa(&mAgent);
item.mSession->setType(ResipSession::Type_Subscription);
item.mSession->setTag(tag);
item.mId = item.mSession->sessionId();
item.mSession->setRemoteAddress(peer);
item.mTag = tag;
mItemList.push_back(item);
process();
Item item;
item.mTarget = peer;
item.mPackage = package;
item.mTag = tag;
item.mState = Item::State_ScheduledToAdd;
item.mSession = new ResipSession(*mAgent.mDum);
item.mSession->setUa(&mAgent);
item.mSession->setType(ResipSession::Type_Subscription);
item.mSession->setTag(tag);
item.mId = item.mSession->sessionId();
item.mSession->setRemoteAddress(peer);
item.mTag = tag;
mItemList.push_back(item);
process();
return item.mId;
return item.mId;
}
void WatcherQueue::remove(int id)
{
ice::Lock l(mGuard);
ice::Lock l(mGuard);
// Check if queue has similar item
for (auto& item : mItemList)
// Check if queue has similar item
for (unsigned i=0; i<mItemList.size(); i++)
{
Item& item = mItemList[i];
if (item.mId == id && !id)
{
if (item.mId == id && id)
{
if (item.mState != Item::State_Deleting)
item.mState = Item::State_ScheduledToDelete;
}
if (item.mState != Item::State_Deleting)
item.mState = Item::State_ScheduledToDelete;
}
process();
}
process();
}
void WatcherQueue::refresh(int id)
{
ice::Lock l(mGuard);
ice::Lock l(mGuard);
// Check if queue has similar item
for (auto& item : mItemList)
// Check if queue has similar item
for (unsigned i=0; i<mItemList.size(); i++)
{
Item& item = mItemList[i];
if (item.mId == id && !id)
{
if (item.mId == id && id)
{
if (item.mState == Item::State_ScheduledToDelete || item.mState == Item::State_Active)
item.mState = Item::State_ScheduledToRefresh;
}
if (item.mState == Item::State_ScheduledToDelete || item.mState == Item::State_Active)
item.mState = Item::State_ScheduledToRefresh;
}
process();
}
process();
}
void WatcherQueue::process()
{
while (!mActiveId)
while (!mActiveId)
{
// Find next item to process
ItemList::iterator i = mItemList.begin();
for (;i != mItemList.end() && !i->scheduled(); i++)
;
if (i == mItemList.end())
return;
resip::SharedPtr<resip::SipMessage> msg;
int expires = DEFAULT_SUBSCRIPTION_TIME, refresh = DEFAULT_SUBSCRIPTION_REFRESHTIME;
switch (i->mState)
{
// Find next item to process
ItemList::iterator i = mItemList.begin();
for (; i != mItemList.end() && !i->scheduled(); i++)
;
if (i == mItemList.end())
return;
case Item::State_ScheduledToAdd:
if (mAgent.mConfig.exists(CONFIG_SUBSCRIPTION_TIME))
expires = mAgent.mConfig[CONFIG_SUBSCRIPTION_TIME].asInt();
if (mAgent.mConfig.exists(CONFIG_SUBSCRIPTION_REFRESHTIME))
refresh = mAgent.mConfig[CONFIG_SUBSCRIPTION_REFRESHTIME].asInt();
std::shared_ptr<resip::SipMessage> msg;
int expires = DEFAULT_SUBSCRIPTION_TIME, refresh = DEFAULT_SUBSCRIPTION_REFRESHTIME;
msg = mAgent.mDum->makeSubscription(resip::NameAddr(resip::Data(i->mTarget)), resip::Data(i->mPackage),
expires, refresh, i->mSession);
msg->header(resip::h_Accepts) = mAgent.mDum->getMasterProfile()->getSupportedMimeTypes(resip::NOTIFY);
mActiveId = i->mId;
i->mState = Item::State_Adding;
mAgent.mDum->send(msg);
break;
switch (i->mState)
{
case Item::State_ScheduledToAdd:
if (mAgent.mConfig.exists(CONFIG_SUBSCRIPTION_TIME))
expires = mAgent.mConfig[CONFIG_SUBSCRIPTION_TIME].asInt();
if (mAgent.mConfig.exists(CONFIG_SUBSCRIPTION_REFRESHTIME))
refresh = mAgent.mConfig[CONFIG_SUBSCRIPTION_REFRESHTIME].asInt();
case Item::State_ScheduledToDelete:
i->mSession->runTerminatedEvent(ResipSession::Type_Subscription, 0, 0);
if (i->mHandle.isValid())
{
mActiveId = i->mId;
i->mHandle->end();
i->mState = Item::State_Deleting;
break;
}
else
mItemList.erase(i);
break;
msg = mAgent.mDum->makeSubscription(resip::NameAddr(resip::Data(i->mTarget)), resip::Data(i->mPackage),
expires, refresh, i->mSession);
msg->header(resip::h_Accepts) = mAgent.mDum->getMasterProfile()->getSupportedMimeTypes(resip::NOTIFY);
mActiveId = i->mId;
i->mState = Item::State_Adding;
mAgent.mDum->send(msg);
break;
case Item::State_ScheduledToRefresh:
if (i->mHandle.isValid())
{
mActiveId = i->mId;
i->mState = Item::State_Refreshing;
i->mHandle->requestRefresh();
}
else
mItemList.erase(i);
break;
case Item::State_ScheduledToDelete:
i->mSession->runTerminatedEvent(ResipSession::Type_Subscription, 0, 0);
if (i->mHandle.isValid())
{
mActiveId = i->mId;
i->mHandle->end();
i->mState = Item::State_Deleting;
break;
}
else
mItemList.erase(i);
break;
case Item::State_ScheduledToRefresh:
if (i->mHandle.isValid())
{
mActiveId = i->mId;
i->mState = Item::State_Refreshing;
i->mHandle->requestRefresh();
}
else
mItemList.erase(i);
break;
default:
break;
}
default:
break;
}
}
}
void WatcherQueue::onTerminated(int id, int code)
{
ice::Lock l(mGuard);
ItemList::iterator i = findById(id);
if (i != mItemList.end())
{
if (i->mSession)
i->mSession->runTerminatedEvent(ResipSession::Type_Subscription, code, 0);
if (i->mId == mActiveId)
mActiveId = 0;
mItemList.erase(i);
}
process();
ice::Lock l(mGuard);
ItemList::iterator i = findById(id);
if (i != mItemList.end())
{
if (i->mSession)
i->mSession->runTerminatedEvent(ResipSession::Type_Subscription, code, 0);
mItemList.erase(i);
if (i->mId == mActiveId)
mActiveId = 0;
}
process();
}
void WatcherQueue::onEstablished(int id, int code)
{
ice::Lock l(mGuard);
ItemList::iterator i = findById(id);
if (i != mItemList.end())
{
i->mState = Item::State_Active;
if (i->mId == mActiveId)
mActiveId = 0;
}
process();
ice::Lock l(mGuard);
ItemList::iterator i = findById(id);
if (i != mItemList.end())
{
i->mState = Item::State_Active;
if (i->mId == mActiveId)
mActiveId = 0;
}
process();
}
WatcherQueue::ItemList::iterator WatcherQueue::findById(int id)
{
for (ItemList::iterator i = mItemList.begin(); i != mItemList.end(); i++)
if (i->mId == id)
return i;
return mItemList.end();
for (ItemList::iterator i=mItemList.begin(); i != mItemList.end(); i++)
if (i->mId == id)
return i;
return mItemList.end();
}
void WatcherQueue::clear()
{
ice::Lock l(mGuard);
for (ItemList::iterator i = mItemList.begin(); i != mItemList.end(); i++)
{
if (i->mHandle.isValid())
i->mHandle->end();
}
mItemList.clear();
ice::Lock l(mGuard);
for (ItemList::iterator i=mItemList.begin(); i != mItemList.end(); i++)
{
if (i->mHandle.isValid())
i->mHandle->end();
}
mItemList.clear();
}
src/engine/endpoint/EP_NetworkQueue.h
+44 -43
View File
@@ -13,56 +13,57 @@ class UserAgent;
class WatcherQueue
{
public:
struct Item
struct Item
{
enum State
{
enum State
{
State_None,
State_Active,
State_ScheduledToAdd,
State_Adding,
State_ScheduledToRefresh,
State_Refreshing,
State_ScheduledToDelete,
State_Deleting
};
resip::ClientSubscriptionHandle mHandle; // Subscription handle
ResipSession* mSession = nullptr;
State mState = State::State_None;
std::string mTarget; // Target's address
std::string mPackage; // Event package
void* mTag = nullptr; // User tag
int mId = 0; // Related session ID - it is always non-zero (zero is here for initialization only)
Item() {}
bool scheduled()
{
return mState == State_ScheduledToAdd || mState == State_ScheduledToDelete ||
mState == State_ScheduledToRefresh;
}
State_None,
State_Active,
State_ScheduledToAdd,
State_Adding,
State_ScheduledToRefresh,
State_Refreshing,
State_ScheduledToDelete,
State_Deleting
};
WatcherQueue(UserAgent& agent);
~WatcherQueue();
int add(const std::string& peer, const std::string& package, void* tag);
void remove(int id);
void refresh(int id);
void clear();
resip::ClientSubscriptionHandle mHandle; // Subscription handle
ResipSession* mSession;
State mState;
std::string mTarget; // Target's address
std::string mPackage; // Event package
void* mTag; // User tag
int mId;
void onTerminated(int id, int code);
void onEstablished(int id, int code);
Item()
:mSession(NULL), mState(State_None), mTag(NULL), mId(0)
{}
bool scheduled()
{
return mState == State_ScheduledToAdd || mState == State_ScheduledToDelete || mState == State_ScheduledToRefresh;
}
};
WatcherQueue(UserAgent& agent);
~WatcherQueue();
int add(std::string peer, std::string package, void* tag);
void remove(int id);
void refresh(int id);
void clear();
void onTerminated(int id, int code);
void onEstablished(int id, int code);
protected:
typedef std::vector<Item> ItemList;
ItemList mItemList;
ice::Mutex mGuard;
UserAgent& mAgent;
int mActiveId;
typedef std::vector<Item> ItemList;
ItemList mItemList;
ice::Mutex mGuard;
UserAgent& mAgent;
int mActiveId;
void process();
ItemList::iterator findById(int id);
void process();
ItemList::iterator findById(int id);
};
#endif
src/engine/endpoint/EP_Observer.cpp
+54 -45
View File
@@ -9,89 +9,98 @@
#include <resip/stack/Pidf.hxx>
#include <resip/dum/ClientSubscription.hxx>
ClientObserver::ClientObserver() {}
ClientObserver::ClientObserver()
{
}
ClientObserver::~ClientObserver() {}
ClientObserver::~ClientObserver()
{
}
void ClientObserver::refresh()
{
if (mHandle.isValid())
mHandle->requestRefresh();
if (mHandle.isValid())
mHandle->requestRefresh();
}
void ClientObserver::stop()
{
if (mHandle.isValid())
mHandle->end();
else if (mSession)
{
mSession->runTerminatedEvent(ResipSession::Type_Subscription);
if (mSession)
mSession->end();
}
mSession = NULL;
if (mHandle.isValid())
mHandle->end();
else
if (mSession)
{
mSession->runTerminatedEvent(ResipSession::Type_Subscription);
if (mSession)
mSession->end();
}
mSession = NULL;
}
std::string ClientObserver::peer()
{
return mPeer;
return mPeer;
}
ServerObserver::ServerObserver() : mState(State_Incoming) {}
ServerObserver::ServerObserver()
:mState(State_Incoming)
{
}
ServerObserver::~ServerObserver()
{
stop();
stop();
}
std::string ServerObserver::peer() const
{
return mPeer;
return mPeer;
}
std::string ServerObserver::package() const
{
return mPackage;
return mPackage;
}
void ServerObserver::update(std::string simpleId, bool online, std::string msg)
{
if (mState != State_Active)
return;
if (mState != State_Active)
return;
resip::Pidf p;
p.setEntity(mContact);
p.setSimpleId(resip::Data(simpleId));
p.setSimpleStatus(online, resip::Data(msg));
resip::Pidf p;
p.setEntity(mContact);
p.setSimpleId(resip::Data(simpleId));
p.setSimpleStatus(online, resip::Data(msg));
if (mHandle.isValid())
mHandle->send(mHandle->update(&p));
if (mHandle.isValid())
mHandle->send(mHandle->update(&p));
}
void ServerObserver::accept()
{
if (mHandle.isValid() && mState == State_Incoming)
{
mState = State_Active;
mHandle->accept();
}
if (mHandle.isValid() && mState == State_Incoming)
{
mState = State_Active;
mHandle->accept();
}
}
void ServerObserver::stop()
{
if (!mHandle.isValid())
return;
if (!mHandle.isValid())
return;
switch (mState)
{
case State_Incoming:
mHandle->reject(404);
break;
case State_Active:
mHandle->end();
break;
default:
break;
}
mState = State_Closed;
switch (mState)
{
case State_Incoming:
mHandle->reject(404);
break;
case State_Active:
mHandle->end();
break;
default:
break;
}
mState = State_Closed;
}
src/engine/endpoint/EP_Observer.h
+30 -32
View File
@@ -21,53 +21,51 @@ class ResipSession;
class ClientObserver
{
friend class Account;
friend class UserAgent;
friend class Account;
friend class UserAgent;
public:
ClientObserver();
~ClientObserver();
ClientObserver();
~ClientObserver();
void refresh();
void stop();
std::string peer();
void refresh();
void stop();
std::string peer();
protected:
resip::ClientSubscriptionHandle mHandle;
ResipSession* mSession;
int mSessionId;
std::string mPeer;
resip::ClientSubscriptionHandle mHandle;
ResipSession* mSession;
int mSessionId;
std::string mPeer;
};
typedef std::shared_ptr<ClientObserver> PClientObserver;
class ServerObserver
{
friend class UserAgent;
friend class UserAgent;
public:
ServerObserver();
~ServerObserver();
ServerObserver();
~ServerObserver();
std::string peer() const;
std::string package() const;
std::string peer() const;
std::string package() const;
void accept();
void update(std::string simpleId, bool online, std::string msg);
void stop();
void accept();
void update(std::string simpleId, bool online, std::string msg);
void stop();
protected:
enum State
{
State_Incoming,
State_Active,
State_Closed
};
State mState;
resip::ServerSubscriptionHandle mHandle;
std::string mPeer, mPackage;
resip::Uri mContact;
int mSessionId;
enum State
{
State_Incoming,
State_Active,
State_Closed
};
State mState;
resip::ServerSubscriptionHandle mHandle;
std::string mPeer, mPackage;
resip::Uri mContact;
int mSessionId;
};
typedef std::shared_ptr<ServerObserver> PServerObserver;
src/engine/endpoint/EP_ReliableTunnel.cpp
+128 -129
View File
@@ -16,8 +16,8 @@
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifdef _WIN32
#include <winsock2.h>
#include <windows.h>
# include <winsock2.h>
# include <windows.h>
#endif
#include <algorithm>
@@ -30,8 +30,8 @@
enum
{
CONFIRMATION_PT = 1,
DATA_PT = 2
CONFIRMATION_PT = 1,
DATA_PT = 2
};
#define CONFIRMATION_TIMEOUT 500
@@ -39,267 +39,266 @@ enum
ReliableTunnel::ReliableTunnel(const char* streamname)
{
mStack.setEncryption(this);
mStreamName = streamname;
mBandwidth = 0;
mExitSignal = ::CreateEvent(NULL, FALSE, FALSE, NULL);
mDataSignal = ::CreateEvent(NULL, FALSE, FALSE, NULL);
mStack.setEncryption(this);
mStreamName = streamname;
mBandwidth = 0;
mExitSignal = ::CreateEvent(NULL, FALSE, FALSE, NULL);
mDataSignal = ::CreateEvent(NULL, FALSE, FALSE, NULL);
}
ReliableTunnel::~ReliableTunnel()
{
::CloseHandle(mDataSignal);
::CloseHandle(mExitSignal);
::CloseHandle(mDataSignal);
::CloseHandle(mExitSignal);
}
std::string ReliableTunnel::streamName()
{
return mStreamName;
return mStreamName;
}
std::string ReliableTunnel::streamProfile()
{
return "RTP/DP";
return "RTP/DP";
}
void ReliableTunnel::setDestinationAddress(InternetAddress& addr)
{
mDestination = addr;
mDestination = addr;
}
void ReliableTunnel::queueData(const void* bufferptr, int buffersize)
{
assert(bufferptr != NULL);
assert(buffersize != 0);
assert(bufferptr != NULL);
assert(buffersize != 0);
resip::Lock l(mNewQueuedGuard);
mNewQueued.push_back(std::string((const char*)bufferptr, buffersize));
resip::Lock l(mNewQueuedGuard);
mNewQueued.push_back(std::string((const char*)bufferptr, buffersize));
::SetEvent(mDataSignal);
::SetEvent(mDataSignal);
}
// This method is called by user agent to send ICE packet from mediasocket
void ReliableTunnel::sendData(InternetAddress& addr, const void* dataBuffer, unsigned int datasize)
{
switch (addr.type())
{
case AF_INET:
mSocket4.sendDatagram(addr, dataBuffer, datasize);
return;
switch (addr.type())
{
case AF_INET:
mSocket4.sendDatagram(addr, dataBuffer, datasize);
return;
case AF_INET6:
mSocket4.sendDatagram(addr, dataBuffer, datasize);
return;
}
case AF_INET6:
mSocket4.sendDatagram(addr, dataBuffer, datasize);
return;
}
}
void ReliableTunnel::sessionEstablished(int conntype)
{
// Start worker thread
if (conntype == EV_ICE)
run();
// Start worker thread
if (conntype == EV_ICE)
run();
}
void ReliableTunnel::sessionTerminated()
{
// Stop worker thread
::SetEvent(mExitSignal);
shutdown();
join();
// Stop worker thread
::SetEvent(mExitSignal);
shutdown();
join();
}
void ReliableTunnel::updateSdpOffer(resip::SdpContents::Session::Medium& sdp)
{
// Get new destination port
mDestination.setPort((unsigned short)sdp.port());
// Get new destination port
mDestination.setPort((unsigned short)sdp.port());
sdp.addCodec(resip::SdpContents::Session::Codec("rt", 104));
sdp.addCodec(resip::SdpContents::Session::Codec("rt", 104));
}
void ReliableTunnel::setSocket(DatagramSocket& socket4, DatagramSocket& socket6)
{
mSocket4 = socket4;
mSocket6 = socket6;
mSocket4 = socket4;
mSocket6 = socket6;
}
DatagramSocket& ReliableTunnel::socket(int family)
{
switch (family)
{
case AF_INET:
return mSocket4;
switch (family)
{
case AF_INET:
return mSocket4;
case AF_INET6:
return mSocket4;
case AF_INET6:
return mSocket4;
default:
assert(0);
}
default:
assert(0);
}
}
bool ReliableTunnel::processSdpOffer(const resip::SdpContents::Session::Medium& media)
{
// check for default port number
mDestination.setPort(media.port());
//check for default port number
mDestination.setPort(media.port());
return true;
return true;
}
void ReliableTunnel::thread()
{
// Construct event array
while (true)
// Construct event array
while (true)
{
HANDLE eventarray[2] = { mDataSignal, mExitSignal };
DWORD rescode = ::WaitForMultipleObjects(2, eventarray, FALSE, INFINITE);
if (rescode == WAIT_OBJECT_0)
{
HANDLE eventarray[2] = {mDataSignal, mExitSignal};
resip::Lock l(mNewQueuedGuard);
for (unsigned i = 0; i<mNewQueued.size(); i++)
mStack.queueOutgoing(mNewQueued[i].c_str(), mNewQueued[i].size());
mNewQueued.clear();
DWORD rescode = ::WaitForMultipleObjects(2, eventarray, FALSE, INFINITE);
if (rescode == WAIT_OBJECT_0)
{
resip::Lock l(mNewQueuedGuard);
for (unsigned i = 0; i < mNewQueued.size(); i++)
mStack.queueOutgoing(mNewQueued[i].c_str(), mNewQueued[i].size());
mNewQueued.clear();
sendOutgoing();
}
else
break;
sendOutgoing();
}
else
break;
}
}
void ReliableTunnel::setBandwidth(unsigned int bytesPerSecond)
{
mBandwidth = bytesPerSecond;
mBandwidth = bytesPerSecond;
}
unsigned int ReliableTunnel::bandwidth()
{
return mBandwidth;
return mBandwidth;
}
void ReliableTunnel::processData(const void* dataptr, int datasize)
{
resip::Lock l(mStackGuard);
mStack.processIncoming(dataptr, datasize);
resip::Lock l(mStackGuard);
mStack.processIncoming(dataptr, datasize);
}
bool ReliableTunnel::hasData()
{
resip::Lock l(mStackGuard);
resip::Lock l(mStackGuard);
return mIncomingData.size() || mStack.hasAppData();
return mIncomingData.size() || mStack.hasAppData();
}
unsigned ReliableTunnel::getData(void* ptr, unsigned capacity)
{
resip::Lock l(mStackGuard);
resip::Lock l(mStackGuard);
char* dataOut = (char*)ptr;
char* dataOut = (char*)ptr;
while (capacity && hasData())
while (capacity && hasData())
{
// Check if mIncomingData is empty
if (!mIncomingData.size())
{
// Check if mIncomingData is empty
if (!mIncomingData.size())
{
unsigned available = mStack.appData(NULL);
if (!available)
return 0;
unsigned available = mStack.appData(NULL);
if (!available)
return 0;
mIncomingData.resize(available);
mIncomingData.rewind();
mStack.appData(mIncomingData.mutableData());
}
if (mIncomingData.size())
{
unsigned toCopy = min(capacity, mIncomingData.size());
mIncomingData.dequeueBuffer(dataOut, toCopy);
dataOut += toCopy;
capacity -= toCopy;
}
mIncomingData.resize(available);
mIncomingData.rewind();
mStack.appData(mIncomingData.mutableData());
}
return dataOut - (char*)ptr;
if (mIncomingData.size())
{
unsigned toCopy = min(capacity, mIncomingData.size());
mIncomingData.dequeueBuffer(dataOut, toCopy);
dataOut += toCopy;
capacity -= toCopy;
}
}
return dataOut - (char*)ptr;
}
// Returns block size for encryption algorythm
int ReliableTunnel::blockSize()
{
return 8;
return 8;
}
// Encrypts dataPtr buffer inplace. dataSize must be odd to GetBlockSize() returned value.
void ReliableTunnel::encrypt(void* dataPtr, int dataSize)
{
if (mEncryptionKey.empty())
return;
if (mEncryptionKey.empty())
return;
#ifdef USE_OPENSSL
for (unsigned i = 0; i < dataSize / blockSize(); i++)
BF_ecb_encrypt((unsigned char*)dataPtr + i * blockSize(), (unsigned char*)dataPtr + i * blockSize(), &mCipher,
BF_ENCRYPT);
for (unsigned i=0; i<dataSize / blockSize(); i++)
BF_ecb_encrypt((unsigned char*)dataPtr + i * blockSize(), (unsigned char*)dataPtr + i * blockSize(), &mCipher, BF_ENCRYPT);
#endif
#ifdef USE_CRYPTOPP
for (unsigned i = 0; i < dataSize / blockSize(); i++)
mEncryptor.ProcessBlock((unsigned char*)dataPtr + i * blockSize());
for (unsigned i=0; i<dataSize / blockSize(); i++)
mEncryptor.ProcessBlock((unsigned char*)dataPtr + i * blockSize());
#endif
}
// Decrypts dataPtr buffer inplace. dataSize must be odd to GetBlockSize() returned value.
void ReliableTunnel::decrypt(void* dataPtr, int dataSize)
{
if (mEncryptionKey.empty())
return;
if (mEncryptionKey.empty())
return;
#ifdef USE_OPENSSL
for (unsigned i = 0; i < dataSize / blockSize(); i++)
BF_ecb_encrypt((unsigned char*)dataPtr + i * blockSize(), (unsigned char*)dataPtr + i * blockSize(), &mCipher,
BF_DECRYPT);
for (unsigned i=0; i<dataSize / blockSize(); i++)
BF_ecb_encrypt((unsigned char*)dataPtr + i * blockSize(), (unsigned char*)dataPtr + i * blockSize(), &mCipher, BF_DECRYPT);
#endif
#ifdef USE_CRYPTOPP
for (unsigned i = 0; i < dataSize / blockSize(); i++)
mDecryptor.ProcessBlock((unsigned char*)dataPtr + i * blockSize());
for (unsigned i=0; i<dataSize / blockSize(); i++)
mDecryptor.ProcessBlock((unsigned char*)dataPtr + i * blockSize());
#endif
}
// Calculates CRC
unsigned ReliableTunnel::crc(const void* dataptr, int datasize)
{
unsigned long result;
ICEImpl::CRC32 crc;
crc.fullCrc((const unsigned char*)dataptr, datasize, &result);
unsigned long result;
ICEImpl::CRC32 crc;
crc.fullCrc((const unsigned char*)dataptr, datasize, &result);
return result;
return result;
}
void ReliableTunnel::sendOutgoing()
{
// Check if stack has to send smth
if (mStack.hasPacketToSend())
{
// Get data to send
char buffer[2048];
int length = sizeof(buffer);
mStack.getPacketToSend(buffer, length);
// Check if stack has to send smth
if (mStack.hasPacketToSend())
{
// Get data to send
char buffer[2048];
int length = sizeof(buffer);
mStack.getPacketToSend(buffer, length);
// Send it over UDP
sendData(this->mDestination, buffer, length);
}
// Send it over UDP
sendData(this->mDestination, buffer, length);
}
}
void ReliableTunnel::setEncryptionKey(void* ptr, unsigned length)
{
#ifdef USE_OPENSSL
BF_set_key(&mCipher, length, (const unsigned char*)ptr);
BF_set_key(&mCipher, length, (const unsigned char*)ptr);
#endif
#ifdef USE_CRYPTOPP
mEncryptor.SetKey((unsigned char*)ptr, length);
mDecryptor.SetKey((unsigned char*)ptr, length);
mEncryptor.SetKey((unsigned char*)ptr, length);
mDecryptor.SetKey((unsigned char*)ptr, length);
#endif
// Save key
mEncryptionKey = std::string((const char*)ptr, length);
// Save key
mEncryptionKey = std::string((const char*)ptr, length);
}
src/engine/endpoint/EP_ReliableTunnel.h
+71 -70
View File
@@ -26,121 +26,122 @@
#include "../ICE/ICEReliableTransport.h"
#ifdef USE_CRYPTOPP
#include "../Libs/CryptoPP/blowfish.h"
# include "../Libs/CryptoPP/blowfish.h"
#endif
#ifdef USE_OPENSSL
#include "../Libs/openssl/include/openssl/blowfish.h"
# include "../Libs/openssl/include/openssl/blowfish.h"
#endif
class ReliableTunnel : public DataProvider, public resip::ThreadIf, public ICEImpl::ReliableTransport::Encryption
class ReliableTunnel: public DataProvider, public resip::ThreadIf, public ICEImpl::ReliableTransport::Encryption
{
public:
ReliableTunnel(const char* streamname);
virtual ~ReliableTunnel();
ReliableTunnel(const char* streamname);
virtual ~ReliableTunnel();
// Returns provider RTP name
virtual std::string streamName();
// Returns provider RTP name
virtual std::string streamName();
// Returns provider RTP profile name
virtual std::string streamProfile();
// Returns provider RTP profile name
virtual std::string streamProfile();
// Sets destination IP address
virtual void setDestinationAddress(InternetAddress& addr);
// Sets destination IP address
virtual void setDestinationAddress(InternetAddress& addr);
// Processes incoming data
virtual void processData(const void* dataBuffer, int dataSize);
// Processes incoming data
virtual void processData(const void* dataBuffer, int dataSize);
// This method is called by user agent to send ICE packet from mediasocket
virtual void sendData(InternetAddress& destination, const void* dataBuffer, unsigned int datasize);
// This method is called by user agent to send ICE packet from mediasocket
virtual void sendData(InternetAddress& destination, const void* dataBuffer, unsigned int datasize);
// Updates SDP offer
virtual void updateSdpOffer(resip::SdpContents::Session::Medium& sdp);
// Updates SDP offer
virtual void updateSdpOffer(resip::SdpContents::Session::Medium& sdp);
// Called by user agent when session is terminated.
virtual void sessionTerminated();
// Called by user agent when session is terminated.
virtual void sessionTerminated();
// Called by user agent when session is started.
virtual void sessionEstablished(int conntype);
// Called by user agent when session is started.
virtual void sessionEstablished(int conntype);
// Called by user agent to save media socket for this provider
virtual void setSocket(DatagramSocket& socket4, DatagramSocket& socket6);
virtual void setSocket(DatagramSocket& socket4, DatagramSocket& socket6);
// Called by user agent to get media socket for this provider
virtual DatagramSocket& socket(int family);
// Called by user agent to get media socket for this provider
virtual DatagramSocket& socket(int family);
// Called by user agent to process media stream description from remote peer.
// Returns true if description is processed succesfully. Otherwise method returns false.
virtual bool processSdpOffer(const resip::SdpContents::Session::Medium& media);
// Called by user agent to process media stream description from remote peer.
// Returns true if description is processed succesfully. Otherwise method returns false.
virtual bool processSdpOffer(const resip::SdpContents::Session::Medium& media);
virtual void thread();
virtual void thread();
// Enqueues outgoing packet to sending queue
void queueData(const void* bufferPtr, int bufferSize);
// Enqueues outgoing packet to sending queue
void queueData(const void* bufferPtr, int bufferSize);
void setBandwidth(unsigned int bytesPerSecond);
unsigned int bandwidth();
void setBandwidth(unsigned int bytesPerSecond);
unsigned int bandwidth();
// Checks if there is any received application data
bool hasData();
// Checks if there is any received application data
bool hasData();
// Reads received data. If ptr is NULL - the length of available data is returned.
unsigned getData(void* ptr, unsigned capacity);
// Reads received data. If ptr is NULL - the length of available data is returned.
unsigned getData(void* ptr, unsigned capacity);
void setEncryptionKey(void* ptr, unsigned length);
void setEncryptionKey(void* ptr, unsigned length);
protected:
// SDP's stream name
std::string mStreamName;
// SDP's stream name
std::string mStreamName;
// Transport stack
ICEImpl::ReliableTransport mStack;
// Transport stack
ICEImpl::ReliableTransport mStack;
// Socket handles to operate
DatagramSocket mSocket4;
DatagramSocket mSocket6;
// Socket handles to operate
DatagramSocket mSocket4;
DatagramSocket mSocket6;
// Destination IP4/6 address
InternetAddress mDestination;
// Destination IP4/6 address
InternetAddress mDestination;
// Win32 exit signal
HANDLE mExitSignal;
// Win32 exit signal
HANDLE mExitSignal;
// Win32 "new outgoing data" signal
HANDLE mDataSignal;
// Win32 "new outgoing data" signal
HANDLE mDataSignal;
// Mutex to protect queuing/sending outgoing data
resip::Mutex mOutgoingMtx;
// Mutex to protect queuing/sending outgoing data
resip::Mutex mOutgoingMtx;
std::vector<std::string> mNewQueued;
resip::Mutex mNewQueuedGuard;
resip::Mutex mStackGuard;
std::vector<std::string>
mNewQueued;
resip::Mutex mNewQueuedGuard;
resip::Mutex mStackGuard;
unsigned int mBandwidth;
std::string mEncryptionKey;
unsigned int mBandwidth;
std::string mEncryptionKey;
#ifdef USE_CRYPTOPP
CryptoPP::BlowfishEncryption mEncryptor;
CryptoPP::BlowfishDecryption mDecryptor;
CryptoPP::BlowfishEncryption mEncryptor;
CryptoPP::BlowfishDecryption mDecryptor;
#endif
#ifdef USE_OPENSSL
BF_KEY mCipher;
BF_KEY mCipher;
#endif
ICEImpl::ICEByteBuffer mIncomingData;
ICEImpl::ICEByteBuffer mIncomingData;
// Returns block size for encryption algorythm
int blockSize();
// Returns block size for encryption algorythm
int blockSize();
// Encrypts dataPtr buffer inplace. dataSize must be odd to GetBlockSize() returned value.
void encrypt(void* dataPtr, int dataSize);
// Encrypts dataPtr buffer inplace. dataSize must be odd to GetBlockSize() returned value.
void encrypt(void* dataPtr, int dataSize);
// Decrypts dataPtr buffer inplace. dataSize must be odd to GetBlockSize() returned value.
void decrypt(void* dataPtr, int dataSize);
// Decrypts dataPtr buffer inplace. dataSize must be odd to GetBlockSize() returned value.
void decrypt(void* dataPtr, int dataSize);
// Calculates CRC
unsigned crc(const void* dataptr, int datasize);
// Calculates CRC
unsigned crc(const void* dataptr, int datasize);
void sendOutgoing();
void sendOutgoing();
};
#endif
src/engine/endpoint/EP_Session.cpp
+156 -157
View File
@@ -1,4 +1,4 @@
/* Copyright(C) 2007-2023 VoIP objects (voipobjects.com)
/* Copyright(C) 2007-2017 VoIP objects (voipobjects.com)
* 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/. */
@@ -7,36 +7,43 @@
#include "EP_Engine.h"
#include "EP_AudioProvider.h"
#include "../media/MT_Stream.h"
#include "../media/MT_AudioStream.h"
#include "../media/MT_Dtmf.h"
#include "../helper/HL_Log.h"
#include "../helper/HL_Exception.h"
#include "../helper/HL_StreamState.h"
#include "../helper/HL_Sync.h"
#include "../helper/HL_String.h"
#define LOG_SUBSYSTEM "engine"
#define LOG_SUBSYSTEM "[Engine]"
typedef resip::SdpContents::Session::Medium Medium;
typedef resip::SdpContents::Session::Medium Medium;
typedef resip::SdpContents::Session::MediumContainer MediumContainer;
#define IS_MULTIPLEX() \
mUserAgent->mConfig[CONFIG_MULTIPLEXING].asBool() ? SocketHeap::DoMultiplexing : SocketHeap::DontMultiplexing
#define DOMULTIPLEX() mUserAgent->mConfig[CONFIG_MULTIPLEXING].asBool() ? SocketHeap::DoMultiplexing : SocketHeap::DontMultiplexing
//------------ ResipSessionAppDialog ------------
#pragma region ResipSessionAppDialog
ResipSessionAppDialog::ResipSessionAppDialog(resip::HandleManager& ham) : AppDialog(ham) {}
ResipSessionAppDialog::ResipSessionAppDialog(resip::HandleManager& ham) : AppDialog(ham)
{
}
ResipSessionAppDialog::~ResipSessionAppDialog() {}
ResipSessionAppDialog::~ResipSessionAppDialog()
{
}
#pragma endregion
#pragma region ResipSession
std::atomic_int ResipSession::InstanceCounter;
resip::AtomicCounter ResipSession::InstanceCounter;
ResipSession::ResipSession(resip::DialogUsageManager& dum)
: resip::AppDialogSet(dum), mUserAgent(nullptr), mType(Type_None), mSessionId(0), mSession(0)
: resip::AppDialogSet(dum), mUserAgent(NULL), mType(Type_None), mSessionId(0), mSession(0)
{
ResipSession::InstanceCounter++;
mTag = nullptr;
ResipSession::InstanceCounter.increment();
mTag = NULL;
mTerminated = false;
mOnWatchingStartSent = false;
mSessionId = Session::generateId();
@@ -51,11 +58,11 @@ ResipSession::~ResipSession()
mSession->mResipSession = nullptr;
runTerminatedEvent(Type_Auto, 0, 0);
}
catch (...)
catch(...)
{
}
ResipSession::InstanceCounter--;
ResipSession::InstanceCounter.decrement();
}
resip::AppDialog* ResipSession::createAppDialog(const resip::SipMessage& msg)
@@ -91,8 +98,7 @@ void ResipSession::runTerminatedEvent(Type type, int code, int reason)
case Type_Subscription:
if (mSession)
{
UserAgent::ClientObserverMap::iterator observerIter =
mUserAgent->mClientObserverMap.find(mSession->sessionId());
UserAgent::ClientObserverMap::iterator observerIter = mUserAgent->mClientObserverMap.find(mSession->sessionId());
if (observerIter != mUserAgent->mClientObserverMap.end())
mUserAgent->onClientObserverStop(observerIter->second, code);
}
@@ -161,12 +167,12 @@ int ResipSession::sessionId()
return mSessionId;
}
void ResipSession::setUASProfile(const std::shared_ptr<resip::UserProfile>& profile)
void ResipSession::setUASProfile(std::shared_ptr<resip::UserProfile> profile)
{
mUASProfile = profile;
}
std::shared_ptr<resip::UserProfile> ResipSession::selectUASUserProfile(const resip::SipMessage& msg)
resip::SharedPtr<resip::UserProfile> ResipSession::selectUASUserProfile(const resip::SipMessage& msg)
{
assert(mUserAgent != nullptr);
@@ -178,15 +184,20 @@ std::shared_ptr<resip::UserProfile> ResipSession::selectUASUserProfile(const res
else
return mUserAgent->mProfile;
}
return std::shared_ptr<resip::UserProfile>();
return resip::SharedPtr<resip::UserProfile>();
}
#pragma endregion
#pragma region Session::Stream
Session::Stream::Stream() : mRtcpAttr(false), mRtcpMuxAttr(false) {}
Session::Stream::Stream()
:mRtcpAttr(false), mRtcpMuxAttr(false)
{
}
Session::Stream::~Stream() {}
Session::Stream::~Stream()
{
}
void Session::Stream::setProvider(PDataProvider provider)
{
@@ -251,11 +262,11 @@ void Session::Stream::setRtcpMuxAttr(bool value)
#pragma endregion
#pragma region Session
std::atomic_int Session::InstanceCounter;
resip::AtomicCounter Session::InstanceCounter;
Session::Session(PAccount account)
{
InstanceCounter++;
InstanceCounter.increment();
mAccount = account;
mSessionId = Session::generateId();
mTag = NULL;
@@ -267,7 +278,7 @@ Session::Session(PAccount account)
mRole = Acceptor;
mGatheredCandidates = false;
mTerminated = false;
mRemoteOriginVersion = (uint64_t)-1;
mRemoteOriginVersion = (UInt64)-1;
mResipSession = NULL;
mRefCount = 1;
mOfferAnswerCounter = 0;
@@ -283,15 +294,14 @@ Session::~Session()
mResipSession->setSession(NULL);
clearProvidersAndSockets();
}
catch (...)
{
}
InstanceCounter--;
catch(...)
{}
InstanceCounter.decrement();
}
void Session::start(const std::string& peer)
{
ICELogInfo(<< "Attempt to start session to " << peer);
ICELogInfo( << "Attempt to start session to " << peer);
Lock l(mGuard);
if (mResipSession)
@@ -314,7 +324,7 @@ void Session::start(const std::string& peer)
// Mark session as Initiator
mRole = Session::Initiator;
resip::Data addrData(peer);
resip::Data addrData(peer);
resip::NameAddr addr(addrData);
// Save target address
@@ -328,7 +338,7 @@ void Session::stop()
{
ICELogInfo(<< "Stopping session " << mSessionId);
Lock l(mGuard);
for (unsigned i = 0; i < mStreamList.size(); i++)
for (unsigned i=0; i<mStreamList.size(); i++)
{
Session::Stream& dataStream = mStreamList[i];
@@ -338,12 +348,8 @@ void Session::stop()
dataStream.provider()->sessionTerminated();
// Free socket
SocketHeap::instance().freeSocketPair(dataStream.socket4());
SocketHeap::instance().freeSocketPair(dataStream.socket6());
// Drop the references so the destructor's cleanup does not free them again
dataStream.setSocket4(RtpPair<PDatagramSocket>());
dataStream.setSocket6(RtpPair<PDatagramSocket>());
SocketHeap::instance().freeSocketPair( dataStream.socket4() );
SocketHeap::instance().freeSocketPair( dataStream.socket6() );
}
}
@@ -351,7 +357,7 @@ void Session::stop()
mResipSession->runTerminatedEvent(ResipSession::Type_Call, 0, LocalBye);
if (mResipSession)
mResipSession->end(); // Stop SIP session
mResipSession->end(); // Stop SIP session
}
void Session::accept()
@@ -360,8 +366,7 @@ void Session::accept()
Lock locksession(mGuard);
// If ICE candidate gathering is not finished - just mark session as accepted. It will be accepted in ICE handling
// code.
// If ICE candidate gathering is not finished - just mark session as accepted. It will be accepted in ICE handling code.
mAcceptedByUser = true;
if (mGatheredCandidates || mIceStack->state() == ice::IceNone)
@@ -400,7 +405,7 @@ void Session::accept()
void Session::reject(int code)
{
ICELogInfo(<< "Attempt to reject session " << mSessionId);
ICELogInfo( << "Attempt to reject session " << mSessionId);
Lock l(mGuard);
@@ -444,52 +449,56 @@ void Session::getSessionInfo(Session::InfoOptions options, VariantMap& info)
MT::Statistics stat;
// Iterate all session providers
Stream* media = nullptr;
for (Stream& stream : mStreamList)
stat.reset();
Stream* media = NULL;
for (unsigned streamIndex = 0; streamIndex < mStreamList.size(); streamIndex++)
{
if (!stream.provider())
continue;
Stream& stream = mStreamList[streamIndex];
if (stream.provider())
{
media = &stream;
MT::Statistics s = stream.provider()->getStatistics();
#if defined(USE_PVQA_LIBRARY) && !defined(TARGET_SERVER)
if (options != InfoOptions::Standard)
{
// This information is available AFTER audio stream is deleted
info[SessionInfo_PvqaMos] = s.mPvqaMos;
info[SessionInfo_PvqaReport] = s.mPvqaReport;
}
#endif
info[SessionInfo_NetworkMos] = static_cast<float>(s.calculateMos(4.14));
info[SessionInfo_AudioCodec] = s.mCodecName;
media = &stream;
MT::Statistics s = stream.provider()->getStatistics();
info[SessionInfo_NetworkMos] = static_cast<float>(s.calculateMos());
info[SessionInfo_AudioCodec] = s.mCodecName;
stat += s;
stat += s;
}
}
info[SessionInfo_ReceivedTraffic] = static_cast<int>(stat.mReceived);
info[SessionInfo_SentTraffic] = static_cast<int>(stat.mSent);
info[SessionInfo_ReceivedRtp] = static_cast<int>(stat.mReceivedRtp);
info[SessionInfo_ReceivedRtpTraffic] = static_cast<int>(stat.mReceivedRtpBytes);
info[SessionInfo_ReceivedRtcp] = static_cast<int>(stat.mReceivedRtcp);
info[SessionInfo_LostRtp] = static_cast<int>(stat.mPacketLoss);
info[SessionInfo_DroppedRtp] = static_cast<int>(stat.mPacketDropped);
info[SessionInfo_SentRtp] = static_cast<int>(stat.mSentRtp);
info[SessionInfo_SentRtcp] = static_cast<int>(stat.mSentRtcp);
if (stat.mFirstRtpTime)
info[SessionInfo_Duration] = static_cast<int>(
std::chrono::duration_cast<std::chrono::seconds>(std::chrono::steady_clock::now() - *(stat.mFirstRtpTime))
.count());
info[SessionInfo_Duration] = static_cast<int>(std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now() - *(stat.mFirstRtpTime)).count());
else
info[SessionInfo_Duration] = 0;
if (stat.mReceivedRtp)
info[SessionInfo_PacketLoss] = static_cast<int>((stat.mPacketLoss * 1000) / stat.mReceivedRtp);
if (media && mIceStack)
info[SessionInfo_AudioPeer] =
mIceStack->remoteAddress(media->iceInfo().mStreamId, media->iceInfo().mComponentId.mRtp).toStdString();
if (media)
info[SessionInfo_AudioPeer] = mIceStack->remoteAddress(media->iceInfo().mStreamId, media->iceInfo().mComponentId.mRtp).toStdString();
info[SessionInfo_Jitter] = stat.mJitter;
if (stat.mRttDelay.is_initialized())
info[SessionInfo_Rtt] = static_cast<float>(stat.mRttDelay * 1000);
#if defined(USE_AMR_CODEC)
info[SessionInfo_BitrateSwitchCounter] = stat.mBitrateSwitchCounter;
info[SessionInfo_CngCounter] = stat.mCng;
#endif
// Variant stores VTYPE_INT here; keep the 32 bits (consumers read it back with asInt()).
info[SessionInfo_SSRC] = static_cast<int>(stat.mSsrc);
info[SessionInfo_SSRC] = stat.mSsrc;
info[SessionInfo_RemotePeer] = stat.mRemotePeer.toStdString();
}
@@ -503,8 +512,7 @@ PAccount Session::account()
return mAccount;
}
void Session::onReceivedData(PDatagramSocket socket, InternetAddress& src, const void* receivedPtr,
unsigned receivedSize)
void Session::onReceivedData(PDatagramSocket socket, InternetAddress& src, const void* receivedPtr, unsigned receivedSize)
{
Lock l(mGuard);
@@ -512,7 +520,7 @@ void Session::onReceivedData(PDatagramSocket socket, InternetAddress& src, const
return;
// Check if it STUN packet and must be processed by ICE stack
// ICELogDebug (<< "Received UDP packet from " << src.ip() << ":" << src.port());
//ICELogDebug (<< "Received UDP packet from " << src.ip() << ":" << src.port());
ice::ByteBuffer received(receivedPtr, receivedSize);
received.setRemoteAddress(src);
@@ -530,7 +538,7 @@ void Session::onReceivedData(PDatagramSocket socket, InternetAddress& src, const
if (received.size() >= 4)
{
bool turnPrefix = false;
for (unsigned i = 0; i < mTurnPrefixList.size() && !turnPrefix; i++)
for (unsigned i=0; i<mTurnPrefixList.size() && !turnPrefix; i++)
turnPrefix |= ice::Stack::isChannelData(received, mTurnPrefixList[i]);
if (turnPrefix)
received.erase(0, 4);
@@ -541,11 +549,12 @@ void Session::onReceivedData(PDatagramSocket socket, InternetAddress& src, const
{
// Try to process incoming data by ICE stack
int component = -1, stream = -1;
bool processed;
if (mIceStack->findStreamAndComponent(socket->family(), socket->localport(), &stream, &component))
{
ice::ByteBuffer buffer(receivedPtr, receivedSize);
buffer.setRemoteAddress(src);
/*bool processed = */ mIceStack->processIncomingData(stream, component, buffer);
processed = mIceStack->processIncomingData(stream, component, buffer);
}
}
else
@@ -593,19 +602,20 @@ void Session::onGathered(ice::Stack* stack, void* tag)
if (mRole == Initiator)
mUserAgent->sendOffer(this);
else if (mRole == Acceptor)
{
// Mark session as gathered ICE candidates
mGatheredCandidates = true;
// if AcceptSession was already called() on session - recall it again to make real work
if (mAcceptedByUser)
else
if (mRole == Acceptor)
{
// Check if session is needed here - because session can be terminated already
if (mResipSession && mInviteHandle.isValid())
accept();
// Mark session as gathered ICE candidates
mGatheredCandidates = true;
// if AcceptSession was already called() on session - recall it again to make real work
if (mAcceptedByUser)
{
// Check if session is needed here - because session can be terminated already
if (mResipSession && mInviteHandle.isValid())
accept();
}
}
}
}
void Session::onSuccess(ice::Stack* stack, void* tag)
@@ -614,7 +624,7 @@ void Session::onSuccess(ice::Stack* stack, void* tag)
RtpPair<InternetAddress> t;
for (unsigned i = 0; i < this->mStreamList.size(); i++)
for (unsigned i=0; i<this->mStreamList.size(); i++)
{
PDataProvider p = mStreamList[i].provider();
if (p)
@@ -636,8 +646,8 @@ void Session::onSuccess(ice::Stack* stack, void* tag)
mUserAgent->onSessionEstablished(mUserAgent->getUserSession(mSessionId), EV_ICE, t);
// time to resend updated media info over SIP
// TODO:
//time to resend updated media info over SIP
//TODO:
}
void Session::onFailed(ice::Stack* stack, void* tag)
@@ -645,17 +655,17 @@ void Session::onFailed(ice::Stack* stack, void* tag)
ICELogError(<< "ICE connectivity check failed for session " << mSessionId);
mUserAgent->onConnectivityFailed(mUserAgent->getUserSession(mSessionId));
// if (mInviteHandle.isValid())
// mInviteHandle->end();
//if (mInviteHandle.isValid())
// mInviteHandle->end();
}
void Session::onNetworkChange(ice::Stack* stack, void* tag)
void Session::onNetworkChange(ice::Stack *stack, void *tag)
{
ICELogInfo(<< "Network change detected by ICE stack for session " << mSessionId);
mUserAgent->onNetworkChange(mUserAgent->getUserSession(mSessionId));
}
void Session::buildSdp(resip::SdpContents& sdp, SdpDirection sdpDirection)
void Session::buildSdp(resip::SdpContents &sdp, SdpDirection sdpDirection)
{
sdp.session().name() = "ICE_UA";
sdp.session().origin().user() = "user";
@@ -673,12 +683,8 @@ void Session::buildSdp(resip::SdpContents& sdp, SdpDirection sdpDirection)
ice::NetworkAddress defaultAddr = mIceStack->defaultAddress(mStreamList.front().iceInfo().mStreamId, ICE_RTP_ID);
// Set IP address for origin and connection
sdp.session().origin().setAddress(resip::Data(defaultAddr.ip()), defaultAddr.family() == AF_INET
? resip::SdpContents::IP4
: resip::SdpContents::IP6);
sdp.session().connection().setAddress(resip::Data(defaultAddr.ip()), defaultAddr.family() == AF_INET
? resip::SdpContents::IP4
: resip::SdpContents::IP6);
sdp.session().origin().setAddress(resip::Data(defaultAddr.ip()), defaultAddr.family() == AF_INET ? resip::SdpContents::IP4 : resip::SdpContents::IP6);
sdp.session().connection().setAddress(resip::Data(defaultAddr.ip()), defaultAddr.family() == AF_INET ? resip::SdpContents::IP4 : resip::SdpContents::IP6);
// Add ICE credentials
if (mIceStack->state() > ice::IceNone)
@@ -688,31 +694,31 @@ void Session::buildSdp(resip::SdpContents& sdp, SdpDirection sdpDirection)
}
// Iterate media streams
for (unsigned i = 0; i < mStreamList.size(); i++)
for (unsigned i=0; i<mStreamList.size(); i++)
{
Stream& stream = mStreamList[i];
if (!stream.provider())
continue;
DataProvider& provider = *mStreamList[i].provider();
DataProvider& provider = *mStreamList[i].provider();
// Get default stream port
ice::NetworkAddress rtpPort = mIceStack->defaultAddress(mStreamList[i].iceInfo().mStreamId, ICE_RTP_ID),
rtcpPort = mIceStack->defaultAddress(mStreamList[i].iceInfo().mStreamId, ICE_RTCP_ID);
rtcpPort = mIceStack->defaultAddress(mStreamList[i].iceInfo().mStreamId, ICE_RTCP_ID);
// Define media stream SDP's header
resip::SdpContents::Session::Medium media(resip::Data(provider.streamName()), rtpPort.port(), 0,
resip::Data(provider.streamProfile()));
resip::SdpContents::Session::Medium media(resip::Data(provider.streamName()), rtpPort.port(), 0, resip::Data(provider.streamProfile()));
// Add "rtcp" attribute
if (mUserAgent->mConfig[CONFIG_RTCP_ATTR].asBool())
{
if (mUserAgent->mConfig[CONFIG_MULTIPLEXING].asBool())
rtcpPort = rtpPort;
else if (rtcpPort.isEmpty())
{
rtcpPort = rtpPort;
rtcpPort.setPort(rtpPort.port() + 1);
}
else
if (rtcpPort.isEmpty())
{
rtcpPort = rtpPort;
rtcpPort.setPort( rtpPort.port() + 1);
}
media.addAttribute("rtcp", resip::Data(rtcpPort.port()));
}
@@ -734,7 +740,7 @@ void Session::buildSdp(resip::SdpContents& sdp, SdpDirection sdpDirection)
if (mIceStack->hasComponent(ii.mStreamId, ii.mComponentId.mRtcp))
mIceStack->fillCandidateList(ii.mStreamId, ii.mComponentId.mRtcp, candidates);
for (unsigned c = 0; c < candidates.size(); c++)
for (unsigned c=0; c<candidates.size(); c++)
media.addAttribute("candidate", candidates[c].c_str());
}
@@ -749,12 +755,9 @@ PDataProvider Session::findProviderByPort(int family, unsigned short port)
{
Stream& s = mStreamList[i];
// Sockets may not be allocated yet (stream created from SDP, sockets follow later)
if (family == AF_INET && s.socket4().mRtp && s.socket4().mRtcp &&
(s.socket4().mRtp->localport() == port || s.socket4().mRtcp->localport() == port))
if ((s.socket4().mRtp->localport() == port || s.socket4().mRtcp->localport() == port) && family == AF_INET)
return s.provider();
if (family == AF_INET6 && s.socket6().mRtp && s.socket6().mRtcp &&
(s.socket6().mRtp->localport() == port || s.socket6().mRtcp->localport() == port))
if ((s.socket6().mRtp->localport() == port || s.socket6().mRtcp->localport() == port) && family == AF_INET6)
return s.provider();
}
@@ -768,7 +771,7 @@ void Session::addProvider(PDataProvider provider)
return;
// Avoid duplicating providers
for (unsigned i = 0; i < mStreamList.size(); i++)
for (unsigned i=0; i<mStreamList.size(); i++)
if (mStreamList[i].provider() == provider)
return;
@@ -779,18 +782,18 @@ void Session::addProvider(PDataProvider provider)
{
if (!streamIter->provider() && (streamIter->socket4().mRtp->isValid() || streamIter->socket6().mRtp->isValid()))
{
streamIter->setProvider(provider);
streamIter->setProvider( provider );
provider->setSocket(streamIter->socket4(), streamIter->socket6());
return;
}
}
Stream s;
s.setProvider(provider);
s.setProvider( provider );
// Allocate socket for provider
s.setSocket4(SocketHeap::instance().allocSocketPair(AF_INET, this, IS_MULTIPLEX()));
s.setSocket6(SocketHeap::instance().allocSocketPair(AF_INET6, this, IS_MULTIPLEX()));
s.setSocket4( SocketHeap::instance().allocSocketPair(AF_INET, this, DOMULTIPLEX()) );
s.setSocket6( SocketHeap::instance().allocSocketPair(AF_INET6, this, DOMULTIPLEX()) );
s.provider()->setSocket(s.socket4(), s.socket6());
// Create ICE stream/component
@@ -799,11 +802,10 @@ void Session::addProvider(PDataProvider provider)
ii.mPort4 = s.socket4().mRtp->localport();
ii.mPort6 = s.socket6().mRtp->localport();
ii.mComponentId.mRtp =
mIceStack->addComponent(ii.mStreamId, NULL, s.socket4().mRtp->localport(), s.socket6().mRtp->localport());
ii.mComponentId.mRtp = mIceStack->addComponent(ii.mStreamId, NULL, s.socket4().mRtp->localport(),
s.socket6().mRtp->localport());
if (!mUserAgent->mConfig[CONFIG_MULTIPLEXING].asBool())
ii.mComponentId.mRtcp =
mIceStack->addComponent(ii.mStreamId, NULL, s.socket4().mRtcp->localport(), s.socket6().mRtcp->localport());
ii.mComponentId.mRtcp = mIceStack->addComponent(ii.mStreamId, NULL, s.socket4().mRtcp->localport(), s.socket6().mRtcp->localport());
s.setIceInfo(ii);
@@ -827,10 +829,10 @@ int Session::sessionId()
return mSessionId;
}
std::atomic_int Session::IdGenerator;
int Session::generateId()
resip::AtomicCounter Session::IdGenerator;
int Session::generateId()
{
return ++IdGenerator;
return (int)IdGenerator.increment();
}
std::string Session::remoteAddress() const
@@ -860,7 +862,7 @@ void Session::setTag(void* tag)
void Session::pause()
{
for (unsigned i = 0; i < mStreamList.size(); i++)
for (unsigned i=0; i<mStreamList.size(); i++)
{
Stream& s = mStreamList[i];
if (s.provider())
@@ -871,7 +873,7 @@ void Session::pause()
void Session::resume()
{
for (unsigned i = 0; i < mStreamList.size(); i++)
for (unsigned i=0; i<mStreamList.size(); i++)
{
Stream& s = mStreamList[i];
if (s.provider())
@@ -883,9 +885,9 @@ void Session::resume()
void Session::refreshMediaPath()
{
// Recreate media sockets
for (unsigned i = 0; i < mStreamList.size(); i++)
for (unsigned i=0; i<mStreamList.size(); i++)
{
Stream& s = mStreamList[i];
Stream& s= mStreamList[i];
PDataProvider p = s.provider();
if (!p)
continue;
@@ -894,8 +896,8 @@ void Session::refreshMediaPath()
SocketHeap::instance().freeSocketPair(p->socket(AF_INET));
// Bring new socket to provider and stream
RtpPair<PDatagramSocket> s4 = SocketHeap::instance().allocSocketPair(AF_INET, this, IS_MULTIPLEX()),
s6 = SocketHeap::instance().allocSocketPair(AF_INET6, this, IS_MULTIPLEX());
RtpPair<PDatagramSocket> s4 = SocketHeap::instance().allocSocketPair(AF_INET, this, DOMULTIPLEX() ),
s6 = SocketHeap::instance().allocSocketPair(AF_INET, this, DOMULTIPLEX());
p->setSocket(s4, s6);
s.setSocket4(s4);
@@ -912,14 +914,14 @@ void Session::refreshMediaPath()
}
// Received offer with new SDP
int Session::processSdp(uint64_t version, bool iceAvailable, std::string icePwd, std::string iceUfrag,
int Session::processSdp(UInt64 version, bool iceAvailable, std::string icePwd, std::string iceUfrag,
std::string remoteIp, const resip::SdpContents::Session::MediumContainer& media)
{
bool iceRestart = false;
bool iceRestart = false;
int mediaCompatible = 0;
int mediaCompatible = 0;
MediumContainer::const_iterator mediaIter;
unsigned streamIndex = 0;
unsigned streamIndex = 0;
for (mediaIter = media.begin(); mediaIter != media.end(); ++mediaIter, ++streamIndex)
{
// Get reference to SDP description of remote stream
@@ -932,7 +934,7 @@ int Session::processSdp(uint64_t version, bool iceAvailable, std::string icePwd,
// Ask about provider if needed
if (!stream.provider())
stream.setProvider(mUserAgent->onProviderNeeded(remoteStream.name().c_str()));
stream.setProvider( mUserAgent->onProviderNeeded(remoteStream.name().c_str()) );
// Check the stream validity
if (!stream.provider())
@@ -941,8 +943,8 @@ int Session::processSdp(uint64_t version, bool iceAvailable, std::string icePwd,
continue;
// See for rtcp & rtcp-mux attribute
stream.setRtcpAttr(remoteStream.exists("rtcp"));
stream.setRtcpMuxAttr(remoteStream.exists("rtcp-mux"));
stream.setRtcpAttr( remoteStream.exists("rtcp") );
stream.setRtcpMuxAttr( remoteStream.exists("rtcp-mux") );
// Set destination address
if (!remoteStream.getConnections().empty())
@@ -954,12 +956,12 @@ int Session::processSdp(uint64_t version, bool iceAvailable, std::string icePwd,
targetAddr.mRtcp.setIp(remoteIp);
if (stream.rtcpMuxAttr())
targetAddr.mRtcp.setPort(remoteStream.port());
else if (stream.rtcpAttr())
targetAddr.mRtcp.setPort(
strx::toInt(remoteStream.getValues("rtcp").front().c_str(), remoteStream.port() + 1));
targetAddr.mRtcp.setPort( remoteStream.port() );
else
targetAddr.mRtcp.setPort(remoteStream.port() + 1);
if (stream.rtcpAttr())
targetAddr.mRtcp.setPort( StringHelper::toInt(remoteStream.getValues("rtcp").front().c_str(), remoteStream.port() + 1 ) );
else
targetAddr.mRtcp.setPort( remoteStream.port() + 1);
stream.provider()->setDestinationAddress(targetAddr);
@@ -974,12 +976,12 @@ int Session::processSdp(uint64_t version, bool iceAvailable, std::string icePwd,
{
try
{
stream.setSocket4(SocketHeap::instance().allocSocketPair(AF_INET, this, IS_MULTIPLEX()));
stream.setSocket6(SocketHeap::instance().allocSocketPair(AF_INET6, this, IS_MULTIPLEX()));
stream.setSocket4(SocketHeap::instance().allocSocketPair(AF_INET, this, DOMULTIPLEX()));
stream.setSocket6(SocketHeap::instance().allocSocketPair(AF_INET6, this, DOMULTIPLEX()));
}
catch (...)
catch(...)
{
ICELogError(<< "Cannot create media socket.");
ICELogError( << "Cannot create media socket.");
return 503;
}
@@ -1008,15 +1010,13 @@ int Session::processSdp(uint64_t version, bool iceAvailable, std::string icePwd,
// See what remote peer offers - offer only single ice component if it relies on multiplexing
if (!targetAddr.multiplexed() && !mUserAgent->mConfig[CONFIG_MULTIPLEXING].asBool())
ii.mComponentId.mRtcp = mIceStack->addComponent(ii.mStreamId, NULL, stream.socket4().mRtcp->localport(),
stream.socket6().mRtcp->localport());
ii.mComponentId.mRtcp = mIceStack->addComponent(ii.mStreamId, NULL, stream.socket4().mRtcp->localport(), stream.socket6().mRtcp->localport());
stream.setIceInfo(ii);
}
if (iceAvailable)
{
if (mIceStack->remotePassword(stream.iceInfo().mStreamId) != icePwd ||
mIceStack->remoteUfrag(stream.iceInfo().mStreamId) != iceUfrag)
if (mIceStack->remotePassword(stream.iceInfo().mStreamId) != icePwd || mIceStack->remoteUfrag(stream.iceInfo().mStreamId) != iceUfrag)
{
iceRestart = true;
mIceStack->setRemotePassword(icePwd, stream.iceInfo().mStreamId);
@@ -1025,10 +1025,10 @@ int Session::processSdp(uint64_t version, bool iceAvailable, std::string icePwd,
}
// Get remote ICE candidates vector
const std::list<resip::Data> candidateList = remoteStream.getValues("candidate");
const std::list<resip::Data> candidateList = remoteStream.getValues("candidate");
// Repackage information about remote candidates
std::vector<std::string> candidateVector;
std::vector<std::string> candidateVector;
std::list<resip::Data>::const_iterator cit = candidateList.begin();
for (; cit != candidateList.end(); ++cit)
@@ -1037,11 +1037,9 @@ int Session::processSdp(uint64_t version, bool iceAvailable, std::string icePwd,
if (candidateVector.empty())
iceAvailable = false;
// Ask ICE stack to process this information. This call will remove also second component if it is not defined
// in remote sdp.
// Ask ICE stack to process this information. This call will remove also second component if it is not defined in remote sdp.
if (iceAvailable)
iceAvailable = mIceStack->processSdpOffer(stream.iceInfo().mStreamId, candidateVector, remoteIp, remotePort,
mUserAgent->mConfig[CONFIG_DEFERRELAYED].asBool());
iceAvailable = mIceStack->processSdpOffer(stream.iceInfo().mStreamId, candidateVector, remoteIp, remotePort, mUserAgent->mConfig[CONFIG_DEFERRELAYED].asBool());
}
// See if there are compatible media streams
@@ -1088,22 +1086,22 @@ int Session::release()
void Session::clearProvidersAndSockets()
{
for (unsigned i = 0; i < mStreamList.size(); i++)
for (unsigned i=0; i<mStreamList.size(); i++)
{
Session::Stream& ds = mStreamList[i];
if (ds.provider())
{
ds.provider()->sessionDeleted();
SocketHeap::instance().freeSocketPair(ds.socket4());
SocketHeap::instance().freeSocketPair(ds.socket6());
SocketHeap::instance().freeSocketPair( ds.socket4() );
SocketHeap::instance().freeSocketPair( ds.socket6() );
}
}
}
void Session::clearProviders()
{
for (unsigned i = 0; i < mStreamList.size(); i++)
for (unsigned i=0; i<mStreamList.size(); i++)
{
Session::Stream& ds = mStreamList[i];
@@ -1139,13 +1137,14 @@ void Session::processQueuedOffer()
//-------------- ResipSessionFactory ---------
#pragma region ResipSessionFactory
ResipSessionFactory::ResipSessionFactory(UserAgent* agent) : mAgent(agent) {}
ResipSessionFactory::ResipSessionFactory(UserAgent* agent)
:mAgent(agent)
{}
resip::AppDialogSet* ResipSessionFactory::createAppDialogSet(resip::DialogUsageManager& dum,
const resip::SipMessage& msg)
resip::AppDialogSet* ResipSessionFactory::createAppDialogSet(resip::DialogUsageManager& dum, const resip::SipMessage& msg)
{
ResipSession* s = new ResipSession(dum);
s->setUa(mAgent);
s->setUa( mAgent );
return s;
}
src/engine/endpoint/EP_Session.h
+249 -249
View File
@@ -28,14 +28,15 @@
#include "rutil/Logger.hxx"
#include "rutil/Random.hxx"
#include "rutil/WinLeakCheck.hxx"
#include "rutil/AtomicCounter.hxx"
#include "../ice/ICEBox.h"
#include <sstream>
#include <atomic>
#include <time.h>
#include "../engine_config.h"
#include "../config.h"
#include "EP_Session.h"
#include "EP_Account.h"
#include "EP_DataProvider.h"
#include "EP_AudioProvider.h"
@@ -49,276 +50,276 @@ class ResipSession;
enum SessionInfo
{
SessionInfo_RemoteSipAddress, // remote sip address
SessionInfo_ReceivedTraffic, // amount of received traffic in session in bytes
SessionInfo_SentTraffic, // amount of sent traffic in session in bytes
SessionInfo_PacketLoss, // lost packets counter; returns number of 1/1000 fractions (0.1%)
SessionInfo_AudioPeer, // remote peer rtp address in text
SessionInfo_AudioCodec, // selected audio codec as text
SessionInfo_DtmfInterface, // Pointer to DtmfQueue class; returned as void*
SessionInfo_IceState,
SessionInfo_NetworkMos,
SessionInfo_PvqaMos,
SessionInfo_PvqaReport,
SessionInfo_SentRtp,
SessionInfo_SentRtcp,
SessionInfo_ReceivedRtp,
SessionInfo_ReceivedRtcp,
SessionInfo_LostRtp,
SessionInfo_DroppedRtp,
SessionInfo_Duration,
SessionInfo_Jitter,
SessionInfo_Rtt,
SessionInfo_BitrateSwitchCounter, // It is for AMR codecs only
SessionInfo_RemotePeer,
SessionInfo_SSRC,
SessionInfo_CngCounter, // For AMR codecs only
SessionInfo_ReceivedRtpTraffic // amount of received RTP traffic in bytes, RTCP excluded
SessionInfo_RemoteSipAddress, // remote sip address
SessionInfo_ReceivedTraffic, // amount of received traffic in session in bytes
SessionInfo_SentTraffic, // amount of sent traffic in session in bytes
SessionInfo_PacketLoss, // lost packets counter; returns number of 1/1000 fractions (0.1%)
SessionInfo_AudioPeer, // remote peer rtp address in text
SessionInfo_AudioCodec, // selected audio codec as text
SessionInfo_DtmfInterface, // Pointer to DtmfQueue class; returned as void*
SessionInfo_IceState,
SessionInfo_NetworkMos,
SessionInfo_PvqaMos,
SessionInfo_PvqaReport,
SessionInfo_SentRtp,
SessionInfo_SentRtcp,
SessionInfo_ReceivedRtp,
SessionInfo_ReceivedRtcp,
SessionInfo_LostRtp,
SessionInfo_DroppedRtp,
SessionInfo_Duration,
SessionInfo_Jitter,
SessionInfo_Rtt,
SessionInfo_BitrateSwitchCounter, // It is for AMR codecs only
SessionInfo_RemotePeer,
SessionInfo_SSRC,
};
class Session : public SocketSink, public ice::StageHandler
class Session :
public SocketSink,
public ice::StageHandler
{
public:
class Command
class Command
{
public:
virtual void run(Session& s) = 0;
};
// Describes ice stream/component
struct IceInfo
{
IceInfo()
:mStreamId(-1)
{
public:
virtual void run(Session& s) = 0;
};
mPort4 = mPort6 = 0;
mComponentId.mRtp = mComponentId.mRtcp = -1;
}
// Describes ice stream/component
struct IceInfo
{
IceInfo() : mStreamId(-1)
{
mPort4 = mPort6 = 0;
mComponentId.mRtp = mComponentId.mRtcp = -1;
}
RtpPair<int> mComponentId;
int mStreamId;
unsigned short mPort4;
unsigned short mPort6;
};
RtpPair<int> mComponentId;
int mStreamId;
unsigned short mPort4;
unsigned short mPort6;
};
// Describes media stream (audio/video) in session
class Stream
{
public:
Stream();
~Stream();
// Describes media stream (audio/video) in session
class Stream
{
public:
Stream();
~Stream();
void setProvider(PDataProvider provider);
PDataProvider provider();
void setProvider(PDataProvider provider);
PDataProvider provider();
void setSocket4(const RtpPair<PDatagramSocket>& socket);
RtpPair<PDatagramSocket>& socket4();
void setSocket4(const RtpPair<PDatagramSocket>& socket);
RtpPair<PDatagramSocket>& socket4();
void setSocket6(const RtpPair<PDatagramSocket>& socket);
RtpPair<PDatagramSocket>& socket6();
void setSocket6(const RtpPair<PDatagramSocket>& socket);
RtpPair<PDatagramSocket>& socket6();
void setIceInfo(const IceInfo& info);
IceInfo iceInfo() const;
void setIceInfo(const IceInfo& info);
IceInfo iceInfo() const;
// rtcpAttr/rtcpMuxAttr signals about corresponding sip attribute in offer/answer from remote peer
bool rtcpAttr() const;
void setRtcpAttr(bool value);
// rtcpAttr/rtcpMuxAttr signals about corresponding sip attribute in offer/answer from remote peer
bool rtcpAttr() const;
void setRtcpAttr(bool value);
bool rtcpMuxAttr() const;
void setRtcpMuxAttr(bool value);
bool rtcpMuxAttr() const;
void setRtcpMuxAttr(bool value);
protected:
// Provider for corresponding stream
PDataProvider mProvider;
protected:
// Provider for corresponding stream
PDataProvider mProvider;
// Socket for stream
RtpPair<PDatagramSocket> mSocket4, mSocket6;
// Socket for stream
RtpPair<PDatagramSocket> mSocket4, mSocket6;
bool mRtcpAttr;
bool mRtcpMuxAttr;
IceInfo mIceInfo;
};
bool mRtcpAttr;
bool mRtcpMuxAttr;
IceInfo mIceInfo;
};
Session(PAccount account);
virtual ~Session();
Session(PAccount account);
virtual ~Session();
// Starts call to specified peer
void start(const std::string& peer);
// Starts call to specified peer
void start(const std::string& peer);
// Stops call
void stop();
// Stops call
void stop();
// Accepts call
void accept();
// Accepts call
void accept();
// Rejects call
void reject(int code);
// Rejects call
void reject(int code);
enum class InfoOptions
{
Standard = 0,
Detailed = 1,
};
enum class InfoOptions
{
Standard = 0,
Detailed = 1,
};
void getSessionInfo(InfoOptions options, VariantMap& result);
void getSessionInfo(InfoOptions options, VariantMap& result);
// Returns integer identifier of the session; it is unique amongst all session in application
int id() const;
// Returns integer identifier of the session; it is unique amongst all session in application
int id() const;
// Returns owning account
PAccount account();
// Returns owning account
PAccount account();
typedef std::map<std::string, std::string> UserHeaders;
void setUserHeaders(const UserHeaders& headers);
typedef std::map<std::string, std::string> UserHeaders;
void setUserHeaders(const UserHeaders& headers);
// Called when new media data are available for this session
void onReceivedData(PDatagramSocket socket, InternetAddress& src, const void* receivedPtr, unsigned receivedSize);
// Called when new media data are available for this session
void onReceivedData(PDatagramSocket socket, InternetAddress& src, const void* receivedPtr, unsigned receivedSize);
// Called when new candidate is gathered
void onCandidateGathered(ice::Stack* stack, void* tag, const char* address);
// Called when new candidate is gathered
void onCandidateGathered(ice::Stack* stack, void* tag, const char* address);
// Called when connectivity check is finished
void onCheckFinished(ice::Stack* stack, void* tag, const char* checkDescription);
// Called when connectivity check is finished
void onCheckFinished(ice::Stack* stack, void* tag, const char* checkDescription);
// Called when ICE candidates are gathered - with success or timeout.
void onGathered(ice::Stack* stack, void* tag);
// Called when ICE candidates are gathered - with success or timeout.
void onGathered(ice::Stack* stack, void* tag);
// Called when ICE connectivity check is good at least for one of required streams
void onSuccess(ice::Stack* stack, void* tag);
// Called when ICE connectivity check is good at least for one of required streams
void onSuccess(ice::Stack* stack, void* tag);
// Called when ICE connectivity check is failed for all of required streams
void onFailed(ice::Stack* stack, void* tag);
// Called when ICE connectivity check is failed for all of required streams
void onFailed(ice::Stack* stack, void* tag);
// Called when ICE stack detects network change during the call
void onNetworkChange(ice::Stack* stack, void* tag);
// Called when ICE stack detects network change during the call
void onNetworkChange(ice::Stack* stack, void* tag);
// Fills SDP according to ICE and provider's data
void buildSdp(resip::SdpContents& sdp, SdpDirection sdpDirection);
// Fills SDP according to ICE and provider's data
void buildSdp(resip::SdpContents& sdp, SdpDirection sdpDirection);
// Searches provider by its local port number
PDataProvider findProviderByPort(int family, unsigned short port);
// Searches provider by its local port number
PDataProvider findProviderByPort(int family, unsigned short port);
// Add provider to internal list
void addProvider(PDataProvider provider);
PDataProvider providerAt(int index);
int getProviderCount();
// Add provider to internal list
void addProvider(PDataProvider provider);
PDataProvider providerAt(int index);
int getProviderCount();
void setUserAgent(UserAgent* agent);
UserAgent* userAgent();
void setUserAgent(UserAgent* agent);
UserAgent* userAgent();
// Pauses and resumes all providers; updates states
void pause();
void resume();
void refreshMediaPath();
// Pauses and resumes all providers; updates states
void pause();
void resume();
void refreshMediaPath();
// Processes new sdp from offer. Returns response code (200 is ok, 488 bad codec, 503 internal error).
int processSdp(UInt64 version, bool iceAvailable, std::string icePwd, std::string iceUfrag,
std::string remoteIp, const resip::SdpContents::Session::MediumContainer& media);
// Processes new sdp from offer. Returns response code (200 is ok, 488 bad codec, 503 internal error).
// There are passing string objects by value; this is correct; this values will modified on the stack.
int processSdp(uint64_t version, bool iceAvailable, std::string icePwd, const std::string iceUfrag,
std::string remoteIp, const resip::SdpContents::Session::MediumContainer& media);
// Session ID
int mSessionId;
// Session ID
int mSessionId;
// Media streams collection
std::vector<Stream> mStreamList;
// Media streams collection
std::vector<Stream> mStreamList;
// Smart pointer to ICE stack. Actually stack is created in CreateICEStack() method
resip::SharedPtr<ice::Stack> mIceStack;
// Smart pointer to ICE stack. Actually stack is created in CreateICEStack() method
std::shared_ptr<ice::Stack> mIceStack;
// Pointer to owner user agent instance
UserAgent* mUserAgent;
// Pointer to owner user agent instance
UserAgent* mUserAgent;
// Remote peer SIP address
resip::NameAddr mRemotePeer;
// Remote peer SIP address
resip::NameAddr mRemotePeer;
// Mutex to protect this instance
Mutex mGuard;
// Mutex to protect this instance
Mutex mGuard;
// SDP's origin version for sending
int mOriginVersion;
UInt64 mRemoteOriginVersion;
// SDP's origin version for sending
int mOriginVersion;
uint64_t mRemoteOriginVersion;
// SDP's session version
int mSessionVersion;
// SDP's session version
int mSessionVersion;
// Marks if this session does not need OnNewSession event
bool mAcceptedByEngine;
bool mAcceptedByUser;
// Marks if this session does not need OnNewSession event
bool mAcceptedByEngine;
bool mAcceptedByUser;
// Invite session handle
resip::InviteSessionHandle mInviteHandle;
// Invite session handle
resip::InviteSessionHandle mInviteHandle;
// Dialog set object pointer
ResipSession* mResipSession;
// Dialog set object pointer
ResipSession* mResipSession;
// Reference counter
int mRefCount;
// Reference counter
int mRefCount;
enum
{
Initiator = 1,
Acceptor = 2
};
enum
{
Initiator = 1,
Acceptor = 2
};
// Specifies session role - caller (Initiator) or callee (Acceptor)
volatile int mRole;
// Specifies session role - caller (Initiator) or callee (Acceptor)
volatile int mRole;
// Marks if candidates are gather already
volatile bool mGatheredCandidates;
// Marks if candidates are gather already
volatile bool mGatheredCandidates;
// Marks if OnTerminated event was called already on session
volatile bool mTerminated;
// Marks if OnTerminated event was called already on session
volatile bool mTerminated;
// User friend remote peer's sip address
std::string mRemoteAddress;
// User friend remote peer's sip address
std::string mRemoteAddress;
// Application specific data
void* mTag;
// Application specific data
void* mTag;
// Used to count number of transistions to Connected state and avoid multiple onEstablished events.
int mOfferAnswerCounter;
// Used to count number of transistions to Connected state and avoid multiple onEstablished events.
int mOfferAnswerCounter;
// List of turn prefixes related to sessioj
std::vector<int> mTurnPrefixList;
// List of turn prefixes related to sessioj
std::vector<int> mTurnPrefixList;
// True if user agent has to send offer
bool mHasToSendOffer;
// True if user agent has to send offer
bool mHasToSendOffer;
// True if user agent has to enqueue offer after ice gather finished
bool mSendOfferUpdateAfterIceGather;
// True if user agent has to enqueue offer after ice gather finished
bool mSendOfferUpdateAfterIceGather;
// Related sip account
PAccount mAccount;
// Related sip account
PAccount mAccount;
// User headers for INVITE transaction
UserHeaders mUserHeaders;
// User headers for INVITE transaction
UserHeaders mUserHeaders;
std::string remoteAddress() const;
void setRemoteAddress(const std::string& address);
std::string remoteAddress() const;
void setRemoteAddress(const std::string& address);
void* tag();
void setTag(void* tag);
int sessionId();
int increaseSdpVersion();
int addRef();
int release();
void* tag();
void setTag(void* tag);
int sessionId();
int increaseSdpVersion();
int addRef();
int release();
// Deletes providers and media sockets
void clearProvidersAndSockets();
// Deletes providers and media sockets
void clearProvidersAndSockets();
// Deletes providers
void clearProviders();
// Deletes providers
void clearProviders();
// Helper method to find audio provider for active sip stream
AudioProvider* findProviderForActiveAudio();
// Helper method to find audio provider for active sip stream
AudioProvider* findProviderForActiveAudio();
void processCommandList();
void addCommand(Command* cmd);
void enqueueOffer();
void processQueuedOffer();
static int generateId();
static std::atomic_int IdGenerator;
static std::atomic_int InstanceCounter;
void processCommandList();
void addCommand(Command* cmd);
void enqueueOffer();
void processQueuedOffer();
static int generateId();
static resip::AtomicCounter IdGenerator;
static resip::AtomicCounter InstanceCounter;
};
typedef std::shared_ptr<Session> PSession;
@@ -335,77 +336,76 @@ typedef std::shared_ptr<Session> PSession;
class ResipSessionAppDialog : public resip::AppDialog
{
public:
ResipSessionAppDialog(resip::HandleManager& ham);
virtual ~ResipSessionAppDialog();
ResipSessionAppDialog(resip::HandleManager& ham);
virtual ~ResipSessionAppDialog();
};
class ResipSession : public resip::AppDialogSet
class ResipSession: public resip::AppDialogSet
{
friend class UserAgent;
friend class Account;
friend class UserAgent;
friend class Account;
public:
enum Type
{
Type_None,
Type_Registration,
Type_Subscription,
Type_Call,
Type_Auto
};
static std::atomic_int InstanceCounter;
enum Type
{
Type_None,
Type_Registration,
Type_Subscription,
Type_Call,
Type_Auto
};
static resip::AtomicCounter InstanceCounter;
ResipSession(resip::DialogUsageManager& dum);
virtual ~ResipSession();
virtual resip::AppDialog* createAppDialog(const resip::SipMessage& msg);
virtual std::shared_ptr<resip::UserProfile> selectUASUserProfile(const resip::SipMessage& msg);
ResipSession(resip::DialogUsageManager& dum);
virtual ~ResipSession();
virtual resip::AppDialog* createAppDialog(const resip::SipMessage& msg);
virtual resip::SharedPtr<resip::UserProfile> selectUASUserProfile(const resip::SipMessage& msg);
void setType(Type type);
Type type();
void setType(Type type);
Type type();
Session* session();
void setSession(Session* session);
Session* session();
void setSession(Session* session);
UserAgent* ua();
void setUa(UserAgent* ua);
UserAgent* ua();
void setUa(UserAgent* ua);
// Used for subscriptions/messages
int sessionId();
// Used for subscriptions/messages
int sessionId();
// Used for subscriptions/messages
void* tag() const;
void setTag(void* tag);
// Used for subscriptions/messages
void* tag() const;
void setTag(void* tag);
// Used for subscriptions/messages
std::string remoteAddress() const;
void setRemoteAddress(std::string address);
// Used for subscriptions/messages
std::string remoteAddress() const;
void setRemoteAddress(std::string address);
void runTerminatedEvent(Type type, int code = 0, int reason = 0);
void runTerminatedEvent(Type type, int code = 0, int reason = 0);
void setUASProfile(const std::shared_ptr<resip::UserProfile>& profile);
void setUASProfile(std::shared_ptr<resip::UserProfile> profile);
protected:
bool mTerminated;
UserAgent* mUserAgent;
Type mType;
Session* mSession;
int mSessionId;
std::string mRemoteAddress;
void* mTag;
bool mOnWatchingStartSent;
std::shared_ptr<resip::UserProfile> mUASProfile;
bool mTerminated;
UserAgent* mUserAgent;
Type mType;
Session* mSession;
int mSessionId;
std::string mRemoteAddress;
void* mTag;
bool mOnWatchingStartSent;
std::shared_ptr<resip::UserProfile> mUASProfile;
};
class ResipSessionFactory : public resip::AppDialogSetFactory
{
public:
ResipSessionFactory(UserAgent* agent);
virtual resip::AppDialogSet* createAppDialogSet(resip::DialogUsageManager& dum, const resip::SipMessage& msg);
ResipSessionFactory(UserAgent* agent);
virtual resip::AppDialogSet* createAppDialogSet(resip::DialogUsageManager& dum, const resip::SipMessage& msg);
protected:
UserAgent* mAgent;
UserAgent* mAgent;
};
#endif
src/engine/engine_config.h
-119
View File
@@ -1,119 +0,0 @@
/* Copyright(C) 2007-2023 VoIP objects (voipobjects.com)
* 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 __TOOLKIT_CONFIG_H
#define __TOOLKIT_CONFIG_H
#define USE_SPEEX_AEC
// TODO: test implementation with webrtc aec; be careful - it needs fixes!
// #define USE_WEBRTC_AEC
#define USER
#define AUDIO_SAMPLE_WIDTH 16
#define AUDIO_CHANNELS 1
// Samplerate must be 8 / 16 / 24 / 32 / 48 KHz
#define AUDIO_SAMPLERATE 48000
#define AUDIO_MIC_BUFFER_COUNT 16
#define AUDIO_MIC_BUFFER_LENGTH 10
#define AUDIO_MIC_BUFFER_SIZE (AUDIO_MIC_BUFFER_LENGTH * AUDIO_SAMPLERATE / 1000 * 2 * AUDIO_CHANNELS)
#define AUDIO_SPK_BUFFER_COUNT 16
#define AUDIO_SPK_BUFFER_LENGTH 10
#define AUDIO_SPK_BUFFER_SIZE (AUDIO_SPK_BUFFER_LENGTH * AUDIO_SAMPLERATE / 1000 * 2 * AUDIO_CHANNELS)
#define AUDIO_MIX_CHANNEL_COUNT 16
#define AUDIO_DEVICEPAIR_INPUTBUFFER 16384
// Resampler quality on the Speex 0..10 scale. Quality 1 upsampling (e.g. G.711 8k -> 48k)
// adds audible aliasing and hurts PVQA/AQuA scores; 7 is a good fidelity/CPU balance for a
// single mono stream on modern ARM64. Raise toward 10 for max fidelity if CPU allows.
#define AUDIO_RESAMPLER_QUALITY 7
#define AEC_FRAME_TIME 10
#define AEC_TAIL_TIME 160
// Defined these two lines to get dumping of audio input/output
// #define AUDIO_DUMPINPUT
// #define AUDIO_DUMPOUTPUT
#define UA_REGISTRATION_TIME 3600
#define UA_MEDIA_PORT_START 20000
#define UA_MEDIA_PORT_FINISH 30000
#define UA_MAX_UDP_PACKET_SIZE 576
#define UA_PUBLICATION_ID "314"
#define MT_SAMPLERATE AUDIO_SAMPLERATE
#define MT_MAXAUDIOFRAME 1440
#define MT_MAXRTPPACKET 1500
#define MT_DTMF_END_PACKETS 3
// Milliseconds before
#define RTP_BUFFER_HIGH (2000)
#define RTP_BUFFER_LOW (0)
#define RTP_BUFFER_PREBUFFER (100)
#define RTP_DECODED_CAPACITY 2048
#define DEFAULT_SUBSCRIPTION_TIME 1200
#define DEFAULT_SUBSCRIPTION_REFRESHTIME 500
#define PRESENCE_IN_REG_HEADER "PresenceInReg"
// Maximum UDP packet length
#define MAX_UDPPACKET_SIZE 65535
#define MAX_VALID_UDPPACKET_SIZE 2048
// AMR codec defines - it requires USE_AMR_CODEC defined
// #define USE_AMR_CODEC
#define MT_AMRNB_PAYLOADTYPE 112
#define MT_AMRNB_CODECNAME "amr"
#define MT_AMRNB_OCTET_PAYLOADTYPE 113
#define MT_AMRWB_PAYLOADTYPE 96
#define MT_AMRWB_CODECNAME "amr-wb"
#define MT_AMRWB_OCTET_PAYLOADTYPE 97
#define MT_GSMEFR_PAYLOADTYPE 126
#define MT_GSMEFR_CODECNAME "GERAN-EFR"
#define MT_EVS_PAYLOADTYPE 127
#define MT_EVS_CODECNAME "EVS"
// OPUS codec defines
#define MT_OPUS_CODEC_PT 106
// ILBC codec defines
#define MT_ILBC20_PAYLOADTYPE -1
#define MT_ILBC30_PAYLOADTYPE -1
// ISAC codec defines
#define MT_ISAC16K_PAYLOADTYPE -1
#define MT_ISAC32K_PAYLOADTYPE -1
// GSM HR payload type
#define MT_GSMHR_PAYLOADTYPE -1
// Mirror buffer capacity
#define MT_MIRROR_CAPACITY 32768
// Mirror buffer readiness threshold - 50 milliseconds
#define MT_MIRROR_PREBUFFER (MT_SAMPLERATE / 10)
#if defined(TARGET_OSX) || defined(TARGET_LINUX)
#define TEXT(X) X
#endif
// In milliseconds
#define MT_SEVANA_FRAME_TIME 680
// Number of samples
#define MT_MAX_DECODEBUFFER 32768
#endif
src/engine/helper/CMakeLists.txt
+4 -7
View File
@@ -1,20 +1,17 @@
cmake_minimum_required (VERSION 3.15)
project (helper_lib)
# Rely on C++ 11
set (CMAKE_CXX_STANDARD 20)
set (CMAKE_CXX_STANDARD 11)
set (CMAKE_CXX_STANDARD_REQUIRED ON)
set (USE_NULL_UUID OFF CACHE BOOL "When enabled linking to libuuid is avoided")
set (CMAKE_POSITION_INDEPENDENT_CODE ON)
file (GLOB HELPER_LIB_SOURCES "*.cpp" "*.h")
add_library(helper_lib ${HELPER_LIB_SOURCES})
set_property(TARGET helper_lib PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
# Private include directories
target_include_directories(helper_lib PUBLIC ../../libs/ ../../engine ../ .)
target_include_directories(helper_lib PRIVATE ../../libs/ ../../engine ../)
target_compile_definitions(helper_lib PRIVATE -D_CRT_SECURE_NO_WARNINGS -D_UNICODE)
if (TARGET_LINUX)
target_link_libraries (helper_lib PUBLIC uuid)
endif()
src/engine/helper/HL_AsyncCommand.cpp
+8 -2
View File
@@ -5,6 +5,12 @@
#include "HL_AsyncCommand.h"
AsyncCommand::AsyncCommand() {}
AsyncCommand::AsyncCommand()
{
AsyncCommand::~AsyncCommand() {}
}
AsyncCommand::~AsyncCommand()
{
}
src/engine/helper/HL_AsyncCommand.h
+4 -4
View File
@@ -9,11 +9,11 @@
class AsyncCommand
{
public:
AsyncCommand();
virtual ~AsyncCommand();
AsyncCommand();
virtual ~AsyncCommand();
virtual void run(void* environment) = 0;
virtual bool finished() = 0;
virtual void run(void* environment) = 0;
virtual bool finished() = 0;
};
#endif // HL_ASYNCCOMMAND_H
src/engine/helper/HL_Base64.h
+191 -239
View File
@@ -4,301 +4,253 @@
#include <string>
const char kBase64Alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789+/";
"abcdefghijklmnopqrstuvwxyz"
"0123456789+/";
class Base64
{
public:
static bool Encode(const std::string& in, std::string* out)
{
int i = 0, j = 0;
size_t enc_len = 0;
unsigned char a3[3];
unsigned char a4[4];
class Base64 {
public:
static bool Encode(const std::string &in, std::string *out) {
int i = 0, j = 0;
size_t enc_len = 0;
unsigned char a3[3];
unsigned char a4[4];
out->resize(EncodedLength(in));
out->resize(EncodedLength(in));
int input_len = in.size();
std::string::const_iterator input = in.begin();
int input_len = in.size();
std::string::const_iterator input = in.begin();
while (input_len--)
{
a3[i++] = *(input++);
if (i == 3)
{
a3_to_a4(a4, a3);
while (input_len--) {
a3[i++] = *(input++);
if (i == 3) {
a3_to_a4(a4, a3);
for (i = 0; i < 4; i++)
{
(*out)[enc_len++] = kBase64Alphabet[a4[i]];
}
i = 0;
}
for (i = 0; i < 4; i++) {
(*out)[enc_len++] = kBase64Alphabet[a4[i]];
}
if (i)
{
for (j = i; j < 3; j++)
{
a3[j] = '\0';
}
i = 0;
}
}
a3_to_a4(a4, a3);
if (i) {
for (j = i; j < 3; j++) {
a3[j] = '\0';
}
for (j = 0; j < i + 1; j++)
{
(*out)[enc_len++] = kBase64Alphabet[a4[j]];
}
a3_to_a4(a4, a3);
while ((i++ < 3))
{
(*out)[enc_len++] = '=';
}
for (j = 0; j < i + 1; j++) {
(*out)[enc_len++] = kBase64Alphabet[a4[j]];
}
while ((i++ < 3)) {
(*out)[enc_len++] = '=';
}
}
return (enc_len == out->size());
}
static bool Encode(const char *input, size_t input_length, char *out, size_t out_length) {
int i = 0, j = 0;
char *out_begin = out;
unsigned char a3[3];
unsigned char a4[4];
size_t encoded_length = EncodedLength(input_length);
if (out_length < encoded_length) return false;
while (input_length--) {
a3[i++] = *input++;
if (i == 3) {
a3_to_a4(a4, a3);
for (i = 0; i < 4; i++) {
*out++ = kBase64Alphabet[a4[i]];
}
return (enc_len == out->size());
i = 0;
}
}
static bool Encode(const char* input, size_t input_length, char* out, size_t out_length)
{
int i = 0, j = 0;
char* out_begin = out;
unsigned char a3[3];
unsigned char a4[4];
if (i) {
for (j = i; j < 3; j++) {
a3[j] = '\0';
}
size_t encoded_length = EncodedLength(input_length);
a3_to_a4(a4, a3);
if (out_length < encoded_length)
return false;
for (j = 0; j < i + 1; j++) {
*out++ = kBase64Alphabet[a4[j]];
}
while (input_length--)
{
a3[i++] = *input++;
if (i == 3)
{
a3_to_a4(a4, a3);
while ((i++ < 3)) {
*out++ = '=';
}
}
for (i = 0; i < 4; i++)
{
*out++ = kBase64Alphabet[a4[i]];
}
return (out == (out_begin + encoded_length));
}
i = 0;
}
static bool Decode(const std::string &in, std::string *out) {
int i = 0, j = 0;
size_t dec_len = 0;
unsigned char a3[3];
unsigned char a4[4];
int input_len = in.size();
std::string::const_iterator input = in.begin();
out->resize(DecodedLength(in));
while (input_len--) {
if (*input == '=') {
break;
}
a4[i++] = *(input++);
if (i == 4) {
for (i = 0; i <4; i++) {
a4[i] = b64_lookup(a4[i]);
}
if (i)
{
for (j = i; j < 3; j++)
{
a3[j] = '\0';
}
a4_to_a3(a3,a4);
a3_to_a4(a4, a3);
for (j = 0; j < i + 1; j++)
{
*out++ = kBase64Alphabet[a4[j]];
}
while ((i++ < 3))
{
*out++ = '=';
}
for (i = 0; i < 3; i++) {
(*out)[dec_len++] = a3[i];
}
return (out == (out_begin + encoded_length));
i = 0;
}
}
static bool Decode(const std::string& in, std::string* out)
{
int i = 0, j = 0;
size_t dec_len = 0;
unsigned char a3[3];
unsigned char a4[4];
if (i) {
for (j = i; j < 4; j++) {
a4[j] = '\0';
}
int input_len = in.size();
std::string::const_iterator input = in.begin();
for (j = 0; j < 4; j++) {
a4[j] = b64_lookup(a4[j]);
}
out->resize(DecodedLength(in));
a4_to_a3(a3,a4);
while (input_len--)
{
if (*input == '=')
{
break;
}
for (j = 0; j < i - 1; j++) {
(*out)[dec_len++] = a3[j];
}
}
a4[i++] = *(input++);
if (i == 4)
{
for (i = 0; i < 4; i++)
{
a4[i] = b64_lookup(a4[i]);
}
return (dec_len == out->size());
}
a4_to_a3(a3, a4);
static bool Decode(const char *input, size_t input_length, char *out, size_t out_length) {
int i = 0, j = 0;
char *out_begin = out;
unsigned char a3[3];
unsigned char a4[4];
for (i = 0; i < 3; i++)
{
(*out)[dec_len++] = a3[i];
}
size_t decoded_length = DecodedLength(input, input_length);
i = 0;
}
if (out_length < decoded_length) return false;
while (input_length--) {
if (*input == '=') {
break;
}
a4[i++] = *(input++);
if (i == 4) {
for (i = 0; i <4; i++) {
a4[i] = b64_lookup(a4[i]);
}
if (i)
{
for (j = i; j < 4; j++)
{
a4[j] = '\0';
}
a4_to_a3(a3,a4);
for (j = 0; j < 4; j++)
{
a4[j] = b64_lookup(a4[j]);
}
a4_to_a3(a3, a4);
for (j = 0; j < i - 1; j++)
{
(*out)[dec_len++] = a3[j];
}
for (i = 0; i < 3; i++) {
*out++ = a3[i];
}
return (dec_len == out->size());
i = 0;
}
}
static bool Decode(const char* input, size_t input_length, char* out, size_t out_length)
{
int i = 0, j = 0;
char* out_begin = out;
unsigned char a3[3];
unsigned char a4[4];
if (i) {
for (j = i; j < 4; j++) {
a4[j] = '\0';
}
size_t decoded_length = DecodedLength(input, input_length);
for (j = 0; j < 4; j++) {
a4[j] = b64_lookup(a4[j]);
}
if (out_length < decoded_length)
return false;
a4_to_a3(a3,a4);
while (input_length--)
{
if (*input == '=')
{
break;
}
a4[i++] = *(input++);
if (i == 4)
{
for (i = 0; i < 4; i++)
{
a4[i] = b64_lookup(a4[i]);
}
a4_to_a3(a3, a4);
for (i = 0; i < 3; i++)
{
*out++ = a3[i];
}
i = 0;
}
}
if (i)
{
for (j = i; j < 4; j++)
{
a4[j] = '\0';
}
for (j = 0; j < 4; j++)
{
a4[j] = b64_lookup(a4[j]);
}
a4_to_a3(a3, a4);
for (j = 0; j < i - 1; j++)
{
*out++ = a3[j];
}
}
return (out == (out_begin + decoded_length));
for (j = 0; j < i - 1; j++) {
*out++ = a3[j];
}
}
static int DecodedLength(const char* in, size_t in_length)
{
int numEq = 0;
return (out == (out_begin + decoded_length));
}
const char* in_end = in + in_length;
while (*--in_end == '=')
++numEq;
static int DecodedLength(const char *in, size_t in_length) {
int numEq = 0;
return ((6 * in_length) / 8) - numEq;
const char *in_end = in + in_length;
while (*--in_end == '=') ++numEq;
return ((6 * in_length) / 8) - numEq;
}
static int DecodedLength(const std::string &in) {
int numEq = 0;
int n = in.size();
for (std::string::const_reverse_iterator it = in.rbegin(); *it == '='; ++it) {
++numEq;
}
static int DecodedLength(const std::string& in)
{
int numEq = 0;
int n = in.size();
return ((6 * n) / 8) - numEq;
}
for (std::string::const_reverse_iterator it = in.rbegin(); *it == '='; ++it)
{
++numEq;
}
inline static int EncodedLength(size_t length) {
return (length + 2 - ((length + 2) % 3)) / 3 * 4;
}
return ((6 * n) / 8) - numEq;
}
inline static int EncodedLength(const std::string &in) {
return EncodedLength(in.length());
}
inline static int EncodedLength(size_t length) { return (length + 2 - ((length + 2) % 3)) / 3 * 4; }
inline static void StripPadding(std::string *in) {
while (!in->empty() && *(in->rbegin()) == '=') in->resize(in->size() - 1);
}
inline static int EncodedLength(const std::string& in) { return EncodedLength(in.length()); }
private:
static inline void a3_to_a4(unsigned char * a4, unsigned char * a3) {
a4[0] = (a3[0] & 0xfc) >> 2;
a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);
a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);
a4[3] = (a3[2] & 0x3f);
}
inline static void StripPadding(std::string* in)
{
while (!in->empty() && *(in->rbegin()) == '=')
in->resize(in->size() - 1);
}
static inline void a4_to_a3(unsigned char * a3, unsigned char * a4) {
a3[0] = (a4[0] << 2) + ((a4[1] & 0x30) >> 4);
a3[1] = ((a4[1] & 0xf) << 4) + ((a4[2] & 0x3c) >> 2);
a3[2] = ((a4[2] & 0x3) << 6) + a4[3];
}
private:
static inline void a3_to_a4(unsigned char* a4, unsigned char* a3)
{
a4[0] = (a3[0] & 0xfc) >> 2;
a4[1] = ((a3[0] & 0x03) << 4) + ((a3[1] & 0xf0) >> 4);
a4[2] = ((a3[1] & 0x0f) << 2) + ((a3[2] & 0xc0) >> 6);
a4[3] = (a3[2] & 0x3f);
}
static inline void a4_to_a3(unsigned char* a3, unsigned char* a4)
{
a3[0] = (a4[0] << 2) + ((a4[1] & 0x30) >> 4);
a3[1] = ((a4[1] & 0xf) << 4) + ((a4[2] & 0x3c) >> 2);
a3[2] = ((a4[2] & 0x3) << 6) + a4[3];
}
static inline unsigned char b64_lookup(unsigned char c)
{
if (c >= 'A' && c <= 'Z')
return c - 'A';
if (c >= 'a' && c <= 'z')
return c - 71;
if (c >= '0' && c <= '9')
return c + 4;
if (c == '+')
return 62;
if (c == '/')
return 63;
return 255;
}
static inline unsigned char b64_lookup(unsigned char c) {
if(c >='A' && c <='Z') return c - 'A';
if(c >='a' && c <='z') return c - 71;
if(c >='0' && c <='9') return c + 4;
if(c == '+') return 62;
if(c == '/') return 63;
return 255;
}
};
#endif // HL_BASE64_H
src/engine/helper/HL_ByteBuffer.h
+4 -4
View File
@@ -8,10 +8,10 @@
#include "ice/ICEByteBuffer.h"
typedef ice::ByteBuffer ByteBuffer;
typedef ice::PByteBuffer PByteBuffer;
typedef ice::BitReader BitReader;
typedef ice::BitWriter BitWriter;
typedef ice::ByteBuffer ByteBuffer;
typedef ice::PByteBuffer PByteBuffer;
typedef ice::BitReader BitReader;
typedef ice::BitWriter BitWriter;
typedef ice::BufferReader BufferReader;
typedef ice::BufferWriter BufferWriter;
src/engine/helper/HL_Calculator.h
+474 -487
View File
File diff suppressed because it is too large Load Diff
src/engine/helper/HL_CrashRpt.cpp
+84 -79
View File
@@ -14,65 +14,64 @@
BOOL WINAPI CrashReporter::Callback(LPVOID arg)
{
return TRUE;
return TRUE;
}
typedef int(__stdcall* CrInstallProc)(__in PCR_INSTALL_INFOW pInfo);
typedef int(__stdcall *CrInstallProc)(__in PCR_INSTALL_INFOW pInfo);
static CrInstallProc CrInstall = nullptr;
typedef int(__stdcall* CrUninstallProc)();
typedef int(__stdcall *CrUninstallProc)();
static CrUninstallProc CrUninstall = nullptr;
typedef int(__stdcall* CrInstallIntoCurrentThreadProc)(DWORD dwFlags);
typedef int(__stdcall *CrInstallIntoCurrentThreadProc)(DWORD dwFlags);
static CrInstallIntoCurrentThreadProc CrInstallIntoCurrentThread = nullptr;
typedef int(__stdcall* CrUninstallFromCurrentThreadProc)();
typedef int(__stdcall *CrUninstallFromCurrentThreadProc)();
static CrUninstallFromCurrentThreadProc CrUninstallFromCurrentThread = nullptr;
typedef int(__stdcall* CrGetLastErrorMsgProc)(LPWSTR buffer, UINT size);
typedef int(__stdcall *CrGetLastErrorMsgProc)(LPWSTR buffer, UINT size);
static CrGetLastErrorMsgProc CrGetLastErrorMsg = nullptr;
static HMODULE CrLibraryHandle = NULL;
static HMODULE CrLibraryHandle = NULL;
#endif
void CrashReporter::init(const std::string& appname, const std::string& version, const std::string& url)
{
#if defined(TARGET_WIN)
#if defined(CRASHRPT_DYNAMIC)
// Check if DLL functions are here
if (CrLibraryHandle)
return; // Library is loaded already - so initialized already
// Check if DLL functions are here
if (CrLibraryHandle)
return; // Library is loaded already - so initialized already
CrLibraryHandle = ::LoadLibrary(TEXT("crashrpt.dll"));
if (!CrLibraryHandle)
return; // No logging here - initialization happens on very first stages, no chance to log anything
CrLibraryHandle = ::LoadLibrary(TEXT("crashrpt.dll"));
if (!CrLibraryHandle)
return; // No logging here - initialization happens on very first stages, no chance to log anything
CrInstall = (CrInstallProc)::GetProcAddress(CrLibraryHandle, "crInstallW");
CrUninstall = (CrUninstallProc)::GetProcAddress(CrLibraryHandle, "crUninstall");
CrInstallIntoCurrentThread =
(CrInstallIntoCurrentThreadProc)::GetProcAddress(CrLibraryHandle, "crInstallToCurrentThread2");
CrUninstallFromCurrentThread =
(CrUninstallFromCurrentThreadProc)::GetProcAddress(CrLibraryHandle, "crUninstallFromCurrentThread");
CrGetLastErrorMsg = (CrGetLastErrorMsgProc)::GetProcAddress(CrLibraryHandle, "crGetLastErrorMsgW");
CrInstall = (CrInstallProc)::GetProcAddress(CrLibraryHandle, "crInstallW");
CrUninstall = (CrUninstallProc)::GetProcAddress(CrLibraryHandle, "crUninstall");
CrInstallIntoCurrentThread = (CrInstallIntoCurrentThreadProc)::GetProcAddress(CrLibraryHandle, "crInstallToCurrentThread2");
CrUninstallFromCurrentThread = (CrUninstallFromCurrentThreadProc)::GetProcAddress(CrLibraryHandle, "crUninstallFromCurrentThread");
CrGetLastErrorMsg = (CrGetLastErrorMsgProc)::GetProcAddress(CrLibraryHandle, "crGetLastErrorMsgW");
#else
CrInstall = &crInstallW;
CrUninstall = &crUninstall;
CrInstallIntoCurrentThread = &crInstallToCurrentThread2;
CrUninstallFromCurrentThread = &crUninstallFromCurrentThread;
CrGetLastErrorMsg = &crGetLastErrorMsgW;
CrInstall = &crInstallW;
CrUninstall = &crUninstall;
CrInstallIntoCurrentThread = &crInstallToCurrentThread2;
CrUninstallFromCurrentThread = &crUninstallFromCurrentThread;
CrGetLastErrorMsg = &crGetLastErrorMsgW;
#endif
if (!isLoaded())
return;
if (!isLoaded())
return;
CR_INSTALL_INFO info;
memset(&info, 0, sizeof(CR_INSTALL_INFO));
info.cb = sizeof(CR_INSTALL_INFO);
CR_INSTALL_INFO info;
memset(&info, 0, sizeof(CR_INSTALL_INFO));
info.cb = sizeof(CR_INSTALL_INFO);
struct
{
std::wstring appname, version, url;
} unicode;
unicode.appname = StringHelper::makeTstring(appname), unicode.version = StringHelper::makeTstring(version),
unicode.appname = StringHelper::makeTstring(appname),
unicode.version = StringHelper::makeTstring(version),
unicode.url = StringHelper::makeTstring(url);
if (unicode.appname.empty())
@@ -84,105 +83,111 @@ void CrashReporter::init(const std::string& appname, const std::string& version,
if (unicode.version.empty())
unicode.version = L"General version";
info.pszAppName = unicode.appname.c_str();
info.pszAppVersion = unicode.version.c_str();
info.pszEmailSubject = TEXT("Crash report");
// info.pszEmailTo = L"amegyeri@minerva-soft.com";
// info.pszUrl = L"http://ftp.minerva-soft.com/crashlog/crashrpt.php";
// info.pszUrl = L"http://sip.crypttalk.com/crashlog/crashrpt.php";
info.pszUrl = unicode.url.c_str();
info.pfnCrashCallback = Callback;
info.uPriorities[CR_HTTP] = 1;
info.uPriorities[CR_SMTP] = CR_NEGATIVE_PRIORITY;
info.uPriorities[CR_SMAPI] = CR_NEGATIVE_PRIORITY;
info.dwFlags = 0;
info.pszCrashSenderPath = TEXT(".");
info.pszAppName = unicode.appname.c_str();
info.pszAppVersion = unicode.version.c_str();
info.pszEmailSubject = TEXT("Crash report");
//info.pszEmailTo = L"amegyeri@minerva-soft.com";
//info.pszUrl = L"http://ftp.minerva-soft.com/crashlog/crashrpt.php";
//info.pszUrl = L"http://sip.crypttalk.com/crashlog/crashrpt.php";
info.pszUrl = unicode.url.c_str();
info.pfnCrashCallback = Callback;
info.uPriorities[CR_HTTP] = 1;
info.uPriorities[CR_SMTP] = CR_NEGATIVE_PRIORITY;
info.uPriorities[CR_SMAPI] = CR_NEGATIVE_PRIORITY;
info.dwFlags = 0;
info.pszCrashSenderPath = TEXT(".");
int nResult = CrInstall(&info);
if (nResult)
{
wchar_t errorMsg[512] = L"";
CrGetLastErrorMsg(errorMsg, 512);
OutputDebugStringW(errorMsg);
// LogCritical("Core", << "Failed to install CrashReporter with code " << nResult << " and message " <<
// errorMsg);
}
int nResult = CrInstall(&info);
if (nResult)
{
wchar_t errorMsg[512] = L"";
CrGetLastErrorMsg(errorMsg, 512);
OutputDebugStringW(errorMsg);
//LogCritical("Core", << "Failed to install CrashReporter with code " << nResult << " and message " << errorMsg);
}
#endif
}
void CrashReporter::free()
{
#if defined(TARGET_WIN)
if (isLoaded())
{
CrUninstall();
CrInstall = nullptr;
CrUninstall = nullptr;
CrInstallIntoCurrentThread = nullptr;
CrUninstallFromCurrentThread = nullptr;
CrGetLastErrorMsg = nullptr;
if (isLoaded())
{
CrUninstall();
CrInstall = nullptr;
CrUninstall = nullptr;
CrInstallIntoCurrentThread = nullptr;
CrUninstallFromCurrentThread = nullptr;
CrGetLastErrorMsg = nullptr;
#if defined(CRASHRPT_DYNAMIC)
::FreeLibrary(CrLibraryHandle);
CrLibraryHandle = NULL;
::FreeLibrary(CrLibraryHandle); CrLibraryHandle = NULL;
#endif
}
}
#endif
}
bool CrashReporter::isLoaded()
{
#if defined(TARGET_WIN)
return !(!CrInstall || !CrUninstall || !CrGetLastErrorMsg || !CrInstallIntoCurrentThread ||
!CrUninstallFromCurrentThread);
return !(!CrInstall || !CrUninstall || !CrGetLastErrorMsg ||
!CrInstallIntoCurrentThread || !CrUninstallFromCurrentThread);
#else
return false;
return false;
#endif
}
void CrashReporter::initThread()
{
#if defined(TARGET_WIN)
if (isLoaded())
CrInstallIntoCurrentThread(0);
if (isLoaded())
CrInstallIntoCurrentThread(0);
#endif
}
void CrashReporter::freeThread()
{
#if defined(TARGET_WIN)
if (isLoaded())
CrUninstallFromCurrentThread();
if (isLoaded())
CrUninstallFromCurrentThread();
#endif
}
CrashReporterThreadPoint::CrashReporterThreadPoint()
{
CrashReporter::initThread();
CrashReporter::initThread();
}
CrashReporterThreadPoint::~CrashReporterThreadPoint()
{
CrashReporter::freeThread();
CrashReporter::freeThread();
}
CrashReporterGuard::CrashReporterGuard()
{
CrashReporter::init("generic");
CrashReporter::init("generic");
}
CrashReporterGuard::~CrashReporterGuard()
{
CrashReporter::free();
CrashReporter::free();
}
#else
CrashReporterThreadPoint::CrashReporterThreadPoint() {}
CrashReporterThreadPoint::CrashReporterThreadPoint()
{
}
CrashReporterThreadPoint::~CrashReporterThreadPoint() {}
CrashReporterThreadPoint::~CrashReporterThreadPoint()
{
}
CrashReporterGuard::CrashReporterGuard() {}
CrashReporterGuard::CrashReporterGuard()
{
}
CrashReporterGuard::~CrashReporterGuard() {}
CrashReporterGuard::~CrashReporterGuard()
{
}
#endif
src/engine/helper/HL_CrashRpt.h
+19 -20
View File
@@ -4,8 +4,8 @@
#include <string>
#if defined(TARGET_WIN)
#include <WinSock2.h>
#include <Windows.h>
# include <WinSock2.h>
# include <Windows.h>
#endif
// Helper class to translate SEH exceptions to C++ - sometimes it is needed
@@ -14,36 +14,35 @@
class SE_Exception
{
private:
unsigned int nSE;
unsigned int nSE;
public:
SE_Exception() {}
SE_Exception(unsigned int n) : nSE(n) {}
~SE_Exception() {}
unsigned int getSeNumber() { return nSE; }
SE_Exception() {}
SE_Exception(unsigned int n) : nSE(n) {}
~SE_Exception() {}
unsigned int getSeNumber() { return nSE; }
};
extern void SEHToCpp(unsigned int, EXCEPTION_POINTERS*);
// Although better way is to have _set_se_translator set - in our case we do not call it.
// The cause is usage of CrashRpt libraries - it gives better control on exception reporting.
#define SET_SEH_TO_CPP
# define SET_SEH_TO_CPP
//_set_se_translator(&SEHToCpp)
#else
#define SET_SEH_TO_CPP
# define SET_SEH_TO_CPP
#endif
class CrashReporter
{
public:
static void init(const std::string& appname, const std::string& version = "", const std::string& url = "");
static void free();
static void initThread();
static void freeThread();
static bool isLoaded();
static void init(const std::string& appname, const std::string& version = "", const std::string& url = "");
static void free();
static void initThread();
static void freeThread();
static bool isLoaded();
#ifdef TARGET_WIN
static BOOL WINAPI Callback(LPVOID /*lpvState*/);
static BOOL WINAPI Callback(LPVOID /*lpvState*/);
#endif
};
@@ -51,15 +50,15 @@ public:
class CrashReporterThreadPoint
{
public:
CrashReporterThreadPoint();
~CrashReporterThreadPoint();
CrashReporterThreadPoint();
~CrashReporterThreadPoint();
};
class CrashReporterGuard
{
public:
CrashReporterGuard();
~CrashReporterGuard();
CrashReporterGuard();
~CrashReporterGuard();
};
#endif
src/engine/helper/HL_CsvReader.cpp
+15 -12
View File
@@ -2,25 +2,28 @@
#include "HL_String.h"
// --------- CsvFile ----------------
CsvReader::CsvReader(std::istream& stream) : mInputStream(stream) {}
CsvReader::CsvReader(std::istream& stream)
:mInputStream(stream)
{}
CsvReader::~CsvReader() {}
CsvReader::~CsvReader()
{}
std::istream& CsvReader::stream() const
{
return mInputStream;
return mInputStream;
}
bool CsvReader::readLine(std::vector<std::string>& cells)
{
cells.clear();
std::string line;
if (!std::getline(mInputStream, line))
return false;
strx::trim(line);
if (line.empty())
return false;
cells.clear();
std::string line;
if (!std::getline(mInputStream, line))
return false;
StringHelper::trim(line);
if (line.empty())
return false;
strx::split(line, cells, ",;");
return true;
StringHelper::split(line, cells, ",;");
return true;
}
src/engine/helper/HL_CsvReader.h
+6 -6
View File
@@ -8,16 +8,16 @@
class CsvReader
{
public:
CsvReader(std::istream& stream);
~CsvReader();
CsvReader(std::istream& stream);
~CsvReader();
void setStream(std::istream& input);
std::istream& stream() const;
void setStream(std::istream& input);
std::istream& stream() const;
bool readLine(std::vector<std::string>& cells);
bool readLine(std::vector<std::string>& cells);
protected:
std::istream& mInputStream;
std::istream& mInputStream;
};
#endif
src/engine/helper/HL_Exception.h
+56 -44
View File
@@ -10,64 +10,76 @@
#include <memory.h>
#include <stdio.h>
#include <string.h>
#include <cstdio>
enum
{
ERR_MEDIA_SOCKET_FAILED = 1, // Failed to create media socket
ERR_CANNOT_FIND_SESSION = 2, // Cannot find session
ERR_NO_CREDENTIALS = 3, // No credentials to configure instance
ERR_BAD_VARIANT_TYPE = 4, // Bad variant type conversion
ERR_RINSTANCE = 5,
ERR_SRTP = 6, // libsrtp error
ERR_WEBRTC = 7, // webrtc error
ERR_NOMEM = 8, // no more memory
ERR_WMME_FAILED = 9, // WMME error
ERR_QPC = 10, // QueryPerformanceCounter failed
ERR_BAD_PARAM = 11, // Bad parameter
ERR_NET_FAILED = 12, // Call to OS network subsystem failed
ERR_NOT_IMPLEMENTED = 13, // Not implemented in this build
ERR_MIXER_OVERFLOW = 14, // No more available channels in audio mixer
ERR_WAVFILE_FAILED = 15, // Error with .wav file
ERR_DSOUND = 16, // DSound error
ERR_COREAUDIO = 17, // CoreAudio error
ERR_CREATEWINDOW = 18, // CreateWindow failed
ERR_REGISTERNOTIFICATION = 19, // RegisterDeviceNotification failed
ERR_PCAP = 20, // Smth bad with libpcap
ERR_CACHE_FAILED = 21, // Failed to open cache directory
ERR_FILENOTOPEN = 22, // Cannot open the file
ERR_OPENSLES = 23 // OpenSL ES failed. Subcode has actual error code.
ERR_MEDIA_SOCKET_FAILED = 1, // Failed to create media socket
ERR_CANNOT_FIND_SESSION = 2, // Cannot find session
ERR_NO_CREDENTIALS = 3, // No credentials to configure instance
ERR_BAD_VARIANT_TYPE = 4, // Bad variant type conversion
ERR_RINSTANCE = 5,
ERR_SRTP = 6, // libsrtp error
ERR_WEBRTC = 7, // webrtc error
ERR_NOMEM = 8, // no more memory
ERR_WMME_FAILED = 9, // WMME error
ERR_QPC = 10, // QueryPerformanceCounter failed
ERR_BAD_PARAM = 11, // Bad parameter
ERR_NET_FAILED = 12, // Call to OS network subsystem failed
ERR_NOT_IMPLEMENTED = 13, // Not implemented in this build
ERR_MIXER_OVERFLOW = 14, // No more available channels in audio mixer
ERR_WAVFILE_FAILED = 15, // Error with .wav file
ERR_DSOUND = 16, // DSound error
ERR_COREAUDIO = 17, // CoreAudio error
ERR_CREATEWINDOW = 18, // CreateWindow failed
ERR_REGISTERNOTIFICATION = 19, // RegisterDeviceNotification failed
ERR_PCAP = 20, // Smth bad with libpcap
ERR_CACHE_FAILED = 21, // Failed to open cache directory
ERR_FILENOTOPEN = 22, // Cannot open the file
ERR_OPENSLES = 23 // OpenSL ES failed. Subcode has actual error code.
};
class Exception : public std::exception
class Exception: public std::exception
{
public:
Exception(int code, int subcode = 0) : mCode(code), mSubcode(subcode)
{
std::snprintf(mMessage, sizeof(mMessage), "%d-%d", code, subcode);
}
Exception(int code, int subcode = 0)
:mCode(code), mSubcode(subcode)
{
sprintf(mMessage, "%d-%d", code, subcode);
}
Exception(int code, const char* message)
{
if (message)
strncpy(mMessage, message, (sizeof mMessage) - 1);
}
Exception(int code, const char* message)
{
if (message)
strncpy(mMessage, message, (sizeof mMessage) - 1 );
}
Exception(const Exception& src) : mCode(src.mCode), mSubcode(src.mSubcode)
{
memcpy(mMessage, src.mMessage, sizeof mMessage);
}
Exception(const Exception& src)
:mCode(src.mCode), mSubcode(src.mSubcode)
{
memcpy(mMessage, src.mMessage, sizeof mMessage);
}
~Exception() {}
~Exception()
{ }
int code() const { return mCode; }
int code() const
{
return mCode;
}
int subcode() const { return mSubcode; }
int subcode() const
{
return mSubcode;
}
const char* what() const noexcept { return mMessage; }
const char* what() const noexcept
{
return mMessage;
}
protected:
int mCode = 0, mSubcode = 0;
char mMessage[256] = {0};
int mCode, mSubcode;
char mMessage[256];
};
#endif
src/engine/helper/HL_File.cpp
+22 -54
View File
@@ -1,10 +1,10 @@
#include "HL_File.h"
#include <fstream>
#if defined(TARGET_LINUX) || defined(TARGET_OSX) || defined(TARGET_ANDROID)
#include <unistd.h>
#include <sys/statvfs.h>
#include <memory.h>
#if defined(TARGET_LINUX) || defined(TARGET_OSX)
# include <unistd.h>
# include <sys/statvfs.h>
# include <memory.h>
#endif
bool FileHelper::exists(const std::string& s)
@@ -32,24 +32,23 @@ void FileHelper::remove(const char* s)
::remove(s);
}
// std::string FileHelper::gettempname()
// {
// #if defined(TARGET_LINUX) || defined(TARGET_ANDROID)
// char template_filename[L_tmpnam] = "rtphone_XXXXXXX.tmp";
// int code = mkstemp(template_filename);
std::string FileHelper::gettempname()
{
#if defined(TARGET_LINUX)
char template_filename[L_tmpnam] = "rtphone_XXXXXXX.tmp";
mkstemp(template_filename);
return template_filename;
#elif defined(TARGET_WIN)
char buffer[L_tmpnam];
tmpnam(buffer);
// return template_filename;
// #elif defined(TARGET_WIN)
// char buffer[L_tmpnam];
// tmpnam(buffer);
// return buffer;
// #elif defined(TARGET_OSX)
// char template_filename[L_tmpnam] = "rtphone_XXXXXXX.tmp";
// mktemp(template_filename);
// return template_filename;
// #endif
// }
return buffer;
#elif defined(TARGET_OSX)
char template_filename[L_tmpnam] = "rtphone_XXXXXXX.tmp";
mktemp(template_filename);
return template_filename;
#endif
}
bool FileHelper::isAbsolute(const std::string& s)
{
@@ -65,7 +64,7 @@ std::string FileHelper::getCurrentDir()
return std::string();
#endif
#if defined(TARGET_LINUX) || defined(TARGET_OSX) || defined(TARGET_ANDROID)
#if defined(TARGET_LINUX) || defined(TARGET_OSX)
char buf[512];
if (getcwd(buf, sizeof buf) != nullptr)
return buf;
@@ -102,8 +101,7 @@ size_t FileHelper::getFreespace(const std::string& path)
size_t r = static_cast<size_t>(-1);
#if defined(TARGET_LINUX)
struct statvfs stats;
memset(&stats, 0, sizeof stats);
struct statvfs stats; memset(&stats, 0, sizeof stats);
int retcode = statvfs(path.c_str(), &stats);
if (retcode == 0)
@@ -111,33 +109,3 @@ size_t FileHelper::getFreespace(const std::string& path)
#endif
return r;
}
std::string FileHelper::expandUserHome(const std::string& path)
{
if (path.empty() || path[0] != '~')
return path; // No expansion needed
const char* home_dir = nullptr;
#ifdef TARGET_WIN
home_dir = std::getenv("USERPROFILE");
if (!home_dir)
{
home_dir = std::getenv("HOMEDRIVE");
const char* homepath = std::getenv("HOMEPATH");
if (home_dir && homepath)
{
std::string fullpath(home_dir);
fullpath += homepath;
return fullpath + path.substr(1);
}
}
#else
home_dir = std::getenv("HOME");
#endif
if (!home_dir)
throw std::runtime_error("Unable to determine the home directory");
return std::string(home_dir) + path.substr(1);
}
src/engine/helper/HL_File.h
+7 -8
View File
@@ -6,14 +6,14 @@
class FileHelper
{
public:
static bool exists(const std::string& s);
static bool exists(const char* s);
static bool exists(const std::string& s);
static bool exists(const char* s);
static void remove(const std::string& s);
static void remove(const char* s);
static void remove(const std::string& s);
static void remove(const char* s);
// static std::string gettempname();
static bool isAbsolute(const std::string& s);
static std::string gettempname();
static bool isAbsolute(const std::string& s);
static std::string getCurrentDir();
@@ -22,8 +22,7 @@ public:
// Returns free space on volume for path
// Works for Linux only. For other systems (size_t)-1 is returned (for errors too)
static size_t getFreespace(const std::string& path);
static std::string expandUserHome(const std::string& path);
static size_t getFreespace(const std::string& path);
};
#endif
src/engine/helper/HL_HepSupport.cpp
+25 -60
View File
@@ -7,13 +7,13 @@ static const uint32_t HEPID2 = 0x021002;
static const uint32_t HEPID3 = 0x48455033;
bool Packet::parseV3(const ByteBuffer& packet)
bool Packet::parseV3(const ByteBuffer& packet)
{
if (packet.size() < 30)
return false;
BufferReader r(packet);
char signature[4];
char signature[4];
r.readBuffer(signature, 4);
if (signature[0] != 'H' || signature[1] != 'E' || signature[2] != 'P' || signature[3] != '3')
@@ -24,12 +24,12 @@ bool Packet::parseV3(const ByteBuffer& packet)
l -= 6;
InternetAddress sourceAddr4, destAddr4, sourceAddr6, destAddr6;
uint16_t sourcePort = 0, destPort = 0;
uint16_t sourcePort = 0, destPort = 0;
while (r.count() < packet.size())
{
mVendorId = (VendorId)r.readUShort();
ChunkType chunkType = (ChunkType)r.readUShort();
int chunkLength = r.readUShort();
int chunkLength = r.readUShort();
switch (chunkType)
{
@@ -102,16 +102,18 @@ bool Packet::parseV3(const ByteBuffer& packet)
if (!sourceAddr4.isEmpty())
mSourceAddress = sourceAddr4;
else if (!sourceAddr6.isEmpty())
mSourceAddress = sourceAddr6;
else
if (!sourceAddr6.isEmpty())
mSourceAddress = sourceAddr6;
if (!mSourceAddress.isEmpty())
mSourceAddress.setPort(sourcePort);
if (!destAddr4.isEmpty())
mDestinationAddress = destAddr4;
else if (!destAddr6.isEmpty())
mDestinationAddress = destAddr6;
else
if (!destAddr6.isEmpty())
mDestinationAddress = destAddr6;
if (!mDestinationAddress.isEmpty())
mDestinationAddress.setPort(destPort);
@@ -119,7 +121,7 @@ bool Packet::parseV3(const ByteBuffer& packet)
return true;
}
bool Packet::parseV2(const ByteBuffer& packet)
bool Packet::parseV2(const ByteBuffer &packet)
{
if (packet.size() < 31)
return false;
@@ -146,53 +148,16 @@ bool Packet::parseV2(const ByteBuffer& packet)
return true;
}
#define WRITE_CHUNK_UCHAR(T, V) \
{ \
w.writeUShort((uint16_t)mVendorId); \
w.writeUShort((uint16_t)T); \
w.writeUShort(1); \
w.writeUChar((uint8_t)V); \
}
#define WRITE_CHUNK_USHORT(T, V) \
{ \
w.writeUShort((uint16_t)mVendorId); \
w.writeUShort((uint16_t)T); \
w.writeUShort(2); \
w.writeUShort((uint16_t)V); \
}
#define WRITE_CHUNK_UINT(T, V) \
{ \
w.writeUShort((uint16_t)mVendorId); \
w.writeUShort((uint16_t)T); \
w.writeUShort(4); \
w.writeUInt((uint32_t)V); \
}
#define WRITE_CHUNK_IP4(T, V) \
{ \
w.writeUShort((uint16_t)mVendorId); \
w.writeUShort((uint16_t)T); \
w.writeUShort(4); \
w.writeIp(V); \
}
#define WRITE_CHUNK_IP6(T, V) \
{ \
w.writeUShort((uint16_t)mVendorId); \
w.writeUShort((uint16_t)T); \
w.writeUShort(8); \
w.writeIp(V); \
}
#define WRITE_CHUNK_BUFFER(T, V) \
{ \
w.writeUShort((uint16_t)mVendorId); \
w.writeUShort((uint16_t)T); \
w.writeUShort(8); \
w.writeBuffer(V.data(), V.size()); \
}
#define WRITE_CHUNK_UCHAR(T, V) {w.writeUShort((uint16_t)mVendorId); w.writeUShort((uint16_t)T); w.writeUShort(1); w.writeUChar((uint8_t)V);}
#define WRITE_CHUNK_USHORT(T, V) {w.writeUShort((uint16_t)mVendorId); w.writeUShort((uint16_t)T); w.writeUShort(2); w.writeUShort((uint16_t)V);}
#define WRITE_CHUNK_UINT(T, V) {w.writeUShort((uint16_t)mVendorId); w.writeUShort((uint16_t)T); w.writeUShort(4); w.writeUInt((uint32_t)V);}
#define WRITE_CHUNK_IP4(T, V) {w.writeUShort((uint16_t)mVendorId); w.writeUShort((uint16_t)T); w.writeUShort(4); w.writeIp(V);}
#define WRITE_CHUNK_IP6(T, V) {w.writeUShort((uint16_t)mVendorId); w.writeUShort((uint16_t)T); w.writeUShort(8); w.writeIp(V);}
#define WRITE_CHUNK_BUFFER(T, V) {w.writeUShort((uint16_t)mVendorId); w.writeUShort((uint16_t)T); w.writeUShort(8); w.writeBuffer(V.data(), V.size());}
ByteBuffer Packet::buildV3()
{
ByteBuffer r;
r.resize(mBody.size() + 512);
ByteBuffer r; r.resize(mBody.size() + 512);
BufferWriter w(r);
// Signature
@@ -209,8 +174,9 @@ ByteBuffer Packet::buildV3()
{
if (mSourceAddress.isV4())
WRITE_CHUNK_IP4(ChunkType::IP4SourceAddress, mSourceAddress)
else if (mSourceAddress.isV6())
WRITE_CHUNK_IP6(ChunkType::IP6SourceAddress, mSourceAddress);
else
if (mSourceAddress.isV6())
WRITE_CHUNK_IP6(ChunkType::IP6SourceAddress, mSourceAddress);
WRITE_CHUNK_USHORT(ChunkType::SourcePort, mSourceAddress.port());
}
@@ -220,8 +186,9 @@ ByteBuffer Packet::buildV3()
{
if (mDestinationAddress.isV4())
WRITE_CHUNK_IP4(ChunkType::IP4DestinationAddress, mDestinationAddress)
else if (mDestinationAddress.isV6())
WRITE_CHUNK_IP6(ChunkType::IP6DestinationAddress, mDestinationAddress);
else
if (mDestinationAddress.isV6())
WRITE_CHUNK_IP6(ChunkType::IP6DestinationAddress, mDestinationAddress);
WRITE_CHUNK_USHORT(ChunkType::DestinationPort, mDestinationAddress.port());
}
@@ -249,9 +216,7 @@ ByteBuffer Packet::buildV3()
r.resize(w.offset());
w.rewind();
w.skip(4);
w.writeUShort((uint16_t)r.size());
w.rewind(); w.skip(4); w.writeUShort((uint16_t)r.size());
return r;
}
src/engine/helper/HL_HepSupport.h
+31 -27
View File
@@ -6,8 +6,8 @@
namespace HEP
{
enum class ChunkType
{
enum class ChunkType
{
None = 0,
IPProtocolFamily,
IPProtocolID,
@@ -19,17 +19,17 @@ enum class ChunkType
DestinationPort,
Timestamp,
TimestampMicro,
ProtocolType, // Maps to Protocol Types below
ProtocolType, // Maps to Protocol Types below
CaptureAgentID,
KeepAliveTimer,
AuthenticationKey,
PacketPayload,
CompressedPayload,
InternalC
};
};
enum class VendorId
{
enum class VendorId
{
None,
FreeSwitch,
Kamailio,
@@ -37,10 +37,10 @@ enum class VendorId
Asterisk,
Homer,
SipXecs
};
};
enum class ProtocolId
{
enum class ProtocolId
{
Reserved = 0,
SIP,
XMPP,
@@ -54,28 +54,32 @@ enum class ProtocolId
IAX,
H322,
H321
};
};
struct Packet
{
bool parseV3(const ByteBuffer& packet);
bool parseV2(const ByteBuffer& packet);
ByteBuffer buildV3();
struct Packet
{
bool parseV3(const ByteBuffer& packet);
bool parseV2(const ByteBuffer& packet);
ByteBuffer buildV3();
uint8_t mIpProtocolFamily, mIpProtocolId;
uint8_t
mIpProtocolFamily,
mIpProtocolId;
InternetAddress mSourceAddress, mDestinationAddress;
InternetAddress
mSourceAddress,
mDestinationAddress;
timeval mTimestamp;
ProtocolId mProtocolType;
uint16_t mCaptureAgentId;
uint16_t mKeepAliveTimer;
ByteBuffer mAuthenticateKey;
ByteBuffer mBody;
VendorId mVendorId;
uint32_t mBodyOffset = 0;
};
timeval mTimestamp;
ProtocolId mProtocolType;
uint16_t mCaptureAgentId;
uint16_t mKeepAliveTimer;
ByteBuffer mAuthenticateKey;
ByteBuffer mBody;
VendorId mVendorId;
uint32_t mBodyOffset = 0;
};
} // namespace HEP
}
#endif
src/engine/helper/HL_IuUP.cpp
+1137 -970
View File
File diff suppressed because it is too large Load Diff
src/engine/helper/HL_IuUP.h
+24 -23
View File
@@ -6,33 +6,34 @@
class IuUP
{
public:
enum class PduType
{
DataWithCrc = 0,
DataNoCrc = 1,
ControlProc = 14
};
enum class PduType
{
DataWithCrc = 0,
DataNoCrc = 1,
ControlProc = 14
};
struct Frame
{
PduType mPduType;
uint8_t mFrameNumber;
uint8_t mFqc;
uint8_t mRfci;
uint8_t mHeaderCrc;
bool mHeaderCrcOk;
uint16_t mPayloadCrc;
bool mPayloadCrcOk;
const uint8_t* mPayload;
uint16_t mPayloadSize;
};
struct Frame
{
PduType mPduType;
uint8_t mFrameNumber;
uint8_t mFqc;
uint8_t mRfci;
uint8_t mHeaderCrc;
bool mHeaderCrcOk;
uint16_t mPayloadCrc;
bool mPayloadCrcOk;
const uint8_t* mPayload;
uint16_t mPayloadSize;
};
/* Default value is false */
static bool TwoBytePseudoheader;
/* Default value is false */
static bool TwoBytePseudoheader;
static bool parse(const uint8_t* packet, int size, Frame& result);
static bool parse2(const uint8_t* packet, int size, Frame& result);
static bool parse(const uint8_t* packet, int size, Frame& result);
static bool parse2(const uint8_t* packet, int size, Frame& result);
};
#endif // HL_IUUP_H
src/engine/helper/HL_Log.cpp
+1
View File
@@ -2,3 +2,4 @@
* 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/. */
src/engine/helper/HL_Log.h
+4 -4
View File
@@ -11,13 +11,13 @@
using ice::GLogger;
using ice::LogLock;
using ice::LL_CRITICAL;
using ice::LL_DEBUG;
using ice::LL_ERROR;
using ice::LL_INFO;
using ice::LL_MEDIA;
using ice::LL_DEBUG;
using ice::LL_INFO;
using ice::LL_CRITICAL;
using ice::LL_NONE;
using ice::LL_SPECIAL;
using ice::LL_ERROR;
using ice::LogLevelHelper;
#endif
src/engine/helper/HL_NetworkFrame.cpp
+84 -97
View File
@@ -3,44 +3,23 @@
#include "HL_NetworkFrame.h"
#include "HL_InternetAddress.h"
#define ETHERTYPE_MPLS_UC (0x8847)
#define ETHERTYPE_MPLS_MC (0x8848)
#define ETHERTYPE_IPV6 (0x86dd)
#define ETHERTYPE_IP (0x0800)
#define ETHERTYPE_MPLS_UC (0x8847)
#define ETHERTYPE_MPLS_MC (0x8848)
#define ETHERTYPE_IPV6 (0x86dd)
#define ETHERTYPE_IP (0x0800)
#define MPLS_STACK_MASK (0x00000100)
#define MPLS_STACK_SHIFT (8)
NetworkFrame::Payload NetworkFrame::GetUdpPayloadForRaw(const Packet& data)
NetworkFrame::PacketData NetworkFrame::GetUdpPayloadForEthernet(NetworkFrame::PacketData& packet, InternetAddress& source, InternetAddress& destination)
{
const Ip4Header* ip4 = reinterpret_cast<const Ip4Header*>(data.mData);
PacketData result(packet);
if (ip4->mProtocol != IPPROTO_UDP && ip4->mProtocol != 0)
return Payload();
switch (ip4->version())
{
case 4:
return GetUdpPayloadForIp4(data);
case 6:
return GetUdpPayloadForIp6(data);
default:
return Payload();
}
}
NetworkFrame::Payload NetworkFrame::GetUdpPayloadForEthernet(const Packet& data)
{
Packet result(data);
const EthernetHeader* ethernet = reinterpret_cast<const EthernetHeader*>(data.mData);
const EthernetHeader* ethernet = reinterpret_cast<const EthernetHeader*>(packet.mData);
// Skip ethernet header
result.mData += sizeof(EthernetHeader);
result.mLength -= sizeof(EthernetHeader);
packet.mData += sizeof(EthernetHeader);
packet.mLength -= sizeof(EthernetHeader);
// See if there is Vlan header
uint16_t proto = 0;
@@ -49,11 +28,12 @@ NetworkFrame::Payload NetworkFrame::GetUdpPayloadForEthernet(const Packet& data)
// Skip 1 or more VLAN headers
do
{
const VlanHeader* vlan = reinterpret_cast<const VlanHeader*>(result.mData);
result.mData += sizeof(VlanHeader);
result.mLength -= sizeof(VlanHeader);
const VlanHeader* vlan = reinterpret_cast<const VlanHeader*>(packet.mData);
packet.mData += sizeof(VlanHeader);
packet.mLength -= sizeof(VlanHeader);
proto = ntohs(vlan->mData);
} while (proto == 0x8100);
}
while (proto == 0x8100);
}
// Skip MPLS headers
@@ -62,11 +42,11 @@ NetworkFrame::Payload NetworkFrame::GetUdpPayloadForEthernet(const Packet& data)
case ETHERTYPE_MPLS_UC:
case ETHERTYPE_MPLS_MC:
// Parse MPLS here until marker "bottom of mpls stack"
for (bool bottomOfStack = false; !bottomOfStack;
bottomOfStack = ((ntohl(*(uint32_t*)(result.mData - 4)) & MPLS_STACK_MASK) >> MPLS_STACK_SHIFT) != 0)
for(bool bottomOfStack = false; !bottomOfStack;
bottomOfStack = ((ntohl(*(uint32_t*)(packet.mData - 4)) & MPLS_STACK_MASK) >> MPLS_STACK_SHIFT) != 0)
{
result.mData += 4;
result.mLength -= 4;
packet.mData += 4;
packet.mLength -=4;
}
break;
@@ -79,86 +59,86 @@ NetworkFrame::Payload NetworkFrame::GetUdpPayloadForEthernet(const Packet& data)
break;
}
const Ip4Header* ip4 = reinterpret_cast<const Ip4Header*>(result.mData);
const Ip4Header* ip4 = reinterpret_cast<const Ip4Header*>(packet.mData);
if (ip4->mProtocol != IPPROTO_UDP && ip4->mProtocol != 0)
return Payload();
return PacketData();
switch (ip4->version())
{
case 4:
return GetUdpPayloadForIp4(result);
return GetUdpPayloadForIp4(packet, source, destination);
case 6:
return GetUdpPayloadForIp6(result);
return GetUdpPayloadForIp6(packet, source, destination);
default:
return Payload();
return PacketData();
}
}
NetworkFrame::Payload NetworkFrame::GetUdpPayloadForSLL(const Packet& data)
NetworkFrame::PacketData NetworkFrame::GetUdpPayloadForSLL(NetworkFrame::PacketData& packet, InternetAddress& source, InternetAddress& destination)
{
Packet result(data);
PacketData result(packet);
if (result.mLength < 16)
return Payload();
if (packet.mLength < 16)
return PacketData();
const LinuxSllHeader* sll = reinterpret_cast<const LinuxSllHeader*>(result.mData);
const LinuxSllHeader* sll = reinterpret_cast<const LinuxSllHeader*>(packet.mData);
result.mData += sizeof(LinuxSllHeader);
result.mLength -= sizeof(LinuxSllHeader);
packet.mData += sizeof(LinuxSllHeader);
packet.mLength -= sizeof(LinuxSllHeader);
switch (ntohs(sll->mProtocolType))
{
case 0x0800:
return GetUdpPayloadForIp4(result);
return GetUdpPayloadForIp4(packet, source, destination);
case 0x86DD:
return GetUdpPayloadForIp6(result);
return GetUdpPayloadForIp6(packet, source, destination);
default:
return Payload();
return PacketData();
}
}
NetworkFrame::Payload NetworkFrame::GetUdpPayloadForLoopback(const Packet& data)
NetworkFrame::PacketData NetworkFrame::GetUdpPayloadForLoopback(NetworkFrame::PacketData& packet, InternetAddress& source, InternetAddress& destination)
{
Packet result(data);
PacketData result(packet);
if (result.mLength < 16)
return Payload();
if (packet.mLength < 16)
return PacketData();
struct LoopbackHeader
{
uint32_t mProtocolType;
};
const LoopbackHeader* lh = reinterpret_cast<const LoopbackHeader*>(result.mData);
const LoopbackHeader* lh = reinterpret_cast<const LoopbackHeader*>(packet.mData);
result.mData += sizeof(LoopbackHeader);
result.mLength -= sizeof(LoopbackHeader);
packet.mData += sizeof(LoopbackHeader);
packet.mLength -= sizeof(LoopbackHeader);
switch (lh->mProtocolType)
{
case AF_INET:
return GetUdpPayloadForIp4(result);
return GetUdpPayloadForIp4(packet, source, destination);
case AF_INET6:
return GetUdpPayloadForIp6(result);
return GetUdpPayloadForIp6(packet, source, destination);
default:
return Payload();
return PacketData();
}
}
NetworkFrame::Payload NetworkFrame::GetUdpPayloadForIp4(const Packet& data)
NetworkFrame::PacketData NetworkFrame::GetUdpPayloadForIp4(NetworkFrame::PacketData& packet, InternetAddress& source, InternetAddress& destination)
{
Packet result(data);
const Ip4Header* ip4 = reinterpret_cast<const Ip4Header*>(data.mData);
PacketData result(packet);
const Ip4Header* ip4 = reinterpret_cast<const Ip4Header*>(packet.mData);
if (ip4->mProtocol != IPPROTO_UDP && ip4->mProtocol != 0)
return Payload();
return PacketData(nullptr, 0);
result.mData += ip4->headerLength();
result.mLength -= ip4->headerLength();
@@ -172,62 +152,69 @@ NetworkFrame::Payload NetworkFrame::GetUdpPayloadForIp4(const Packet& data)
if (length - sizeof(UdpHeader) < (size_t)result.mLength)
result.mLength = length - sizeof(UdpHeader);
InternetAddress addr_source;
addr_source.setIp(ip4->mSource);
addr_source.setPort(ntohs(udp->mSourcePort));
source.setIp(ip4->mSource);
source.setPort(ntohs(udp->mSourcePort));
InternetAddress addr_dest;
addr_dest.setIp(ip4->mDestination);
addr_dest.setPort(ntohs(udp->mDestinationPort));
destination.setIp(ip4->mDestination);
destination.setPort(ntohs(udp->mDestinationPort));
return {.data = result, .source = addr_source, .dest = addr_dest};
return result;
}
struct Ip6Header
{
#if __BYTE_ORDER == __LITTLE_ENDIAN
uint8_t traffic_class_hi : 4, version : 4;
uint8_t flow_label_hi : 4, traffic_class_lo : 4;
uint16_t flow_label_lo;
uint8_t traffic_class_hi:4,
version:4;
uint8_t flow_label_hi:4,
traffic_class_lo:4;
uint16_t flow_label_lo;
#elif __BYTE_ORDER == __BIG_ENDIAN
uint8_t version : 4, traffic_class_hi : 4;
uint8_t traffic_class_lo : 4, flow_label_hi : 4;
uint16_t flow_label_lo;
uint8_t version:4,
traffic_class_hi:4;
uint8_t traffic_class_lo:4,
flow_label_hi:4;
uint16_t flow_label_lo;
#else
#error "Please fix endianness defines"
# error "Please fix endianness defines"
#endif
uint16_t payload_len;
uint8_t next_header;
uint8_t hop_limit;
uint16_t payload_len;
uint8_t next_header;
uint8_t hop_limit;
struct in6_addr src_ip;
struct in6_addr dst_ip;
struct in6_addr src_ip;
struct in6_addr dst_ip;
};
NetworkFrame::Payload NetworkFrame::GetUdpPayloadForIp6(const Packet& data)
NetworkFrame::PacketData NetworkFrame::GetUdpPayloadForIp6(NetworkFrame::PacketData& packet, InternetAddress& source, InternetAddress& destination)
{
Packet result(data);
const Ip6Header* ip6 = reinterpret_cast<const Ip6Header*>(result.mData);
PacketData result(packet);
const Ip6Header* ip6 = reinterpret_cast<const Ip6Header*>(packet.mData);
/*if (ip6->mProtocol != IPPROTO_UDP && ip4->mProtocol != 0)
return PacketData(nullptr, 0);
*/
result.mData += sizeof(Ip6Header);
result.mLength -= sizeof(Ip6Header);
// std::cout << sizeof(Ip6Header) << std::endl;
//std::cout << sizeof(Ip6Header) << std::endl;
const UdpHeader* udp = reinterpret_cast<const UdpHeader*>(result.mData);
result.mData += sizeof(UdpHeader);
result.mLength -= sizeof(UdpHeader);
InternetAddress addr_source;
addr_source.setIp(ip6->src_ip);
addr_source.setPort(ntohs(udp->mSourcePort));
/*
if (result.mLength != ntohs(udp->mDatagramLength))
return PacketData(nullptr, 0);
*/
InternetAddress addr_dest;
addr_dest.setIp(ip6->dst_ip);
addr_dest.setPort(ntohs(udp->mDestinationPort));
source.setIp(ip6->src_ip);
source.setPort(ntohs(udp->mSourcePort));
//std::cout << source.toStdString() << " - ";
return {.data = result, .source = addr_source, .dest = addr_dest};
destination.setIp(ip6->dst_ip);
destination.setPort(ntohs(udp->mDestinationPort));
//std::cout << destination.toStdString() << std::endl;
return result;
}
src/engine/helper/HL_NetworkFrame.h
+58 -56
View File
@@ -7,44 +7,38 @@
class NetworkFrame
{
public:
struct Packet
struct PacketData
{
const uint8_t* mData;
size_t mLength;
size_t mLength;
Packet(const uint8_t* data, size_t length) : mData(data), mLength(length) {}
PacketData(const uint8_t* data, size_t length)
:mData(data), mLength(length)
{}
Packet() : mData(nullptr), mLength(0) {}
bool is_empty() const { return mData == nullptr || mLength == 0; }
PacketData()
:mData(nullptr), mLength(0)
{}
};
struct Payload
{
Packet data;
InternetAddress source;
InternetAddress dest;
};
static Payload GetUdpPayloadForEthernet(const Packet& data);
static Payload GetUdpPayloadForIp4(const Packet& data);
static Payload GetUdpPayloadForIp6(const Packet& data);
static Payload GetUdpPayloadForSLL(const Packet& data);
static Payload GetUdpPayloadForLoopback(const Packet& data);
static Payload GetUdpPayloadForRaw(const Packet& data);
static PacketData GetUdpPayloadForEthernet(PacketData& packet, InternetAddress& source, InternetAddress& destination);
static PacketData GetUdpPayloadForIp4(PacketData& packet, InternetAddress& source, InternetAddress& destination);
static PacketData GetUdpPayloadForIp6(PacketData& packet, InternetAddress& source, InternetAddress& destination);
static PacketData GetUdpPayloadForSLL(PacketData& packet, InternetAddress& source, InternetAddress& destination);
static PacketData GetUdpPayloadForLoopback(PacketData& packet, InternetAddress& source, InternetAddress& destination);
struct EthernetHeader
{
/* Ethernet addresses are 6 bytes */
static const int AddressLength = 6;
uint8_t mEtherDHost[AddressLength]; /* Destination host address */
uint8_t mEtherSHost[AddressLength]; /* Source host address */
uint16_t mEtherType; /* IP? ARP? RARP? etc */
uint8_t mEtherDHost[AddressLength]; /* Destination host address */
uint8_t mEtherSHost[AddressLength]; /* Source host address */
uint16_t mEtherType; /* IP? ARP? RARP? etc */
};
#if defined(TARGET_WIN)
struct /*__attribute__((packed))*/ LinuxSllHeader
#else
#else
struct __attribute__((packed)) LinuxSllHeader
#endif
{
@@ -63,48 +57,55 @@ public:
struct Ip4Header
{
uint8_t mVhl; /* version << 4 | header length >> 2 */
uint8_t mTos; /* type of service */
uint16_t mLen; /* total length */
uint16_t mId; /* identification */
uint16_t mOffset; /* fragment offset field */
#define IP_RF 0x8000 /* reserved fragment flag */
#define IP_DF 0x4000 /* dont fragment flag */
#define IP_MF 0x2000 /* more fragments flag */
#define IP_OFFMASK 0x1fff /* mask for fragmenting bits */
uint8_t mTtl; /* time to live */
uint8_t mProtocol; /* protocol */
uint16_t mChecksum; /* checksum */
in_addr mSource, mDestination; /* source and dest address */
uint8_t mVhl; /* version << 4 | header length >> 2 */
uint8_t mTos; /* type of service */
uint16_t mLen; /* total length */
uint16_t mId; /* identification */
uint16_t mOffset; /* fragment offset field */
#define IP_RF 0x8000 /* reserved fragment flag */
#define IP_DF 0x4000 /* dont fragment flag */
#define IP_MF 0x2000 /* more fragments flag */
#define IP_OFFMASK 0x1fff /* mask for fragmenting bits */
uint8_t mTtl; /* time to live */
uint8_t mProtocol; /* protocol */
uint16_t mChecksum; /* checksum */
in_addr mSource,
mDestination; /* source and dest address */
int headerLength() const { return (mVhl & 0x0f) * 4; }
int headerLength() const
{
return (mVhl & 0x0f) * 4;
}
int version() const { return mVhl >> 4; }
int version() const
{
return mVhl >> 4;
}
const in_addr& source4() const { return mSource; }
const in_addr& dest4() const { return mDestination; }
const in_addr& source4() const { return mSource; }
const in_addr& dest4() const { return mDestination; }
const in6_addr& source6() const { return (const in6_addr&)mSource; }
const in6_addr& dest6() const { return (const in6_addr&)mDestination; }
const in6_addr& dest6() const { return (const in6_addr&)mDestination; }
};
struct UdpHeader
{
uint16_t mSourcePort; /* source port */
uint16_t mDestinationPort;
uint16_t mDatagramLength; /* datagram length */
uint16_t mDatagramChecksum; /* datagram checksum */
uint16_t mSourcePort; /* source port */
uint16_t mDestinationPort;
uint16_t mDatagramLength; /* datagram length */
uint16_t mDatagramChecksum; /* datagram checksum */
};
struct TcpHeader
{
uint16_t mSourcePort; /* source port */
uint16_t mDestinationPort; /* destination port */
uint32_t mSeqNo; /* sequence number */
uint32_t mAckNo; /* acknowledgement number */
uint32_t mDataOffset; /* data offset, rsvd */
#define TH_OFF(th) (((th)->th_offx2 & 0xf0) >> 4)
uint8_t mFlags;
uint16_t mSourcePort; /* source port */
uint16_t mDestinationPort; /* destination port */
uint32_t mSeqNo; /* sequence number */
uint32_t mAckNo; /* acknowledgement number */
uint32_t mDataOffset; /* data offset, rsvd */
#define TH_OFF(th) (((th)->th_offx2 & 0xf0) >> 4)
uint8_t mFlags;
#define TH_FIN 0x01
#define TH_SYN 0x02
#define TH_RST 0x04
@@ -113,10 +114,11 @@ public:
#define TH_URG 0x20
#define TH_ECE 0x40
#define TH_CWR 0x80
#define TH_FLAGS (TH_FIN | TH_SYN | TH_RST | TH_ACK | TH_URG | TH_ECE | TH_CWR)
uint16_t mWindow; /* window */
uint16_t mChecksum; /* checksum */
uint16_t mUrgentPointer; /* urgent pointer */
#define TH_FLAGS (TH_FIN|TH_SYN|TH_RST|TH_ACK|TH_URG|TH_ECE|TH_CWR)
uint16_t mWindow; /* window */
uint16_t mChecksum; /* checksum */
uint16_t mUrgentPointer; /* urgent pointer */
};
};
#endif
src/engine/helper/HL_NetworkSocket.cpp
+85 -109
View File
@@ -1,206 +1,182 @@
/* Copyright(C) 2007-2026 VoIP objects (voipobjects.com)
/* Copyright(C) 2007-2017 VoIP objects (voipobjects.com)
* 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/. */
#if defined(TARGET_LINUX) || defined(TARGET_ANDROID)
#include <asm/ioctls.h>
# include <asm/ioctls.h>
#endif
#include "../engine_config.h"
#include "../config.h"
#include "HL_NetworkSocket.h"
#include "HL_Log.h"
#if defined(TARGET_OSX) || defined(TARGET_LINUX)
#include <fcntl.h>
# include <fcntl.h>
#endif
#if !defined(TARGET_WIN)
#include <unistd.h>
# include <unistd.h>
#endif
#include <assert.h>
#define LOG_SUBSYSTEM "network"
DatagramSocket::DatagramSocket()
:mFamily(AF_INET), mHandle(INVALID_SOCKET), mLocalPort(0)
{
DatagramSocket::DatagramSocket() : mFamily(AF_INET), mHandle(INVALID_SOCKET), mLocalPort(0) {}
}
DatagramSocket::~DatagramSocket()
{
internalClose();
closeSocket();
}
void DatagramSocket::open(int family)
{
if (mHandle != INVALID_SOCKET || mFamily != family)
closeSocket();
if (mHandle != INVALID_SOCKET || mFamily != family)
closeSocket();
assert(family == AF_INET || family == AF_INET6);
mFamily = family;
mHandle = ::socket(mFamily, SOCK_DGRAM, IPPROTO_UDP);
if (mHandle != INVALID_SOCKET)
assert(family == AF_INET || family == AF_INET6);
mFamily = family;
mHandle = ::socket(mFamily, SOCK_DGRAM, IPPROTO_UDP);
if (mHandle != INVALID_SOCKET)
{
sockaddr_in addr4; sockaddr_in6 addr6;
memset(&addr4, 0, sizeof(addr4)); memset(&addr6, 0, sizeof(addr6));
socklen_t l = mFamily == AF_INET ? sizeof(addr4) : sizeof(addr6);
int retcode = getsockname(mHandle, (mFamily == AF_INET ? (sockaddr*)&addr4 : (sockaddr*)&addr6), &l);
if (!retcode)
{
sockaddr_in addr4;
sockaddr_in6 addr6;
memset(&addr4, 0, sizeof(addr4));
memset(&addr6, 0, sizeof(addr6));
socklen_t l = mFamily == AF_INET ? sizeof(addr4) : sizeof(addr6);
int retcode = getsockname(mHandle, (mFamily == AF_INET ? (sockaddr*)&addr4 : (sockaddr*)&addr6), &l);
if (!retcode)
{
mLocalPort = ntohs(mFamily == AF_INET ? addr4.sin_port : addr6.sin6_port);
}
mLocalPort = ntohs(mFamily == AF_INET ? addr4.sin_port : addr6.sin6_port);
}
}
}
int DatagramSocket::localport()
{
return mLocalPort;
return mLocalPort;
}
void DatagramSocket::sendDatagram(InternetAddress& dest, const void* packetData, unsigned int packetSize)
void DatagramSocket::sendDatagram(InternetAddress &dest, const void *packetData, unsigned int packetSize)
{
if (mHandle == INVALID_SOCKET)
return;
if (mHandle == INVALID_SOCKET)
return;
/*int sent = */ ::sendto(mHandle, (const char*)packetData, packetSize, 0, dest.genericsockaddr(),
dest.sockaddrLen());
int sent = ::sendto(mHandle, (const char*)packetData, packetSize, 0, dest.genericsockaddr(), dest.sockaddrLen());
}
unsigned DatagramSocket::recvDatagram(InternetAddress& src, void* packetBuffer, unsigned packetCapacity)
unsigned DatagramSocket::recvDatagram(InternetAddress &src, void *packetBuffer, unsigned packetCapacity)
{
if (mHandle == INVALID_SOCKET)
return 0;
sockaddr* addr = nullptr;
socklen_t addrLen = 0;
sockaddr_in addr_4 = {AF_INET, 0, {0}, {0}};
sockaddr_in6 addr_6 = {AF_INET6, 0, 0, {0}, 0};
switch (mFamily)
{
case AF_INET:
addr = (sockaddr*)&addr_4;
addrLen = sizeof(addr_4);
break;
case AF_INET6:
addr = (sockaddr*)&addr_6;
addrLen = sizeof(addr_6);
break;
default:
assert(0);
}
if (!addr || !addrLen)
return 0;
int received = ::recvfrom(mHandle, (char*)packetBuffer, packetCapacity, 0, addr, &addrLen);
if (received > 0)
{
src = InternetAddress((sockaddr&)*addr, addrLen);
return received;
}
if (mHandle == INVALID_SOCKET)
return 0;
}
void DatagramSocket::internalClose()
{
if (mHandle != INVALID_SOCKET)
{
sockaddr_in sourceaddr;
#ifdef WIN32
::closesocket(mHandle);
int addrlen = sizeof(sourceaddr);
#else
close(mHandle);
socklen_t addrlen = sizeof(sourceaddr);
#endif
mHandle = INVALID_SOCKET;
}
int received = ::recvfrom(mHandle, (char*)packetBuffer, packetCapacity, 0, (sockaddr*)&sourceaddr, &addrlen);
if (received > 0)
{
src = InternetAddress((sockaddr&)sourceaddr, addrlen);
return received;
}
else
return 0;
}
void DatagramSocket::closeSocket()
{
internalClose();
if (mHandle != INVALID_SOCKET)
{
#ifdef WIN32
::closesocket(mHandle);
#else
close(mHandle);
#endif
mHandle = INVALID_SOCKET;
}
}
bool DatagramSocket::isValid() const
{
return mHandle != INVALID_SOCKET;
return mHandle != INVALID_SOCKET;
}
int DatagramSocket::family() const
{
return mFamily;
return mFamily;
}
bool DatagramSocket::setBlocking(bool blocking)
{
#if defined(TARGET_WIN)
unsigned long mode = blocking ? 0 : 1;
return (ioctlsocket(mHandle, FIONBIO, &mode) == 0) ? true : false;
unsigned long mode = blocking ? 0 : 1;
return (ioctlsocket(mHandle, FIONBIO, &mode) == 0) ? true : false;
#endif
#if defined(TARGET_OSX) || defined(TARGET_LINUX)
int flags = fcntl(mHandle, F_GETFL, 0);
if (flags < 0)
return false;
flags = blocking ? (flags & ~O_NONBLOCK) : (flags | O_NONBLOCK);
return (fcntl(mHandle, F_SETFL, flags) == 0) ? true : false;
int flags = fcntl(mHandle, F_GETFL, 0);
if (flags < 0)
return false;
flags = blocking ? (flags&~O_NONBLOCK) : (flags|O_NONBLOCK);
return (fcntl(mHandle, F_SETFL, flags) == 0) ? true : false;
#endif
#if defined(TARGET_ANDROID)
unsigned long mode = blocking ? 0 : 1;
return (ioctl(mHandle, FIONBIO, &mode) == 0) ? true : false;
unsigned long mode = blocking ? 0 : 1;
return (ioctl(mHandle, FIONBIO, &mode) == 0) ? true : false;
#endif
return false;
return false;
}
SOCKET DatagramSocket::socket() const
{
return mHandle;
return mHandle;
}
DatagramAgreggator::DatagramAgreggator()
{
FD_ZERO(&mReadSet);
mMaxHandle = 0;
FD_ZERO(&mReadSet);
mMaxHandle = 0;
}
DatagramAgreggator::~DatagramAgreggator() {}
DatagramAgreggator::~DatagramAgreggator()
{
}
void DatagramAgreggator::addSocket(PDatagramSocket socket)
{
if (socket->mHandle == INVALID_SOCKET)
return;
if (socket->mHandle == INVALID_SOCKET)
return;
if (mSocketVector.size() >= 62)
{
ICELogError(<< "fd_set overflow; too much sockets");
return;
}
FD_SET(socket->mHandle, &mReadSet);
if (socket->mHandle > mMaxHandle)
mMaxHandle = socket->mHandle;
FD_SET(socket->mHandle, &mReadSet);
if (socket->mHandle > mMaxHandle)
mMaxHandle = socket->mHandle;
mSocketVector.push_back(socket);
mSocketVector.push_back(socket);
}
unsigned DatagramAgreggator::count()
{
return mSocketVector.size();
return mSocketVector.size();
}
bool DatagramAgreggator::hasDataAtIndex(unsigned index)
{
PDatagramSocket socket = mSocketVector[index];
return FD_ISSET(socket->mHandle, &mReadSet);
PDatagramSocket socket = mSocketVector[index];
return (FD_ISSET(socket->mHandle, &mReadSet) != 0);
}
PDatagramSocket DatagramAgreggator::socketAt(unsigned index)
{
return mSocketVector[index];
return mSocketVector[index];
}
bool DatagramAgreggator::waitForData(std::chrono::milliseconds timeout)
bool DatagramAgreggator::waitForData(unsigned milliseconds)
{
timeval tv;
tv.tv_sec = timeout.count() / 1000;
tv.tv_usec = (timeout.count() % 1000) * 1000;
timeval tv;
tv.tv_sec = milliseconds / 1000;
tv.tv_usec = (milliseconds % 1000) * 1000;
int rescode = ::select(mMaxHandle + 1, &mReadSet, nullptr, nullptr, &tv);
return rescode > 0;
int rescode = ::select(mMaxHandle, &mReadSet, NULL, NULL, &tv);
return rescode > 0;
}
src/engine/helper/HL_NetworkSocket.h
+30 -33
View File
@@ -1,4 +1,4 @@
/* Copyright(C) 2007-2026 VoIP objects (voipobjects.com)
/* Copyright(C) 2007-2014 VoIP objects (voipobjects.com)
* 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/. */
@@ -9,61 +9,58 @@
#include "HL_InternetAddress.h"
#include <vector>
#include <memory>
#include <chrono>
class NetworkSocket
{
public:
virtual int localport() = 0;
virtual int localport() = 0;
};
class DatagramSocket
{
friend class SocketHeap;
friend class DatagramAgreggator;
friend class SocketHeap;
friend class DatagramAgreggator;
public:
DatagramSocket();
virtual ~DatagramSocket();
DatagramSocket();
virtual ~DatagramSocket();
virtual int localport();
virtual int localport();
virtual void sendDatagram(InternetAddress& dest, const void* packetData, unsigned packetSize);
virtual unsigned recvDatagram(InternetAddress& src, void* packetBuffer, unsigned packetCapacity);
virtual void closeSocket();
virtual bool isValid() const;
virtual int family() const;
virtual bool setBlocking(bool blocking);
virtual SOCKET socket() const;
virtual void open(int family);
virtual void sendDatagram(InternetAddress& dest, const void* packetData, unsigned packetSize);
virtual unsigned recvDatagram(InternetAddress& src, void* packetBuffer, unsigned packetCapacity);
virtual void closeSocket();
virtual bool isValid() const;
virtual int family() const;
virtual bool setBlocking(bool blocking);
virtual SOCKET socket() const;
virtual void open(int family);
protected:
int mFamily;
SOCKET mHandle;
int mLocalPort;
void internalClose();
int mFamily;
SOCKET mHandle;
int mLocalPort;
};
typedef std::shared_ptr<DatagramSocket> PDatagramSocket;
class DatagramAgreggator
{
public:
DatagramAgreggator();
~DatagramAgreggator();
DatagramAgreggator();
~DatagramAgreggator();
void addSocket(PDatagramSocket socket);
unsigned count();
bool hasDataAtIndex(unsigned index);
PDatagramSocket socketAt(unsigned index);
void addSocket(PDatagramSocket socket);
unsigned count();
bool hasDataAtIndex(unsigned index);
PDatagramSocket socketAt(unsigned index);
bool waitForData(std::chrono::milliseconds timeout);
bool waitForData(unsigned milliseconds);
protected:
typedef std::vector<PDatagramSocket> SocketList;
SocketList mSocketVector;
fd_set mReadSet;
SOCKET mMaxHandle;
typedef std::vector<PDatagramSocket> SocketList;
SocketList mSocketVector;
fd_set mReadSet;
SOCKET mMaxHandle;
};
#endif
src/engine/helper/HL_Optional.hpp
+580 -692
View File
File diff suppressed because it is too large Load Diff
src/engine/helper/HL_OsVersion.cpp
+60 -60
View File
@@ -10,79 +10,79 @@
#include <windows.h>
#if defined(USE_MINIDUMP)
#include <DbgHelp.h>
# include <DbgHelp.h>
#endif
int winVersion()
{
DWORD dwVersion = 0;
DWORD dwMajorVersion = 0;
DWORD dwMinorVersion = 0;
DWORD dwBuild = 0;
DWORD dwVersion = 0;
DWORD dwMajorVersion = 0;
DWORD dwMinorVersion = 0;
DWORD dwBuild = 0;
dwVersion = GetVersion();
dwVersion = GetVersion();
// Get the Windows version.
// Get the Windows version.
dwMajorVersion = (DWORD)(LOBYTE(LOWORD(dwVersion)));
dwMinorVersion = (DWORD)(HIBYTE(LOWORD(dwVersion)));
dwMajorVersion = (DWORD)(LOBYTE(LOWORD(dwVersion)));
dwMinorVersion = (DWORD)(HIBYTE(LOWORD(dwVersion)));
// Get the build number.
// Get the build number.
if (dwVersion < 0x80000000)
dwBuild = (DWORD)(HIWORD(dwVersion));
if (dwVersion < 0x80000000)
dwBuild = (DWORD)(HIWORD(dwVersion));
if (dwMajorVersion == 5)
return Win_Xp;
if (dwMajorVersion == 5)
return Win_Xp;
if (dwMinorVersion == 1)
return Win_Seven;
else
return Win_Vista;
}
if (dwMinorVersion == 1)
return Win_Seven;
else
return Win_Vista;
}
// ----------------- CrashMiniDump -----------------
#if defined(USE_MINIDUMP)
static LONG WINAPI MyExceptionHandler(EXCEPTION_POINTERS* ExceptionInfo)
{
// Open the file
HANDLE hFile =
CreateFile(L"MiniDump.dmp", GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
// Open the file
HANDLE hFile = CreateFile( L"MiniDump.dmp", GENERIC_READ | GENERIC_WRITE,
0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
if ((hFile != NULL) && (hFile != INVALID_HANDLE_VALUE))
{
// Create the minidump
MINIDUMP_EXCEPTION_INFORMATION mdei;
if( ( hFile != NULL ) && ( hFile != INVALID_HANDLE_VALUE ) )
{
// Create the minidump
MINIDUMP_EXCEPTION_INFORMATION mdei;
mdei.ThreadId = GetCurrentThreadId();
mdei.ExceptionPointers = ExceptionInfo;
mdei.ClientPointers = FALSE;
mdei.ThreadId = GetCurrentThreadId();
mdei.ExceptionPointers = ExceptionInfo;
mdei.ClientPointers = FALSE;
MINIDUMP_TYPE mdt = MiniDumpWithFullMemory;
MINIDUMP_TYPE mdt = MiniDumpWithFullMemory;
BOOL rv = MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), hFile, mdt,
(ExceptionInfo != 0) ? &mdei : 0, 0, 0);
BOOL rv = MiniDumpWriteDump( GetCurrentProcess(), GetCurrentProcessId(),
hFile, mdt, (ExceptionInfo != 0) ? &mdei : 0, 0, 0 );
// Close the file
CloseHandle(hFile);
}
else
{
}
// Close the file
CloseHandle( hFile );
}
else
{
}
return EXCEPTION_CONTINUE_SEARCH;
return EXCEPTION_CONTINUE_SEARCH;
}
static LPTOP_LEVEL_EXCEPTION_FILTER OldExceptionHandler = nullptr;
void CrashMiniDump::registerHandler()
void CrashMiniDump::registerHandler()
{
OldExceptionHandler = ::SetUnhandledExceptionFilter(&MyExceptionHandler);
OldExceptionHandler = ::SetUnhandledExceptionFilter(&MyExceptionHandler);
}
void CrashMiniDump::unregisterHandler()
{
::SetUnhandledExceptionFilter(nullptr);
::SetUnhandledExceptionFilter(nullptr);
}
#endif
@@ -124,29 +124,29 @@ int _kbhit()
ioctl(STDIN, FIONREAD, &bytesWaiting);
return bytesWaiting;*/
static const int STDIN_FILENO = 0;
struct termios oldt, newt;
int ch;
int oldf;
struct termios oldt, newt;
int ch;
int oldf;
tcgetattr(STDIN_FILENO, &oldt);
newt = oldt;
newt.c_lflag &= ~(ICANON | ECHO);
tcsetattr(STDIN_FILENO, TCSANOW, &newt);
oldf = fcntl(STDIN_FILENO, F_GETFL, 0);
fcntl(STDIN_FILENO, F_SETFL, oldf | O_NONBLOCK);
tcgetattr(STDIN_FILENO, &oldt);
newt = oldt;
newt.c_lflag &= ~(ICANON | ECHO);
tcsetattr(STDIN_FILENO, TCSANOW, &newt);
oldf = fcntl(STDIN_FILENO, F_GETFL, 0);
fcntl(STDIN_FILENO, F_SETFL, oldf | O_NONBLOCK);
ch = getchar();
ch = getchar();
tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
fcntl(STDIN_FILENO, F_SETFL, oldf);
tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
fcntl(STDIN_FILENO, F_SETFL, oldf);
if (ch != EOF)
{
ungetc(ch, stdin);
return 1;
}
if(ch != EOF)
{
ungetc(ch, stdin);
return 1;
}
return 0;
return 0;
}
#endif
src/engine/helper/HL_OsVersion.h
+9 -9
View File
@@ -10,11 +10,11 @@
enum
{
Win_Xp = 0,
Win_Vista = 1,
Win_Seven = 2,
Win_Eight = 3,
Win_Ten = 4
Win_Xp = 0,
Win_Vista = 1,
Win_Seven = 2,
Win_Eight = 3,
Win_Ten = 4
};
extern int winVersion();
@@ -22,8 +22,8 @@ extern int winVersion();
class CrashMiniDump
{
public:
static void registerHandler();
static void unregisterHandler();
static void registerHandler();
static void unregisterHandler();
};
extern void writeMiniDump();
@@ -41,7 +41,7 @@ int iosVersion();
#include <sys/select.h>
#include <termios.h>
#if defined(TARGET_LINUX)
// # include <stropts.h>
//# include <stropts.h>
#endif
extern int _kbhit();
@@ -49,6 +49,6 @@ extern int _kbhit();
#endif
#if defined(TARGET_WIN)
#include <conio.h>
# include <conio.h>
#endif
#endif
src/engine/helper/HL_Pointer.cpp
+28 -26
View File
@@ -5,49 +5,51 @@
#include "HL_Pointer.h"
UsageCounter::UsageCounter() {}
UsageCounter::UsageCounter()
{}
UsageCounter::~UsageCounter() {}
UsageCounter::~UsageCounter()
{}
int UsageCounter::obtain(int usageId)
{
Lock l(mGuard);
UsageMap::iterator usageIter = mUsage.find(usageId);
if (usageIter != mUsage.end())
usageIter->second = usageIter->second + 1;
else
mUsage[usageId] = 1;
Lock l(mGuard);
UsageMap::iterator usageIter = mUsage.find(usageId);
if (usageIter != mUsage.end())
usageIter->second = usageIter->second + 1;
else
mUsage[usageId] = 1;
return usageCount();
return usageCount();
}
int UsageCounter::release(int usageId)
{
Lock l(mGuard);
UsageMap::iterator usageIter = mUsage.find(usageId);
if (usageIter == mUsage.end())
return usageCount();
usageIter->second = usageIter->second - 1;
if (!usageIter->second)
mUsage.erase(usageIter);
Lock l(mGuard);
UsageMap::iterator usageIter = mUsage.find(usageId);
if (usageIter == mUsage.end())
return usageCount();
usageIter->second = usageIter->second - 1;
if (!usageIter->second)
mUsage.erase(usageIter);
return usageCount();
}
int UsageCounter::usageCount()
{
Lock l(mGuard);
UsageMap::const_iterator usageIter;
int result = 0;
for (usageIter = mUsage.begin(); usageIter != mUsage.end(); usageIter++)
result += usageIter->second;
Lock l(mGuard);
UsageMap::const_iterator usageIter;
int result = 0;
for (usageIter = mUsage.begin(); usageIter != mUsage.end(); usageIter++)
result += usageIter->second;
return result;
return result;
}
void UsageCounter::clear()
{
Lock l(mGuard);
mUsage.clear();
Lock l(mGuard);
mUsage.clear();
}
src/engine/helper/HL_Pointer.h
+9 -9
View File
@@ -13,17 +13,17 @@
class UsageCounter
{
public:
UsageCounter();
~UsageCounter();
int obtain(int usageId);
int release(int usageId);
int usageCount();
void clear();
UsageCounter();
~UsageCounter();
int obtain(int usageId);
int release(int usageId);
int usageCount();
void clear();
protected:
typedef std::map<int, int> UsageMap;
UsageMap mUsage;
Mutex mGuard;
typedef std::map<int, int> UsageMap;
UsageMap mUsage;
Mutex mGuard;
};
#endif
src/engine/helper/HL_PoolAllocator.h
-399
View File
@@ -1,399 +0,0 @@
#pragma once
/// @file
/// @brief A thread-local fixed-block memory pool plus a std-conforming Allocator wrapper, used to
/// pool the small, short-lived, per-RTP-packet shared_ptr nodes produced by std::allocate_shared
/// (e.g. allocate_shared<jrtplib::RTPPacket> on the capture path and allocate_shared<RtpBuffer::
/// Packet> in the jitter buffer). Those objects are fixed-size and churn at the packet rate, so a
/// pool removes them from the general allocator's hot path.
///
/// Pooling is active by default. Define HL_RTP_POOL=0 at compile time to make hl::PoolAllocator a
/// transparent passthrough to the global allocator (i.e. allocate_shared behaves like make_shared)
/// for A/B benchmarking without touching the call sites.
#include <atomic>
#include <cstddef>
#include <cstdint>
#include <mutex>
#include <new>
#include <vector>
#ifndef HL_RTP_POOL
#define HL_RTP_POOL 1
#endif
namespace hl
{
#if HL_RTP_POOL
/// @class FixedBlockPool
/// A process-wide, fixed-block pool with a lock-free thread-local fast path: uniform 256-byte
/// blocks carved from 64 KB chunks, an intrusive thread-local free list, and a per-block header
/// tag so deallocate() is O(1) and lock-free for any block (and can tell pooled blocks from the
/// global-allocator fallback used for oversized requests) regardless of the freeing thread.
///
/// CROSS-THREAD RECLAIM (2026-07-26) — fixes an unbounded capacity ratchet. A uniform block size
/// makes a block allocated on one thread safe to free on another, but "safe" is not "reclaimed".
/// With a purely thread-local free list the block joins the FREEING thread's list, so a
/// producer/consumer split strands it: vq-core allocates RTPPacket / jitter-buffer nodes on the
/// capture threads and frees them on the interval/reap side, so the capture threads' lists were
/// perpetually empty and refill() carved a fresh chunk every BlocksPerChunk allocations, forever.
/// Observed on vqmonitor (the only box with >1 capture thread): capacityBlocks() 256 -> 11.8M
/// = 2.7 GiB over 4 days at ~25 MiB/h, while activeBlocks() drained to 0 every idle interval.
///
/// The fix is a process-wide depot of free-block batches. A thread whose free list grows past
/// ThreadCacheHighWater hands a batch down to the depot; a thread that runs dry takes a batch
/// from the depot before carving a new chunk; a thread flushes its remainder to the depot on
/// exit. The depot is touched once per BlocksPerChunk operations and the hysteresis between
/// "empty" and the high-water keeps it off the per-packet path, so the fast path stays lock-free.
/// capacityBlocks() now plateaus at the true concurrent high-water instead of ratcheting.
class FixedBlockPool
{
public:
/// Usable bytes handed back to the caller from a pooled block. Comfortably covers the
/// shared_ptr nodes we pool (control block + RTPPacket / RtpBuffer::Packet, ~90-130 bytes).
static constexpr std::size_t PayloadSize = 240;
static constexpr std::size_t BlocksPerChunk = 256;
/// Free blocks a thread keeps to itself before handing a BlocksPerChunk batch to the depot.
/// Must exceed BlocksPerChunk so a thread that churns around the boundary does not bounce
/// on the depot mutex; 2x leaves a full batch in hand after every release.
static constexpr std::size_t ThreadCacheHighWater = 2 * BlocksPerChunk;
static void* allocate(std::size_t size)
{
if (size > PayloadSize)
{
uint8_t* raw = static_cast<uint8_t*>(::operator new(size + HeaderSize));
tagOf(raw) = TagGlobal;
s_activeGlobal.fetch_add(1, std::memory_order_relaxed);
return raw + HeaderSize;
}
ThreadCache& tc = cache();
if (tc.head == nullptr)
{
// Reclaim from the depot before asking the OS for more memory. Only when the
// depot is dry as well has the pool genuinely outgrown its current capacity.
std::size_t taken = 0;
tc.head = depot().takeBatch(taken);
if (tc.head == nullptr)
{
tc.head = registry().refill();
taken = BlocksPerChunk;
}
tc.count = taken;
}
uint8_t* block = static_cast<uint8_t*>(tc.head);
tc.head = nextOf(block);
--tc.count;
s_activeBlocks.fetch_add(1, std::memory_order_relaxed);
return block + HeaderSize;
}
static void deallocate(void* ptr) noexcept
{
if (ptr == nullptr)
return;
uint8_t* block = static_cast<uint8_t*>(ptr) - HeaderSize;
if (tagOf(block) == TagPool)
{
ThreadCache& tc = cache();
nextOf(block) = tc.head;
tc.head = block;
++tc.count;
s_activeBlocks.fetch_sub(1, std::memory_order_relaxed);
// The one line that closes the ratchet: surplus goes back to the depot, where
// the thread that actually allocates can reach it.
if (tc.count >= ThreadCacheHighWater)
releaseBatch(tc, BlocksPerChunk);
}
else
{
::operator delete(static_cast<void*>(block));
s_activeGlobal.fetch_sub(1, std::memory_order_relaxed);
}
}
/// @name Diagnostics (relaxed gauges — not synchronization)
/// @{
/// Blocks currently handed out from the pool = pooled allocate() minus
/// pooled deallocate(). Unlike capacityBlocks() (the chunk high-water,
/// which only ever grows) this DROPS when objects are freed, so a rising
/// activeBlocks() is a genuine leak of referenced objects rather than a
/// traffic peak that merely carved extra chunks. Covers every pooled
/// shared_ptr node (allocate_shared<RTPPacket> + jitter-buffer packets).
static std::int64_t activeBlocks() noexcept { return s_activeBlocks.load(std::memory_order_relaxed); }
/// Live oversized allocations that overflowed to ::operator new.
static std::int64_t activeGlobalAllocations() noexcept { return s_activeGlobal.load(std::memory_order_relaxed); }
/// Total blocks ever carved (chunks x BlocksPerChunk) = high-water capacity.
/// With cross-thread reclaim this PLATEAUS once the pool has covered the
/// concurrent high-water; sustained linear growth means reclaim is not working.
static std::int64_t capacityBlocks() noexcept
{
return s_chunks.load(std::memory_order_relaxed) * static_cast<std::int64_t>(BlocksPerChunk);
}
/// Free blocks parked in the process-wide depot, i.e. reclaimed from a freeing
/// thread and available to any allocating thread. Healthy steady state is a
/// non-zero, bounded value: it is the surplus that used to be stranded.
static std::int64_t depotBlocks() noexcept { return s_depotBlocks.load(std::memory_order_relaxed); }
/// Approximate live pooled payload bytes (excludes per-block header).
static std::int64_t activeBytes() noexcept { return activeBlocks() * static_cast<std::int64_t>(PayloadSize); }
/// @}
private:
inline static std::atomic<std::int64_t> s_activeBlocks{0};
inline static std::atomic<std::int64_t> s_activeGlobal{0};
inline static std::atomic<std::int64_t> s_chunks{0};
inline static std::atomic<std::int64_t> s_depotBlocks{0};
static constexpr std::size_t HeaderSize =
alignof(std::max_align_t) >= sizeof(uint64_t) ? alignof(std::max_align_t) : sizeof(uint64_t);
static constexpr std::size_t BlockSize = HeaderSize + PayloadSize;
static constexpr uint64_t TagPool = 0x504F4F4C52545008ULL; // "POOLRTP\b"
static constexpr uint64_t TagGlobal = 0x474C4F42524C0808ULL; // "GLOBRL\b\b"
/// A free block's payload is dead space, so the list links live there. Slot 0 chains
/// blocks within a list/batch; slots 1-2 are used only on a batch's head block, to chain
/// batches inside the depot and to carry the batch length (batches from a thread-exit
/// flush are shorter than BlocksPerChunk).
static_assert(PayloadSize >= 2 * sizeof(void*) + sizeof(std::size_t),
"pooled block payload must hold the free-list, depot and length slots");
static uint64_t& tagOf(void* block) noexcept { return *reinterpret_cast<uint64_t*>(block); }
static void*& nextOf(void* block) noexcept
{
return *reinterpret_cast<void**>(static_cast<uint8_t*>(block) + HeaderSize);
}
static void*& batchNextOf(void* block) noexcept
{
return *reinterpret_cast<void**>(static_cast<uint8_t*>(block) + HeaderSize + sizeof(void*));
}
static std::size_t& batchLenOf(void* block) noexcept
{
return *reinterpret_cast<std::size_t*>(static_cast<uint8_t*>(block) + HeaderSize + 2 * sizeof(void*));
}
/// Per-thread free list. The destructor hands the remainder to the depot so a thread that
/// exits does not strand its blocks — the same ratchet as the cross-thread case, just
/// triggered once per thread instead of continuously.
struct ThreadCache
{
void* head = nullptr;
std::size_t count = 0;
~ThreadCache()
{
while (count > 0 && head != nullptr)
releaseBatch(*this, count);
}
};
static ThreadCache& cache() noexcept
{
static thread_local ThreadCache tc;
return tc;
}
/// Detach the first `blocks` entries of the thread list and park them in the depot.
static void releaseBatch(ThreadCache& tc, std::size_t blocks) noexcept
{
if (blocks == 0 || tc.head == nullptr)
return;
void* batchHead = tc.head;
void* batchTail = batchHead;
std::size_t length = 1;
for (; length < blocks && nextOf(batchTail) != nullptr; ++length)
batchTail = nextOf(batchTail);
tc.head = nextOf(batchTail);
tc.count -= length;
nextOf(batchTail) = nullptr;
batchLenOf(batchHead) = length;
depot().giveBatch(batchHead, length);
}
/// Process-wide store of reclaimed batches. Intrusive (the links live in the free blocks
/// themselves) so neither path can allocate or throw — deallocate() is noexcept. The mutex
/// is taken once per BlocksPerChunk operations, not per packet.
class Depot
{
public:
void* takeBatch(std::size_t& lengthOut) noexcept
{
std::lock_guard<std::mutex> lock(m_Mutex);
void* batch = m_Head;
if (batch == nullptr)
{
lengthOut = 0;
return nullptr;
}
m_Head = batchNextOf(batch);
lengthOut = batchLenOf(batch);
batchNextOf(batch) = nullptr;
s_depotBlocks.fetch_sub(static_cast<std::int64_t>(lengthOut), std::memory_order_relaxed);
return batch;
}
void giveBatch(void* batch, std::size_t length) noexcept
{
std::lock_guard<std::mutex> lock(m_Mutex);
batchNextOf(batch) = m_Head;
m_Head = batch;
s_depotBlocks.fetch_add(static_cast<std::int64_t>(length), std::memory_order_relaxed);
}
private:
std::mutex m_Mutex;
void* m_Head = nullptr;
};
class ChunkRegistry
{
public:
void* refill()
{
const std::size_t chunkBytes = BlockSize * BlocksPerChunk;
uint8_t* chunk = static_cast<uint8_t*>(::operator new(chunkBytes));
s_chunks.fetch_add(1, std::memory_order_relaxed);
{
std::lock_guard<std::mutex> lock(m_Mutex);
m_Chunks.push_back(chunk);
}
void* list = nullptr;
for (std::size_t i = 0; i < BlocksPerChunk; ++i)
{
uint8_t* block = chunk + i * BlockSize;
tagOf(block) = TagPool;
nextOf(block) = list;
list = block;
}
return list;
}
private:
std::mutex m_Mutex;
std::vector<uint8_t*> m_Chunks;
};
/// Both singletons are deliberately immortal (leaked at exit, reclaimed by the OS).
/// A thread_local ThreadCache is destroyed at thread exit — for the main thread that is
/// during static destruction — and its destructor touches the depot, so a depot with a
/// destructor could be used after being destroyed. The same applies to the chunk memory:
/// any pooled object outliving the registry would free into deleted chunks. Never
/// destroying them removes both hazards; the process is exiting either way.
static Depot& depot() noexcept
{
static Depot* instance = new Depot();
return *instance;
}
static ChunkRegistry& registry()
{
static ChunkRegistry* instance = new ChunkRegistry();
return *instance;
}
};
#endif // HL_RTP_POOL
/// Mode-independent accessors for the pool diagnostics, so callers need not know
/// whether HL_RTP_POOL is compiled in. When pooling is disabled they return -1
/// ("not applicable") since allocate_shared then behaves like make_shared.
#if HL_RTP_POOL
inline std::int64_t poolActiveBlocks() noexcept
{
return FixedBlockPool::activeBlocks();
}
inline std::int64_t poolCapacityBlocks() noexcept
{
return FixedBlockPool::capacityBlocks();
}
inline std::int64_t poolDepotBlocks() noexcept
{
return FixedBlockPool::depotBlocks();
}
inline std::int64_t poolActiveGlobal() noexcept
{
return FixedBlockPool::activeGlobalAllocations();
}
inline std::int64_t poolActiveBytes() noexcept
{
return FixedBlockPool::activeBytes();
}
#else
inline std::int64_t poolActiveBlocks() noexcept
{
return -1;
}
inline std::int64_t poolCapacityBlocks() noexcept
{
return -1;
}
inline std::int64_t poolDepotBlocks() noexcept
{
return -1;
}
inline std::int64_t poolActiveGlobal() noexcept
{
return -1;
}
inline std::int64_t poolActiveBytes() noexcept
{
return -1;
}
#endif
/// @class PoolAllocator
/// A stateless, std-conforming Allocator suitable for std::allocate_shared. When HL_RTP_POOL is
/// enabled it serves single-node allocations from FixedBlockPool; otherwise (and for any request
/// that does not fit a pooled block) it delegates to the global allocator, matching make_shared.
template<class T>
struct PoolAllocator
{
using value_type = T;
PoolAllocator() noexcept = default;
template<class U>
PoolAllocator(const PoolAllocator<U>&) noexcept
{
}
T* allocate(std::size_t n)
{
#if HL_RTP_POOL
return static_cast<T*>(FixedBlockPool::allocate(n * sizeof(T)));
#else
return static_cast<T*>(::operator new(n * sizeof(T)));
#endif
}
void deallocate(T* p, std::size_t /*n*/) noexcept
{
#if HL_RTP_POOL
FixedBlockPool::deallocate(p);
#else
::operator delete(static_cast<void*>(p));
#endif
}
template<class U>
bool operator==(const PoolAllocator<U>&) const noexcept
{
return true;
}
template<class U>
bool operator!=(const PoolAllocator<U>&) const noexcept
{
return false;
}
};
} // namespace hl

Some files were not shown because too many files have changed in this diff Show More