aboutsummaryrefslogtreecommitdiffstats
path: root/src/ahl-policy-utils.h
blob: 6adfa4ee674a45e35a4e61c84f1d1013d0f4b78e (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
/*
 * Copyright (C) 2017 "Audiokinetic Inc"
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef AHL_POLICY_UTILS_INCLUDE
#define AHL_POLICY_UTILS_INCLUDE

#define AFB_BINDING_VERSION 2
#include <json-c/json.h>
#include <afb/afb-binding.h>
#include <glib.h>

#define AHL_POLICY_ACCEPT 1
#define AHL_POLICY_REJECT 0
#define AHL_POLICY_UTIL_SUCCESS 0
#define AHL_POLICY_UTIL_FAIL 1

typedef int endpointID_t;
typedef int streamID_t;

typedef enum StreamEvent {
    STREAM_EVENT_START  = 0,   // Stream is inactive
    STREAM_EVENT_STOP,         // Stream is running    
    STREAM_EVENT_PAUSE,        // Audio stream paused
    STREAM_EVENT_RESUME,       // Audio stream resumed
    STREAM_EVENT_MUTED,        // Audio stream muted
    STREAM_EVENT_UNMUTED,      // Audio stream unmuted
    STREAM_EVENT_MAXVALUE      // Enum count, keep at the end
} StreamEventT;

typedef enum StreamMute {
    STREAM_UNMUTED = 0,         // Stream is not muted
    STREAM_MUTED,               // Stream is muted
    STREAM_MUTE_MAXVALUE,       // Enum count, keep at the end
} StreamMuteT;

typedef enum EndpointType {
    ENDPOINTTYPE_SOURCE = 0,        // source devices
    ENDPOINTTYPE_SINK,              // sink devices
    ENDPOINTTYPE_MAXVALUE           // Enum count, keep at the end
} EndpointTypeT;

typedef enum StreamState {
    STREAM_STATE_IDLE  = 0,    // Stream is inactive
    STREAM_STATE_RUNNING,      // Stream is active and running    
    STREAM_STATE_PAUSED,       // Stream is active but paused
    STREAM_STATE_MAXVALUE      // Enum count, keep at the end
} StreamStateT;

// Define default behavior of audio role when interrupting lower priority sources
typedef enum InterruptBehavior {
  INTERRUPTBEHAVIOR_CONTINUE = 0, // Continue to play lower priority source when interrupted (e.g. media may be ducked)
  INTERRUPTBEHAVIOR_CANCEL,       // Abort playback of lower priority source when interrupted (e.g. non-important HMI feedback that does not make sense later)
  INTERRUPTBEHAVIOR_PAUSE,        // Pause lower priority source when interrupted, to be resumed afterwards (e.g. non-temporal guidance)
  INTERRUPTBEHAVIOR_MAXVALUE,     // Enum count, keep at the end
} InterruptBehaviorT;

typedef enum DeviceURIType {
    DEVICEURITYPE_ALSA_HW = 0,  // Alsa hardware device URI
    DEVICEURITYPE_ALSA_DMIX,    // Alsa Dmix device URI (only for playback devices)
    DEVICEURITYPE_ALSA_DSNOOP,  // Alsa DSnoop device URI (only for capture devices)
    DEVICEURITYPE_ALSA_SOFTVOL, // Alsa softvol device URI
    DEVICEURITYPE_ALSA_PLUG,    // Alsa plug device URI
    DEVICEURITYPE_ALSA_OTHER,   // Alsa domain URI device of unspecified type
    DEVICEURITYPE_NOT_ALSA,     // Unknown (not ALSA domain)
    DEVICEURITYPE_MAXVALUE      // Enum count, keep at the end
} DeviceURITypeT;

// CPU endianness assumed in all formats
typedef enum SampleType {
  AHL_FORMAT_UNKNOWN = -1,              // Unknown
  AHL_FORMAT_U8 = 0,                    // Unsigned 8 bit
  AHL_FORMAT_S16,                       // Signed 16 bit Little Endian
  AHL_FORMAT_S24,                       // Signed 24 bit Little Endian using low three bytes in 32-bit word
  AHL_FORMAT_S32,                       // Signed 32 bit Little Endian
  AHL_FORMAT_FLOAT,                     // Float 32 bit Little Endian, Range -1.0 to 1.0
  AHL_FORMAT_FLOAT64,                   // Float 64 bit Little Endian, Range -1.0 to 1.0
  AHL_FORMAT_IEC958,                    // IEC-958 Little Endian (SPDIF)
  AHL_FORMAT_MU_LAW,                    // Mu-Law
  AHL_FORMAT_A_LAW,                     // A-Law
  AHL_FORMAT_IMA_ADPCM,                 // Ima-ADPCM
  AHL_FORMAT_MPEG,                      // MPEG
  AHL_FORMAT_GSM,                       // GSM
  AHL_FORMAT_G723,                      // G723
  AHL_FORMAT_DSD,                       // Direct stream digital
  AHL_FORMAT_MAXVALUE,                  // Enum count, keep at the end
} SampleTypeT;

typedef struct AudioFormat {
    int         sampleRate;     // Sample rate
    int         numChannels;    // Number of channels
    SampleTypeT sampleType;     // Sample type
    // TODO: Interleaving?
    // TODO: Sample sub format?
} AudioFormatT;

typedef struct AlsaDeviceInfo {
    int             cardNum;            // HW card number
    int             deviceNum;          // HW device number                                 
    int             subDeviceNum;       // HW sub device number
} AlsaDeviceInfoT;

typedef enum EndpointSelectionMode {
    ENDPOINTSELMODE_AUTO = 0,          // Automatic endpoint selection based on config priority
    ENDPOINTSELMODE_MANUAL,             // Explicit endpoint selection
    ENDPOINTSELMODEMAXVALUE,            // Enum count, keep at the end
} EndpointSelectionModeT;

typedef struct EndpointInfo
{
    endpointID_t    endpointID;         // Unique endpoint ID (per type)
    EndpointTypeT   type;               // Source or sink device
    char *          gsDeviceName;       // Unique device card name 
    char *          gsDisplayName;      // Application display name
    char *          gsDeviceURI;        // Associated URI 
    char *          gsDeviceDomain;     // Device URI domain (e.g. alsa or pulse)
    char *          pRoleName;          // Role assigned to this endpoint 
    DeviceURITypeT  deviceURIType;      // Device URI type (includes audio domain information)
    char *          gsHALAPIName;       // HAL associated with the device (for volume control)
    AlsaDeviceInfoT alsaInfo;           // ALSA specific device information
    AudioFormatT    format;             // Preferred audio format supported (later could be array of supported formats)
    int             iVolume;            // Storage for current endpoint volume (policy effected). 
    GHashTable *    pPropTable;         // Storage for array of properties (policy effected)         
} EndpointInfoT;

typedef struct StreamInfo {
    streamID_t              streamID;           // Stream unique ID
    EndpointInfoT *         pEndpointInfo;      // Associated endpoint information (reference)
    StreamStateT            streamState;        // Stream activity state
    StreamMuteT             streamMute;         // Stream mute state
    struct afb_event        streamStateEvent;   // Stream specific event for stream state changes
    EndpointSelectionModeT  endpointSelMode;    // Automatic (priority based) or manual endpoint selection
    char *                  pRoleName;          // Role string identifier (from role config but could be programatically overriden later)
    int                     iPriority;          // Role normalized priority (0-100) (from role config but could be programatically overriden later)
    InterruptBehaviorT      eInterruptBehavior; // Role behavior when interrupting lower priority streams (from role config but could be programatically overriden later)
} StreamInfoT;


typedef struct StreamPolicyInfo {
    streamID_t      streamID;
    int             RolePriority;
    char *          pAudioRole;    
    InterruptBehaviorT interruptBehavior;   
    int             iDuckVolume;     //duck Volume
} StreamPolicyInfoT;
 
typedef struct EndPointPolicyInfo {
    endpointID_t    endpointID;
    EndpointTypeT   type;    
    DeviceURITypeT  deviceType;
    char *          pDeviceName;
    char *          pHalApiName; 
    int             iVolume;     //Current Volume            
    GArray *        streamInfo; //List of playing or duck stream at a given endpoint
} EndPointPolicyInfoT;

void Add_Endpoint_Property_Double( EndpointInfoT * io_pEndpointInfo, char * in_pPropertyName, double in_dPropertyValue);
void Add_Endpoint_Property_Int( EndpointInfoT * io_pEndpointInfo, char * in_pPropertyName, int in_iPropertyValue);
void Add_Endpoint_Property_String( EndpointInfoT * io_pEndpointInfo, char * in_pPropertyName, const char * in_pPropertyValue);
int PolicyEndpointStructToJSON(EndpointInfoT * pPolicyEndpoint, json_object **ppPolicyEndpointJ);
int PolicyCtxJSONToEndpoint(json_object *pEndpointJ, EndpointInfoT * pPolicyStream);
int PolicyStreamStructToJSON(StreamInfoT * pPolicyStream, json_object **ppPolicyStreamJ);
int PolicyCtxJSONToStream(json_object *pStreamJ, StreamInfoT * pPolicyStream);

#endif // AHL_POLICY_UTILS_INCLUDE