0
# Media Filters
1

2
Dynamic content filtering capabilities through account-level and asset-level filters for adaptive streaming scenarios. Filters enable presentation time range selection, track filtering, bitrate constraints, and dynamic manifest manipulation without re-encoding content.
3

4
## Capabilities
5

6
### Account Filter Management
7

8
Manage account-level filters that apply globally across multiple assets and streaming sessions.
9

10
```python { .api }
11
def list(resource_group_name: str, account_name: str) -> Iterable[AccountFilter]:
12
    """
13
    List all account filters in a media service account.
14
    
15
    Parameters:
16
    - resource_group_name: Name of the resource group (str)
17
    - account_name: Name of the media service account (str)
18
    
19
    Returns:
20
    Iterable of AccountFilter objects with filtering configuration
21
    """
22

23
def get(
24
    resource_group_name: str,
25
    account_name: str,
26
    filter_name: str
27
) -> AccountFilter:
28
    """
29
    Get a specific account filter with complete configuration.
30
    
31
    Parameters:
32
    - resource_group_name: Name of the resource group (str)
33
    - account_name: Name of the media service account (str)
34
    - filter_name: Name of the account filter (str)
35
    
36
    Returns:
37
    AccountFilter object with filtering rules and settings
38
    """
39

40
def create_or_update(
41
    resource_group_name: str,
42
    account_name: str,
43
    filter_name: str,
44
    parameters: AccountFilter
45
) -> AccountFilter:
46
    """
47
    Create or update an account filter.
48
    
49
    Parameters:
50
    - resource_group_name: Name of the resource group (str)
51
    - account_name: Name of the media service account (str)
52
    - filter_name: Name for the account filter (str)
53
    - parameters: Account filter configuration (AccountFilter)
54
    
55
    Returns:
56
    Created or updated AccountFilter object
57
    """
58

59
def update(
60
    resource_group_name: str,
61
    account_name: str,
62
    filter_name: str,
63
    parameters: AccountFilter
64
) -> AccountFilter:
65
    """
66
    Update an existing account filter.
67
    
68
    Parameters:
69
    - resource_group_name: Name of the resource group (str)
70
    - account_name: Name of the media service account (str)
71
    - filter_name: Name of the account filter (str)
72
    - parameters: Updated account filter configuration (AccountFilter)
73
    
74
    Returns:
75
    Updated AccountFilter object
76
    """
77

78
def delete(resource_group_name: str, account_name: str, filter_name: str) -> None:
79
    """
80
    Delete an account filter.
81
    
82
    Parameters:
83
    - resource_group_name: Name of the resource group (str)
84
    - account_name: Name of the media service account (str)
85
    - filter_name: Name of the account filter (str)
86
    
87
    Returns:
88
    None
89
    """
90
```
91

92
### Asset Filter Management
93

94
Manage asset-specific filters that apply to individual assets for targeted content filtering.
95

96
```python { .api }
97
def list(
98
    resource_group_name: str,
99
    account_name: str,
100
    asset_name: str
101
) -> Iterable[AssetFilter]:
102
    """
103
    List all filters for a specific asset.
104
    
105
    Parameters:
106
    - resource_group_name: Name of the resource group (str)
107
    - account_name: Name of the media service account (str)
108
    - asset_name: Name of the asset (str)
109
    
110
    Returns:
111
    Iterable of AssetFilter objects with filtering configuration
112
    """
113

114
def get(
115
    resource_group_name: str,
116
    account_name: str,
117
    asset_name: str,
118
    filter_name: str
119
) -> AssetFilter:
120
    """
121
    Get a specific asset filter with complete configuration.
122
    
123
    Parameters:
124
    - resource_group_name: Name of the resource group (str)
125
    - account_name: Name of the media service account (str)
126
    - asset_name: Name of the asset (str)
127
    - filter_name: Name of the asset filter (str)
128
    
129
    Returns:
130
    AssetFilter object with filtering rules and settings
131
    """
132

133
def create_or_update(
134
    resource_group_name: str,
135
    account_name: str,
136
    asset_name: str,
137
    filter_name: str,
138
    parameters: AssetFilter
139
) -> AssetFilter:
140
    """
141
    Create or update an asset filter.
142
    
143
    Parameters:
144
    - resource_group_name: Name of the resource group (str)
145
    - account_name: Name of the media service account (str)
146
    - asset_name: Name of the asset (str)
147
    - filter_name: Name for the asset filter (str)
148
    - parameters: Asset filter configuration (AssetFilter)
149
    
150
    Returns:
151
    Created or updated AssetFilter object
152
    """
153

154
def update(
155
    resource_group_name: str,
156
    account_name: str,
157
    asset_name: str,
158
    filter_name: str,
159
    parameters: AssetFilter
160
) -> AssetFilter:
161
    """
162
    Update an existing asset filter.
163
    
164
    Parameters:
165
    - resource_group_name: Name of the resource group (str)
166
    - account_name: Name of the media service account (str)
167
    - asset_name: Name of the asset (str)
168
    - filter_name: Name of the asset filter (str)
169
    - parameters: Updated asset filter configuration (AssetFilter)
170
    
171
    Returns:
172
    Updated AssetFilter object
173
    """
174

175
def delete(
176
    resource_group_name: str,
177
    account_name: str,
178
    asset_name: str,
179
    filter_name: str
180
) -> None:
181
    """
182
    Delete an asset filter.
183
    
184
    Parameters:
185
    - resource_group_name: Name of the resource group (str)
186
    - account_name: Name of the media service account (str)
187
    - asset_name: Name of the asset (str)
188
    - filter_name: Name of the asset filter (str)
189
    
190
    Returns:
191
    None
192
    """
193
```
194

