public void AssetFilterOptionalPropertiesTest()
{
using (MockContext context = this.StartMockContextAndInitializeClients(this.GetType()))
{
try
{
CreateMediaServicesAccount();
string assetName = TestUtilities.GenerateName("assetoptionalfilter");
string assetDescription = "A test asset";
string filterName = TestUtilities.GenerateName("assetoptionalfilter");
// Create an asset
Asset inputForAsset = new Asset(description: assetDescription);
Asset createdAsset = MediaClient.Assets.CreateOrUpdate(ResourceGroup, AccountName, assetName, inputForAsset);
// Get AssetFilter, which should not exist
Assert.Equal(System.Net.HttpStatusCode.NotFound, Assert.Throws <ErrorResponseException>(() => MediaClient.AssetFilters.Get(ResourceGroup, AccountName, assetName, filterName)).Response.StatusCode);
// List AssetFilters, which should be empty
var assetFilters = MediaClient.AssetFilters.List(ResourceGroup, AccountName, assetName);
Assert.Empty(assetFilters);
// Create an AssetFilter
// Some of the AssetFilter parameters are for Live. Create a filter for VOD that does not specify Live parameters
var ptr = new PresentationTimeRange(startTimestamp: 1, endTimestamp: 600 * HNSTimescale);
AssetFilter input = new AssetFilter(presentationTimeRange: ptr);
AssetFilter createdAssetFilter = MediaClient.AssetFilters.CreateOrUpdate(ResourceGroup, AccountName, assetName, filterName, input);
ValidateAssetFilter(createdAssetFilter, expectedFirstQuality: null, expectedName: filterName, expectedPresentationTimeRange: ptr, expectedTracks: null);
// List asset filters and validate the created filter shows up
assetFilters = MediaClient.AssetFilters.List(ResourceGroup, AccountName, assetName);
Assert.Single(assetFilters);
ValidateAssetFilter(assetFilters.First(), expectedFirstQuality: null, expectedName: filterName, expectedPresentationTimeRange: ptr, expectedTracks: null);
// Get the newly created asset
AssetFilter assetFilter = MediaClient.AssetFilters.Get(ResourceGroup, AccountName, assetName, filterName);
Assert.NotNull(assetFilter);
ValidateAssetFilter(assetFilter, expectedFirstQuality: null, expectedName: filterName, expectedPresentationTimeRange: ptr, expectedTracks: null);
// Delete the asset filter
MediaClient.AssetFilters.Delete(ResourceGroup, AccountName, assetName, filterName);
// List asset filters, which should be empty again
assetFilters = MediaClient.AssetFilters.List(ResourceGroup, AccountName, assetName);
Assert.Empty(assetFilters);
// Get the asset filter, which should not exist
Assert.Equal(System.Net.HttpStatusCode.NotFound, Assert.Throws <ErrorResponseException>(() => MediaClient.AssetFilters.Get(ResourceGroup, AccountName, assetName, filterName)).Response.StatusCode);
// Delete the asset
MediaClient.Assets.Delete(ResourceGroup, AccountName, assetName);
}
finally
{
DeleteMediaServicesAccount();
}
}
}
public object CreateFilter(string sourceUrl, string filterName, int markIn, int markOut)
{
ulong?timescale = 1;
ulong?markInSeconds = (ulong?)markIn;
ulong?markOutSeconds = markOut > 0 ? (ulong?)markOut : null;
PresentationTimeRange timeRange = new PresentationTimeRange(timescale, markInSeconds, markOutSeconds);
List <FilterTrackSelectStatement> trackConditions = new List <FilterTrackSelectStatement>();
IAsset sourceAsset = GetSourceAsset(sourceUrl);
return(sourceAsset.AssetFilters.Create(filterName, timeRange, trackConditions));
}
public IStreamingAssetFilter CreateFilter(IAsset asset, string filterName, int markIn, int markOut, int?bitrate)
{
ulong?timescale = 1;
ulong?markInSeconds = (ulong?)markIn;
ulong?markOutSeconds = markOut > 0 ? (ulong?)markOut : null;
PresentationTimeRange timeRange = new PresentationTimeRange(timescale, markInSeconds, markOutSeconds);
List <FilterTrackSelectStatement> trackConditions = new List <FilterTrackSelectStatement>();
FirstQuality firstQuality = bitrate.HasValue ? new FirstQuality(bitrate.Value) : null;
return(asset.AssetFilters.Create(filterName, timeRange, trackConditions, firstQuality));
}
/// <summary>
/// Gets the list of filter names to be applied to this asset, given filtering parameters.
/// </summary>
/// <param name="startTime">The optional start time for filtering.</param>
/// <param name="endTime">The optional end time for filtering.</param>
/// <returns>The list of filter names to be applied to this asset.</returns>
private async Task <List <string> > GetListFiltersAsync(TimeSpan?startTime, TimeSpan?endTime, string uniqueness, string assetName)
{
List <string> listFilters = null;
if (startTime != null || endTime != null)
{
string filterName = "filter-time-" + uniqueness;
PresentationTimeRange presTimeRange = new PresentationTimeRange(
startTime?.Ticks,
endTime?.Ticks,
null,
null,
TimeSpan.TicksPerSecond);
listFilters = new List <string>()
{
filterName
};
try
{
AssetFilter newAssetFilter = await this.MediaServicesV3SdkWrapper.AssetFiltersCreateOrUpdateAsync(
assetName,
filterName,
new AssetFilter()
{
PresentationTimeRange = presTimeRange
}).ConfigureAwait(false);
}
catch (Exception ex)
{
var msg = "AMS v3 Publish. Error when creating asset filter.";
var exceptionToThrow = new GridwichPublicationAssetFilterCreateException(
assetName,
msg,
ex);
// Providing additional specific details:
exceptionToThrow.Data.Add("startTime", startTime?.ToString());
exceptionToThrow.Data.Add("endTime", endTime?.ToString());
throw exceptionToThrow;
}
}
return(listFilters);
}
public void StreamingLocatorComboTest()
{
using (MockContext context = this.StartMockContextAndInitializeClients(this.GetType()))
{
try
{
CreateMediaServicesAccount();
// List the StreamingLocators, which should be empty
var locators = MediaClient.StreamingLocators.List(ResourceGroup, AccountName);
Assert.Empty(locators);
string locatorName = TestUtilities.GenerateName("StreamingLocator");
// Get the StreamingLocator, which should not exist
Assert.Equal(System.Net.HttpStatusCode.NotFound, Assert.Throws <ErrorResponseException>(() => MediaClient.StreamingLocators.Get(ResourceGroup, AccountName, locatorName)).Response.StatusCode);
// Create an Asset for the StreamingLocator to point to
string assetName = TestUtilities.GenerateName("assetToPublish");
Asset assetToPublish = MediaClient.Assets.CreateOrUpdate(ResourceGroup, AccountName, assetName, new Asset());
// Create 2 AssetFilters, to be added to StreamingLocator.
// There's no update on StreamingLocators, so no need for update on the Filters.
string filterNameA = TestUtilities.GenerateName("assetFilterA");
// Create an AssetFilter
var ptr = new PresentationTimeRange(0, 600 * HNSTimescale, 120 * HNSTimescale, 0, HNSTimescale, false);
AssetFilter assetFilter = new AssetFilter(presentationTimeRange: ptr);
AssetFilter createdAssetFilter = MediaClient.AssetFilters.CreateOrUpdate(ResourceGroup, AccountName, assetName, filterNameA, assetFilter);
string filterNameB = TestUtilities.GenerateName("assetFilterB");
createdAssetFilter = MediaClient.AssetFilters.CreateOrUpdate(ResourceGroup, AccountName, assetName, filterNameB, assetFilter);
string[] filters = new string[]
{
filterNameA,
filterNameB
};
// Create the ContentKeyPolicy for the StreamingLocator
string policyName = TestUtilities.GenerateName("contentKeyPolicy");
CreateContentKeyPolicy(policyName);
// Create a StreamingLocator
StreamingLocator input = new StreamingLocator(assetName: assetName, streamingPolicyName: PredefinedStreamingPolicy.ClearKey, defaultContentKeyPolicyName: policyName, filters: filters);
StreamingLocator createdLocator = MediaClient.StreamingLocators.Create(ResourceGroup, AccountName, locatorName, input);
ValidateLocator(createdLocator, locatorName, assetName, policyName, PredefinedStreamingPolicy.ClearKey, filters);
// List the StreamingLocators and validate the newly created one shows up
locators = MediaClient.StreamingLocators.List(ResourceGroup, AccountName);
Assert.Single(locators);
ValidateLocator(locators.First(), locatorName, assetName, policyName, PredefinedStreamingPolicy.ClearKey);
// Get the newly created StreamingLocator
StreamingLocator locator = MediaClient.StreamingLocators.Get(ResourceGroup, AccountName, locatorName);
Assert.NotNull(locator);
ValidateLocator(locator, locatorName, assetName, policyName, PredefinedStreamingPolicy.ClearKey, filters);
// Delete the StreamingLocator
MediaClient.StreamingLocators.Delete(ResourceGroup, AccountName, locatorName);
// List the StreamingLocators, which should be empty again
locators = MediaClient.StreamingLocators.List(ResourceGroup, AccountName);
Assert.Empty(locators);
// Get the StreamingLocator, which should not exist
Assert.Equal(System.Net.HttpStatusCode.NotFound, Assert.Throws <ErrorResponseException>(() => MediaClient.StreamingLocators.Get(ResourceGroup, AccountName, locatorName)).Response.StatusCode);
MediaClient.Assets.Delete(ResourceGroup, AccountName, assetName);
MediaClient.ContentKeyPolicies.Delete(ResourceGroup, AccountName, policyName);
}
finally
{
DeleteMediaServicesAccount();
}
}
}
public void AccountFilterComboTest()
{
using (MockContext context = this.StartMockContextAndInitializeClients(this.GetType()))
{
try
{
CreateMediaServicesAccount();
string assetName = TestUtilities.GenerateName("asset");
string assetDescription = "A test asset";
string filterName = TestUtilities.GenerateName("assetfilter");
// Create an asset
Asset inputForAsset = new Asset(description: assetDescription);
Asset createdAsset = MediaClient.Assets.CreateOrUpdate(ResourceGroup, AccountName, assetName, inputForAsset);
// Get AccountFilter, which should not exist
Assert.Equal(System.Net.HttpStatusCode.NotFound, Assert.Throws <ErrorResponseException>(() => MediaClient.AccountFilters.Get(ResourceGroup, AccountName, filterName)).Response.StatusCode);
// List AccountFilters, which should be empty
var accountFilters = MediaClient.AccountFilters.List(ResourceGroup, AccountName);
Assert.Empty(accountFilters);
// Create an AccountFilter
var ptr = new PresentationTimeRange(0, 600 * HNSTimescale, 120 * HNSTimescale, 0, HNSTimescale, false);
AccountFilter input = new AccountFilter(presentationTimeRange: ptr);
AccountFilter createdAccountFilter = MediaClient.AccountFilters.CreateOrUpdate(ResourceGroup, AccountName, filterName, input);
ValidateAccountFilter(createdAccountFilter, expectedFirstQuality: null, expectedName: filterName, expectedPresentationTimeRange: ptr, expectedTracks: null);
// List asset filters and validate the created filter shows up
accountFilters = MediaClient.AccountFilters.List(ResourceGroup, AccountName);
Assert.Single(accountFilters);
ValidateAccountFilter(accountFilters.First(), expectedFirstQuality: null, expectedName: filterName, expectedPresentationTimeRange: ptr, expectedTracks: null);
// Get the newly created asset
AccountFilter accountFilter = MediaClient.AccountFilters.Get(ResourceGroup, AccountName, filterName);
Assert.NotNull(accountFilter);
ValidateAccountFilter(accountFilter, expectedFirstQuality: null, expectedName: filterName, expectedPresentationTimeRange: ptr, expectedTracks: null);
// Update the asset filter
List <FilterTrackPropertyCondition> audioConditions = new List <FilterTrackPropertyCondition>()
{
new FilterTrackPropertyCondition(FilterTrackPropertyType.Type, "audio", FilterTrackPropertyCompareOperation.Equal),
new FilterTrackPropertyCondition(FilterTrackPropertyType.FourCC, "ec-3", FilterTrackPropertyCompareOperation.Equal),
};
List <FilterTrackPropertyCondition> videoConditions = new List <FilterTrackPropertyCondition>()
{
new FilterTrackPropertyCondition(FilterTrackPropertyType.Type, "video", FilterTrackPropertyCompareOperation.Equal),
new FilterTrackPropertyCondition(FilterTrackPropertyType.FourCC, "avc1", FilterTrackPropertyCompareOperation.Equal),
};
List <FilterTrackSelection> tracks = new List <FilterTrackSelection>()
{
new FilterTrackSelection(audioConditions),
new FilterTrackSelection(videoConditions)
};
FirstQuality firstQuality = new FirstQuality(FirstQualityBitRate);
AccountFilter input2 = new AccountFilter(presentationTimeRange: ptr, firstQuality: firstQuality, tracks: tracks);
AccountFilter updatedAccountFilter = MediaClient.AccountFilters.CreateOrUpdate(ResourceGroup, AccountName, filterName, input2);
ValidateAccountFilter(updatedAccountFilter, expectedFirstQuality: firstQuality, expectedName: filterName, expectedPresentationTimeRange: ptr, expectedTracks: tracks);
// List asset filters and validate the updated asset filter shows up as expected
accountFilters = MediaClient.AccountFilters.List(ResourceGroup, AccountName);
Assert.Single(accountFilters);
ValidateAccountFilter(accountFilters.First(), expectedFirstQuality: firstQuality, expectedName: filterName, expectedPresentationTimeRange: ptr, expectedTracks: tracks);
// Get the newly updated asset filter
accountFilter = MediaClient.AccountFilters.Get(ResourceGroup, AccountName, filterName);
Assert.NotNull(accountFilter);
ValidateAccountFilter(accountFilter, expectedFirstQuality: firstQuality, expectedName: filterName, expectedPresentationTimeRange: ptr, expectedTracks: tracks);
// Delete the asset filter
MediaClient.AccountFilters.Delete(ResourceGroup, AccountName, filterName);
// List asset filters, which should be empty again
accountFilters = MediaClient.AccountFilters.List(ResourceGroup, AccountName);
Assert.Empty(accountFilters);
// Get the asset filter, which should not exist
Assert.Equal(System.Net.HttpStatusCode.NotFound, Assert.Throws <ErrorResponseException>(() => MediaClient.AccountFilters.Get(ResourceGroup, AccountName, filterName)).Response.StatusCode);
// Delete the asset
MediaClient.Assets.Delete(ResourceGroup, AccountName, assetName);
}
finally
{
DeleteMediaServicesAccount();
}
}
}
internal static void ValidateAccountFilter(AccountFilter accountFilter, FirstQuality expectedFirstQuality, string expectedName, PresentationTimeRange expectedPresentationTimeRange, IList <FilterTrackSelection> expectedTracks)
{
Assert.Equal(expectedFirstQuality?.Bitrate, accountFilter.FirstQuality?.Bitrate);
Assert.Equal(expectedName, accountFilter.Name);
if (expectedPresentationTimeRange != null)
{
Assert.Equal(expectedPresentationTimeRange.StartTimestamp, accountFilter.PresentationTimeRange.StartTimestamp);
Assert.Equal(expectedPresentationTimeRange.EndTimestamp, accountFilter.PresentationTimeRange.EndTimestamp);
Assert.Equal(expectedPresentationTimeRange.PresentationWindowDuration, accountFilter.PresentationTimeRange.PresentationWindowDuration);
Assert.Equal(expectedPresentationTimeRange.LiveBackoffDuration, accountFilter.PresentationTimeRange.LiveBackoffDuration);
Assert.Equal(expectedPresentationTimeRange.Timescale, accountFilter.PresentationTimeRange.Timescale);
Assert.Equal(expectedPresentationTimeRange.ForceEndTimestamp, accountFilter.PresentationTimeRange.ForceEndTimestamp);
}
else
{
Assert.Null(accountFilter.PresentationTimeRange);
}
if (expectedTracks != null)
{
// A filter can include multiple track definitions
Assert.Equal(expectedTracks.Count, accountFilter.Tracks.Count);
for (int x = 0; x < expectedTracks.Count; x++)
{
// For each track included in the filter, there can be multiple selection criteria. The criteria have an AND relationship
Assert.Equal(expectedTracks[x].TrackSelections.Count, accountFilter.Tracks[x].TrackSelections.Count);
for (int y = 0; y < expectedTracks[x].TrackSelections.Count; y++)
{
Assert.Equal(expectedTracks[x].TrackSelections[y].Property, accountFilter.Tracks[x].TrackSelections[y].Property);
Assert.Equal(expectedTracks[x].TrackSelections[y].Operation, accountFilter.Tracks[x].TrackSelections[y].Operation);
Assert.Equal(expectedTracks[x].TrackSelections[y].Value, accountFilter.Tracks[x].TrackSelections[y].Value);
}
}
}
else
{
Assert.True(accountFilter.Tracks == null || accountFilter.Tracks.Count == 0);
}
}
private void DynManifestFilter_Load(object sender, EventArgs e)
{
_parentassetmanifestdata = new ManifestTimingData();
tabControl1.TabPages.Remove(tabPageTRRaw);
FillComboBoxImportFilters(_parentAsset);
timeControlDVR.TotalDuration = TimeSpan.FromHours(24);
timeControlDVR.Max = TimeSpan.FromHours(24);
/////////////////////////////////////////////
// New Global Filter
/////////////////////////////////////////////
if (_filterToDisplay == null && _parentAsset == null)
{
newfilter = true;
isGlobalFilter = true;
tabControl1.TabPages.Remove(tabPageInformation);
_filter_presentationtimerange = new PresentationTimeRange();
filtertracks = new List <ExFilterTrack>();
timeControlStart.DisplayTrackBar = timeControlEnd.DisplayTrackBar = timeControlDVR.DisplayTrackBar = false;
_timescale = timeControlStart.TimeScale = timeControlEnd.TimeScale = timeControlDVR.TimeScale = _filter_presentationtimerange.Timescale;
textBoxFilterTimeScale.Text = (_filter_presentationtimerange.Timescale == null) ? "(default)" : _filter_presentationtimerange.Timescale.ToString();
}
/////////////////////////////////////////////
// Existing Global Filter
/////////////////////////////////////////////
else if (_filterToDisplay != null && _parentAsset == null)
{
newfilter = false;
isGlobalFilter = true;
DisplayFilterInfo();
_filter_name = _filterToDisplay.Name;
_filter_presentationtimerange = _filterToDisplay.PresentationTimeRange;
filtertracks = ConvertFilterTracksToInternalVar(_filterToDisplay.Tracks);
_timescale = _filterToDisplay.PresentationTimeRange.Timescale;
timeControlStart.TimeScale = timeControlEnd.TimeScale = timeControlDVR.TimeScale = _timescale;
buttonOk.Text = "Update Filter";
buttonOk.Enabled = true; // we can enable the button
toolTip1.SetToolTip(this.buttonOk, "It can take up to 2 minutes for streaming endpoint to refresh the rules");
textBoxFilterName.Enabled = false; // no way to change the filter name
textBoxFilterName.Text = _filter_name;
timeControlStart.DisplayTrackBar = timeControlEnd.DisplayTrackBar = timeControlDVR.DisplayTrackBar = false;
checkBoxStartTime.Checked = _filter_presentationtimerange.StartTimestamp != null;
checkBoxEndTime.Checked = _filter_presentationtimerange.EndTimestamp != null;
checkBoxDVRWindow.Checked = _filter_presentationtimerange.PresentationWindowDuration != null;
checkBoxLiveBackoff.Checked = _filter_presentationtimerange.LiveBackoffDuration != null;
timeControlStart.SetScaledTimeStamp(_filter_presentationtimerange.StartTimestamp);
timeControlEnd.SetScaledTimeStamp(_filter_presentationtimerange.EndTimestamp);
timeControlDVR.SetTimeStamp(_filter_presentationtimerange.PresentationWindowDuration ?? TimeSpan.FromMinutes(2)); // we don't want to pass the max value to the control (overflow)
TimeSpan backoff = _filter_presentationtimerange.LiveBackoffDuration ?? new TimeSpan(0);
numericUpDownBackoffSeconds.Value = Convert.ToDecimal(backoff.TotalSeconds);
}
/////////////////////////////////////////////
// New Asset Filter
/////////////////////////////////////////////
else if (_filterToDisplay == null && _parentAsset != null)
{
newfilter = true;
isGlobalFilter = false;
tabControl1.TabPages.Remove(tabPageInformation);
_filter_presentationtimerange = new PresentationTimeRange();
filtertracks = new List <ExFilterTrack>();
labelFilterTitle.Text = "Asset Filter";
textBoxAssetName.Visible = true;
labelassetname.Visible = true;
textBoxAssetName.Text = _parentAsset != null ? _parentAsset.Name : string.Empty;
// let's try to read asset timing
_parentassetmanifestdata = AssetInfo.GetManifestTimingData(_parentAsset);
if (!_parentassetmanifestdata.Error) // we were able to read asset timings and not live
{
// timescale
_timescale = timeControlStart.TimeScale = timeControlEnd.TimeScale = timeControlDVR.TimeScale = _parentassetmanifestdata.TimeScale;
timeControlStart.ScaledFirstTimestampOffset = timeControlEnd.ScaledFirstTimestampOffset = _parentassetmanifestdata.TimestampOffset;
textBoxOffset.Text = _parentassetmanifestdata.TimestampOffset.ToString();
labelOffset.Visible = textBoxOffset.Visible = true;
// let's disable trackbars if this is live (duration is not fixed)
timeControlStart.DisplayTrackBar = timeControlEnd.DisplayTrackBar = timeControlDVR.DisplayTrackBar = !_parentassetmanifestdata.IsLive;
TimeSpan duration = _parentassetmanifestdata.AssetDuration;
textBoxAssetDuration.Text = duration.ToString(@"d\.hh\:mm\:ss");
labelassetduration.Visible = textBoxAssetDuration.Visible = true;
textBoxFilterName.Text = "filter" + new Random().Next(9999).ToString();
if (!_parentassetmanifestdata.IsLive) // Not a live content
{
// let set duration and active track bat
timeControlStart.TotalDuration = timeControlEnd.TotalDuration = timeControlDVR.TotalDuration = _parentassetmanifestdata.AssetDuration;
timeControlDVR.TotalDuration = TimeSpan.FromHours(24);
timeControlStart.Max = timeControlEnd.Max = duration;
timeControlEnd.SetTimeStamp(timeControlEnd.Max);
}
else
{
textBoxAssetDuration.Text += " (LIVE)";
}
if (_subclipconfig != null && _subclipconfig.Trimming) // user used the subclip UI before and timings are passed
{
timeControlStart.SetTimeStamp(_subclipconfig.StartTimeForAssetFilter - timeControlStart.GetOffSetAsTimeSpan());
timeControlEnd.SetTimeStamp(_subclipconfig.EndTimeForAssetFilter - timeControlStart.GetOffSetAsTimeSpan());
checkBoxStartTime.Checked = checkBoxEndTime.Checked = true;
textBoxFilterName.Text = "subclip" + new Random().Next(9999).ToString();
}
}
else // not able to read asset timings
{
timeControlStart.DisplayTrackBar = timeControlEnd.DisplayTrackBar = timeControlDVR.DisplayTrackBar = false;
timeControlStart.TimeScale = timeControlEnd.TimeScale = timeControlDVR.TimeScale = _timescale;
timeControlStart.Max = timeControlEnd.Max = timeControlDVR.Max = TimeSpan.MaxValue;
timeControlEnd.SetTimeStamp(timeControlEnd.Max);
labelassetduration.Visible = textBoxAssetDuration.Visible = false;
}
}
/////////////////////////////////////////////
// Existing Asset Filter
/////////////////////////////////////////////
else if (_filterToDisplay != null && _parentAsset != null)
{
newfilter = false;
isGlobalFilter = false;
DisplayFilterInfo();
_filter_name = _filterToDisplay.Name;
_filter_presentationtimerange = _filterToDisplay.PresentationTimeRange;
filtertracks = ConvertFilterTracksToInternalVar(_filterToDisplay.Tracks);
_timescale = _filterToDisplay.PresentationTimeRange.Timescale;
buttonOk.Text = "Update Filter";
buttonOk.Enabled = true; // we can enable the button
toolTip1.SetToolTip(this.buttonOk, "It can take up to 2 minutes for streaming endpoint to refresh the rules");
labelFilterTitle.Text = "Asset Filter";
textBoxAssetName.Visible = true;
labelassetname.Visible = true;
textBoxAssetName.Text = _parentAsset != null ? _parentAsset.Name : string.Empty;
textBoxFilterName.Enabled = false; // no way to change the filter name
textBoxFilterName.Text = _filter_name;
// let's try to read asset timing
_parentassetmanifestdata = AssetInfo.GetManifestTimingData(_parentAsset);
_timescale = timeControlStart.TimeScale = timeControlEnd.TimeScale = timeControlDVR.TimeScale = _filterToDisplay.PresentationTimeRange.Timescale;
if (!_parentassetmanifestdata.Error && _timescale == _parentassetmanifestdata.TimeScale) // we were able to read asset timings and timescale between manifest and existing asset match
{
// let's disable trackbars if this is live (duration is not fixed)
timeControlStart.DisplayTrackBar = timeControlEnd.DisplayTrackBar = timeControlDVR.DisplayTrackBar = !_parentassetmanifestdata.IsLive;
timeControlStart.ScaledFirstTimestampOffset = timeControlEnd.ScaledFirstTimestampOffset = _parentassetmanifestdata.TimestampOffset;
textBoxOffset.Text = _parentassetmanifestdata.TimestampOffset.ToString();
labelOffset.Visible = textBoxOffset.Visible = true;
TimeSpan duration = _parentassetmanifestdata.AssetDuration;
textBoxAssetDuration.Text = duration.ToString(@"d\.hh\:mm\:ss");
labelassetduration.Visible = textBoxAssetDuration.Visible = true;
if (!_parentassetmanifestdata.IsLive)
{
timeControlStart.Max = timeControlEnd.Max = duration;
// let set duration and active track bat
timeControlStart.TotalDuration = timeControlEnd.TotalDuration = duration;
}
else
{
textBoxAssetDuration.Text += " (LIVE)";
}
}
else // not able to read asset timings or mismatch in timescale
{
timeControlStart.DisplayTrackBar = timeControlEnd.DisplayTrackBar = timeControlDVR.DisplayTrackBar = false;
timeControlStart.Max = timeControlEnd.Max = TimeSpan.MaxValue;
labelassetduration.Visible = textBoxAssetDuration.Visible = false;
}
checkBoxStartTime.Checked = _filter_presentationtimerange.StartTimestamp != null;
checkBoxEndTime.Checked = _filter_presentationtimerange.EndTimestamp != null;
checkBoxDVRWindow.Checked = _filter_presentationtimerange.PresentationWindowDuration != null;
checkBoxLiveBackoff.Checked = _filter_presentationtimerange.LiveBackoffDuration != null;
timeControlStart.SetScaledTimeStamp(_filter_presentationtimerange.StartTimestamp);
timeControlEnd.SetScaledTimeStamp(_filter_presentationtimerange.EndTimestamp); // we don't want to pass the max value to the control (overflow)
timeControlDVR.SetTimeStamp(_filter_presentationtimerange.PresentationWindowDuration ?? TimeSpan.FromMinutes(2)); // we don't want to pass the max value to the control (overflow)
TimeSpan backoff = _filter_presentationtimerange.LiveBackoffDuration ?? new TimeSpan(0);
numericUpDownBackoffSeconds.Value = Convert.ToDecimal(backoff.TotalSeconds);
}
// Common code
textBoxFilterTimeScale.Text = (_timescale == null) ? "(default)" : _timescale.ToString();
// dataPropertyType
dataPropertyType = new DataTable();
dataPropertyType.Columns.Add(new DataColumn("Value", typeof(string)));
dataPropertyType.Columns.Add(new DataColumn("Description", typeof(string)));
dataPropertyType.Rows.Add(FilterTrackType.Audio.ToString(), FilterTrackType.Audio.ToString());
dataPropertyType.Rows.Add(FilterTrackType.Video.ToString(), FilterTrackType.Video.ToString());
dataPropertyType.Rows.Add(FilterTrackType.Text.ToString(), FilterTrackType.Text.ToString());
// FilterPropertyFourCCValue
dataPropertyFourCC = new DataTable();
dataPropertyFourCC.Columns.Add(new DataColumn("Value", typeof(string)));
dataPropertyFourCC.Columns.Add(new DataColumn("Description", typeof(string)));
dataPropertyFourCC.Rows.Add(FilterPropertyFourCCValue.avc1, FilterPropertyFourCCValue.avc1);
dataPropertyFourCC.Rows.Add(FilterPropertyFourCCValue.ec3, FilterPropertyFourCCValue.ec3);
dataPropertyFourCC.Rows.Add(FilterPropertyFourCCValue.mp4a, FilterPropertyFourCCValue.mp4a);
dataPropertyFourCC.Rows.Add(FilterPropertyFourCCValue.mp4v, FilterPropertyFourCCValue.mp4v);
// dataProperty
dataProperty = new DataTable();
dataProperty.Columns.Add(new DataColumn("Property", typeof(string)));
dataProperty.Columns.Add(new DataColumn("Description", typeof(string)));
dataProperty.Rows.Add(FilterProperty.Type, FilterProperty.Type);
dataProperty.Rows.Add(FilterProperty.Bitrate, FilterProperty.Bitrate);
dataProperty.Rows.Add(FilterProperty.FourCC, FilterProperty.FourCC);
dataProperty.Rows.Add(FilterProperty.Language, FilterProperty.Language);
dataProperty.Rows.Add(FilterProperty.Name, FilterProperty.Name);
// dataOperator
dataOperator = new DataTable();
dataOperator.Columns.Add(new DataColumn("Operator", typeof(string)));
dataOperator.Columns.Add(new DataColumn("Description", typeof(string)));
dataOperator.Rows.Add(FilterTrackCompareOperator.Equal.ToString(), FilterTrackCompareOperator.Equal.ToString());
dataOperator.Rows.Add(FilterTrackCompareOperator.NotEqual.ToString(), FilterTrackCompareOperator.NotEqual.ToString());
var columnProperty = new DataGridViewComboBoxColumn();
columnProperty.DataSource = dataProperty;
columnProperty.ValueMember = "Property";
columnProperty.DisplayMember = "Description";
dataGridViewTracks.Columns.Add(columnProperty);
var columnOperator = new DataGridViewComboBoxColumn();
columnOperator.DataSource = dataOperator;
columnOperator.ValueMember = "Operator";
columnOperator.DisplayMember = "Description";
dataGridViewTracks.Columns.Add(columnOperator);
var columnValue = new DataGridViewTextBoxColumn();
dataGridViewTracks.Columns.Add(columnValue);
moreinfoprofilelink.Links.Add(new LinkLabel.Link(0, moreinfoprofilelink.Text.Length, Constants.LinkHowIMoreInfoDynamicManifest));
RefreshTracks();
CheckIfErrorTimeControls();
UpdateDurationText();
}