195
## Data Types
196

197
```python { .api }
198
class AccountFilter:
199
    """Account-level filter for dynamic content filtering."""
200
    name: str
201
    presentation_time_range: PresentationTimeRange
202
    first_quality: FirstQuality
203
    tracks: List[FilterTrackSelection]
204
    
205
class AssetFilter:
206
    """Asset-specific filter for targeted content filtering."""
207
    name: str
208
    presentation_time_range: PresentationTimeRange
209
    first_quality: FirstQuality
210
    tracks: List[FilterTrackSelection]
211
    
212
class PresentationTimeRange:
213
    """Time range specification for content filtering."""
214
    start_timestamp: int
215
    end_timestamp: int
216
    presentation_window_duration: int
217
    live_backoff_duration: int
218
    timescale: int
219
    force_end_timestamp: bool
220
    
221
class FirstQuality:
222
    """Initial quality level specification."""
223
    bitrate: int
224
    
225
class FilterTrackSelection:
226
    """Track selection criteria for filtering."""
227
    track_selections: List[FilterTrackPropertyCondition]
228
    
229
class FilterTrackPropertyCondition:
230
    """Condition for track property filtering."""
231
    property: str  # FilterTrackPropertyType enum
232
    value: str
233
    operation: str  # FilterTrackPropertyCompareOperation enum
234
```
235

236
## Usage Examples
237

238
### Create Time-Range Account Filter
239

240
```python
241
from azure.mgmt.media import AzureMediaServices
242
from azure.mgmt.media.models import (
243
    AccountFilter, PresentationTimeRange, FirstQuality
244
)
245
from azure.identity import DefaultAzureCredential
246

247
client = AzureMediaServices(
248
    credential=DefaultAzureCredential(),
249
    subscription_id="your-subscription-id"
250
)
251

252
# Create time range filter (skip first 30 seconds, limit to 10 minutes)
253
time_range = PresentationTimeRange(
254
    start_timestamp=300000000,      # 30 seconds in 100ns units
255
    end_timestamp=6000000000,       # 10 minutes in 100ns units
256
    presentation_window_duration=0,  # Not applicable for VOD
257
    live_backoff_duration=0,        # Not applicable for VOD
258
    timescale=10000000,             # 100ns timescale
259
    force_end_timestamp=True
260
)
261

262
# Set initial quality to 1Mbps
263
first_quality = FirstQuality(bitrate=1000000)
264

265
# Create account filter
266
account_filter = AccountFilter(
267
    presentation_time_range=time_range,
268
    first_quality=first_quality
269
)
270

271
created_filter = client.account_filters.create_or_update(
272
    resource_group_name="my-resource-group",
273
    account_name="my-media-service",
274
    filter_name="time-range-filter",
275
    parameters=account_filter
276
)
277

278
print(f"Account filter created: {created_filter.name}")
279
```
280

281
### Create Track-Specific Asset Filter
282

283
```python
284
from azure.mgmt.media.models import (
285
    AssetFilter, FilterTrackSelection, FilterTrackPropertyCondition,
286
    FilterTrackPropertyType, FilterTrackPropertyCompareOperation
287
)
288

289
# Create audio-only filter
290
audio_condition = FilterTrackPropertyCondition(
291
    property=FilterTrackPropertyType.TYPE,
292
    value="Audio",
293
    operation=FilterTrackPropertyCompareOperation.EQUAL
294
)
295

296
audio_track_selection = FilterTrackSelection(
297
    track_selections=[audio_condition]
298
)
299

300
# Create asset filter for audio-only playback
301
audio_filter = AssetFilter(
302
    tracks=[audio_track_selection]
303
)
304

305
created_asset_filter = client.asset_filters.create_or_update(
306
    resource_group_name="my-resource-group",
307
    account_name="my-media-service",
308
    asset_name="multi-track-asset",
309
    filter_name="audio-only-filter",
310
    parameters=audio_filter
311
)
312

313
print(f"Asset filter created: {created_asset_filter.name}")
314
```
315

316
### Apply Filters to Streaming Locator
317

318
```python
319
from azure.mgmt.media.models import StreamingLocator
320

321
# Create streaming locator with filters
322
filtered_locator = StreamingLocator(
323
    asset_name="encoded-asset",
324
    streaming_policy_name="Predefined_ClearStreamingOnly",
325
    filters=["time-range-filter"]  # Reference account filter by name
326
)
327

328
client.streaming_locators.create(
329
    resource_group_name="my-resource-group",
330
    account_name="my-media-service",
331
    streaming_locator_name="filtered-streaming-locator",
332
    parameters=filtered_locator
333
)
334

335
print("Streaming locator created with time-range filter applied")
336
```