async private void InitializeAdaptiveMediaSource(System.Uri uri)
{
manifestUri = uri;
httpClient.DefaultRequestHeaders.TryAppendWithoutValidation("X-CustomHeader", "This is a custom header");
AdaptiveMediaSourceCreationResult result = await AdaptiveMediaSource.CreateFromUriAsync(manifestUri, httpClient);
if (result.Status == AdaptiveMediaSourceCreationStatus.Success)
{
ams = result.MediaSource;
mediaElement.SetMediaStreamSource(ams);
ams.InitialBitrate = ams.AvailableBitrates.Max <uint>();
//Register for download requests
// ams.DownloadRequested += DownloadRequested;
//Register for bitrate change events
// ams.DownloadBitrateChanged += DownloadBitrateChanged;
// ams.PlaybackBitrateChanged += PlaybackBitrateChanged;
}
else
{
// Handle failure to create the adaptive media source
}
}
private async Task RefreshLeoPlayer()
{
if (_HLSUri == null)
{
return;
}
await ClearLeoPlayer();
await HohoemaApp.UIDispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, async() =>
{
// var streamAsyncUri = _HLSUri.Replace("master.m3u8", "stream_sync.json");
// var playSetupRes = await HohoemaApp.NiconicoContext.HttpClient.GetAsync(new Uri(streamAsyncUri));
try
{
var amsCreateResult = await AdaptiveMediaSource.CreateFromUriAsync(new Uri(_HLSUri), HohoemaApp.NiconicoContext.HttpClient);
if (amsCreateResult.Status == AdaptiveMediaSourceCreationStatus.Success)
{
var ams = amsCreateResult.MediaSource;
_MediaSource = MediaSource.CreateFromAdaptiveMediaSource(ams);
_AdaptiveMediaSource = ams;
}
MediaPlayer.Source = _MediaSource;
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
});
}
//</SnippetDeclareAMS>
//<SnippetInitializeAMS>
async private void InitializeAdaptiveMediaSource(System.Uri uri)
{
AdaptiveMediaSourceCreationResult result = await AdaptiveMediaSource.CreateFromUriAsync(uri);
if (result.Status == AdaptiveMediaSourceCreationStatus.Success)
{
ams = result.MediaSource;
mediaPlayerElement.SetMediaPlayer(new MediaPlayer());
mediaPlayerElement.MediaPlayer.SetMediaSource(ams);
mediaPlayerElement.MediaPlayer.Play();
ams.InitialBitrate = ams.AvailableBitrates.Max <uint>();
//Register for download requests
ams.DownloadRequested += DownloadRequested;
//Register for bitrate change events
ams.DownloadBitrateChanged += DownloadBitrateChanged;
ams.PlaybackBitrateChanged += PlaybackBitrateChanged;
}
else
{
// Handle failure to create the adaptive media source
}
}
// </SnippetDeclareHttpClient>
async private void InitializeAdaptiveMediaSourceWithCustomHeaders(System.Uri uri)
{
System.Uri manifestUri = new Uri("http://amssamples.streaming.mediaservices.windows.net/49b57c87-f5f3-48b3-ba22-c55cfdffa9cb/Sintel.ism/manifest(format=m3u8-aapl)");
// <SnippetInitializeAMSWithHttpClient>
httpClient = new Windows.Web.Http.HttpClient();
httpClient.DefaultRequestHeaders.TryAppendWithoutValidation("X-CustomHeader", "This is a custom header");
AdaptiveMediaSourceCreationResult result = await AdaptiveMediaSource.CreateFromUriAsync(manifestUri, httpClient);
// </SnippetInitializeAMSWithHttpClient>
if (result.Status == AdaptiveMediaSourceCreationStatus.Success)
{
ams = result.MediaSource;
mediaPlayerElement.SetMediaPlayer(new MediaPlayer());
mediaPlayerElement.MediaPlayer.Source = MediaSource.CreateFromAdaptiveMediaSource(ams);
mediaPlayerElement.MediaPlayer.Play();
txtDownloadBitrate.Text = ams.InitialBitrate.ToString();
txtPlaybackBitrate.Text = ams.InitialBitrate.ToString();
//Register for download requests
ams.DownloadRequested += DownloadRequested;
//Register for bitrate change events
ams.DownloadBitrateChanged += DownloadBitrateChanged;
ams.PlaybackBitrateChanged += PlaybackBitrateChanged;
}
else
{
// Handle failure to create the adaptive media source
MyLogMessageFunction($"Adaptive source creation failed: {manifestUri} - {result.ExtendedError}");
}
}
private async Task <MediaPlaybackItem> LoadSourceFromUriAsync(Uri uri, HttpClient httpClient = null)
{
UnregisterHandlers(mediaPlayerElement.MediaPlayer);
mediaPlayerElement.MediaPlayer?.DisposeSource();
AdaptiveMediaSourceCreationResult result = null;
if (httpClient != null)
{
result = await AdaptiveMediaSource.CreateFromUriAsync(uri, httpClient);
}
else
{
result = await AdaptiveMediaSource.CreateFromUriAsync(uri);
}
MediaSource source;
if (result.Status == AdaptiveMediaSourceCreationStatus.Success)
{
adaptiveMediaSource = result.MediaSource;
// We use a helper class that logs all the events for the AdaptiveMediaSource:
adaptiveMediaSourceLogger = new AdaptiveMediaSourceLogger(LoggerControl, adaptiveMediaSource);
// In addition to logging, we use the callbacks to update some UI elements in this scenario:
RegisterForAdaptiveMediaSourceEvents(adaptiveMediaSource);
// At this point, we have read the manifest of the media source, and all bitrates are known.
bitrateHelper = new BitrateHelper(adaptiveMediaSource.AvailableBitrates);
InitializeBitrateLists(adaptiveMediaSource);
await UpdatePlaybackBitrateAsync(adaptiveMediaSource.CurrentPlaybackBitrate);
await UpdateDownloadBitrateAsync(adaptiveMediaSource.CurrentDownloadBitrate);
source = MediaSource.CreateFromAdaptiveMediaSource(adaptiveMediaSource);
}
else
{
Log($"Error creating the AdaptiveMediaSource. Status: {result.Status}, ExtendedError.Message: {result.ExtendedError.Message}, ExtendedError.HResult: {result.ExtendedError.HResult.ToString("X8")}");
return(null);
}
// We use a helper class that logs all the events for the MediaSource:
mediaSourceLogger = new MediaSourceLogger(LoggerControl, source);
// Save the original Uri.
source.CustomProperties["uri"] = uri.ToString();
// You're likely to put a content tracking id into the CustomProperties.
source.CustomProperties["contentId"] = Guid.NewGuid().ToString();
var mpItem = new MediaPlaybackItem(source);
// We use a helper class that logs all the events for the MediaPlaybackItem:
mediaPlaybackItemLogger = new MediaPlaybackItemLogger(LoggerControl, mpItem);
HideDescriptionOnSmallScreen();
return(mpItem);
}
// </SnippetDeclareAMS>
// <SnippetInitializeAMS>
async private void InitializeAdaptiveMediaSource(System.Uri uri)
{
AdaptiveMediaSourceCreationResult result = await AdaptiveMediaSource.CreateFromUriAsync(uri);
if (result.Status == AdaptiveMediaSourceCreationStatus.Success)
{
ams = result.MediaSource;
mediaPlayerElement.SetMediaPlayer(new MediaPlayer());
mediaPlayerElement.MediaPlayer.Source = MediaSource.CreateFromAdaptiveMediaSource(ams);
mediaPlayerElement.MediaPlayer.Play();
ams.InitialBitrate = ams.AvailableBitrates.Max <uint>();
//Register for download requests
ams.DownloadRequested += DownloadRequested;
//Register for download failure and completion events
ams.DownloadCompleted += DownloadCompleted;
ams.DownloadFailed += DownloadFailed;
//Register for bitrate change events
ams.DownloadBitrateChanged += DownloadBitrateChanged;
ams.PlaybackBitrateChanged += PlaybackBitrateChanged;
//Register for diagnostic event
ams.Diagnostics.DiagnosticAvailable += DiagnosticAvailable;
}
else
{
// Handle failure to create the adaptive media source
MyLogMessageFunction($"Adaptive source creation failed: {uri} - {result.ExtendedError}");
}
}
private async Task <MediaPlaybackItem> LoadSourceFromUriAsync(Uri uri, HttpClient httpClient = null)
{
UnregisterHandlers(mediaPlayerElement.MediaPlayer);
AdaptiveMediaSourceCreationResult result = null;
if (httpClient != null)
{
result = await AdaptiveMediaSource.CreateFromUriAsync(uri, httpClient);
}
else
{
result = await AdaptiveMediaSource.CreateFromUriAsync(uri);
}
MediaSource source;
if (result.Status == AdaptiveMediaSourceCreationStatus.Success)
{
var adaptiveMediaSource = result.MediaSource;
// We use a helper class that logs all the events for the AdaptiveMediaSource:
adaptiveMediaSourceLogger = new AdaptiveMediaSourceLogger(LoggerControl, adaptiveMediaSource);
source = MediaSource.CreateFromAdaptiveMediaSource(adaptiveMediaSource);
}
else
{
Log($"Error creating the AdaptiveMediaSource. Status: {result.Status}, ExtendedError.Message: {result.ExtendedError.Message}, ExtendedError.HResult: {result.ExtendedError.HResult.ToString("X8")}");
return(null);
}
// We use a helper class that logs all the events for the MediaSource:
mediaSourceLogger = new MediaSourceLogger(LoggerControl, source);
// Save the original Uri.
source.CustomProperties["uri"] = uri.ToString();
// You're likely to put a content tracking id into the CustomProperties.
source.CustomProperties["contentId"] = "MainContent_ID";
// In addition to logging, this scenario uses MediaSource events:
RegisterForMediaSourceEvents(source);
var mpItem = new MediaPlaybackItem(source);
// We use a helper class that logs all the events for the MediaPlaybackItem:
mediaPlaybackItemLogger = new MediaPlaybackItemLogger(LoggerControl, mpItem);
// In addition to logging, this scenario uses MediaPlaybackItem events:
RegisterForMediaPlaybackItemEvents(mpItem);
// Now that we should have a MediaPlaybackItem, we will insert pre- mid- and post-roll ads
// with the MediaBreak API.
CreateMediaBreaksForItem(mpItem);
HideDescriptionOnSmallScreen();
return(mpItem);
}
async private void InitializeAdaptiveMediaSource(System.Uri uri, MediaElement m)
{
AdaptiveMediaSourceCreationResult result = await AdaptiveMediaSource.CreateFromUriAsync(uri);
if (result.Status == AdaptiveMediaSourceCreationStatus.Success)
{
ams = result.MediaSource;
m.SetMediaStreamSource(ams);
outputBitrates(); //query for available bitrates and output to the log
txtDownloadBitrate.Text = ams.InitialBitrate.ToString();
txtPlaybackBitrate.Text = ams.InitialBitrate.ToString();
//Register for download requests
ams.DownloadRequested += DownloadRequested;
//Register for bitrate change events
ams.DownloadBitrateChanged += DownloadBitrateChanged;
ams.PlaybackBitrateChanged += PlaybackBitrateChanged;
}
else
{
rootPage.NotifyUser("Error creating the AdaptiveMediaSource\n\t" + result.Status, NotifyType.ErrorMessage);
}
}
private static async void OnUrlChanged(DependencyObject d, DependencyPropertyChangedEventArgs args)
{
var control = d as CrunchyrollPlayer;
var url = args.NewValue as string;
if (url is null)
{
control.Player.MediaPlayer.Source = null;
control.Player.SetMediaPlayer(null);
return;
}
var sourceResult = await AdaptiveMediaSource.CreateFromUriAsync(new Uri(url));
var source = sourceResult.MediaSource;
source.DesiredMinBitrate = source.AvailableBitrates.Max();
var player = new MediaPlayer
{
Source = MediaSource.CreateFromAdaptiveMediaSource(source)
};
player.Volume = control.Volume;
player.VolumeChanged += control.Player_VolumeChanged;
player.PlaybackSession.PositionChanged += control.Player_PositionChanged;
player.MediaEnded += control.Player_MediaEnded;
control.Player.SetMediaPlayer(player);
control.Player.MediaPlayer.Play();
}
private async Task <MediaPlaybackItem> LoadSourceFromUriAsync(Uri uri, HttpClient httpClient = null)
{
UnregisterHandlers(mediaPlayerElement.MediaPlayer);
mediaPlayerElement.MediaPlayer?.DisposeSource();
AdaptiveMediaSourceCreationResult result = null;
if (httpClient != null)
{
result = await AdaptiveMediaSource.CreateFromUriAsync(uri, httpClient);
}
else
{
result = await AdaptiveMediaSource.CreateFromUriAsync(uri);
}
MediaSource source;
if (result.Status == AdaptiveMediaSourceCreationStatus.Success)
{
var adaptiveMediaSource = result.MediaSource;
// We use a helper class that logs all the events for the AdaptiveMediaSource:
adaptiveMediaSourceLogger = new AdaptiveMediaSourceLogger(LoggerControl, adaptiveMediaSource);
source = MediaSource.CreateFromAdaptiveMediaSource(adaptiveMediaSource);
if (adaptiveMediaSource.MaxSeekableWindowSize.HasValue)
{
UpdateSeekableWindowControls(adaptiveMediaSource);
}
}
else
{
Log($"Error creating the AdaptiveMediaSource. Status: {result.Status}, ExtendedError.Message: {result.ExtendedError.Message}, ExtendedError.HResult: {result.ExtendedError.HResult.ToString("X8")}");
return(null);
}
// We use a helper class that logs all the events for the MediaSource:
mediaSourceLogger = new MediaSourceLogger(LoggerControl, source);
// Save the original Uri.
source.CustomProperties["uri"] = uri.ToString();
// You're likely to put a content tracking id into the CustomProperties.
source.CustomProperties["contentId"] = Guid.NewGuid().ToString();
var mpItem = new MediaPlaybackItem(source);
// We use a helper class that logs all the events for the MediaPlaybackItem:
mediaPlaybackItemLogger = new MediaPlaybackItemLogger(LoggerControl, mpItem);
HideDescriptionOnSmallScreen();
return(mpItem);
}
private async Task PlayCommandExecute()
{
var hlsUri = new Uri(HlsUrl);
var hlsSource = await AdaptiveMediaSource.CreateFromUriAsync(hlsUri);
if (hlsSource.Status == AdaptiveMediaSourceCreationStatus.Success)
{
MediaSource = hlsSource.MediaSource;
}
}
private async Task UpdateMediaSource(string url)
{
var mediaUri = new Uri(url);
var mediaSource = await AdaptiveMediaSource.CreateFromUriAsync(mediaUri);
if (mediaSource.Status == AdaptiveMediaSourceCreationStatus.Success)
{
Media.SetMediaStreamSource(mediaSource.MediaSource);
}
}
public async Task <AdaptiveMediaSourceCreationResult> FetchStreamHLS(string channelName)
{
var streamUrl = await _twitchService.FetchStreamURL(channelName);
if (string.IsNullOrEmpty(streamUrl))
{
App.Current.Exit();
}
return(await AdaptiveMediaSource.CreateFromUriAsync(new Uri(streamUrl)));
}
protected override async Task <MediaSource> GetPlyaingVideoMediaSource()
{
if (!NiconicoSession.ToolkitContext.HttpClient.DefaultRequestHeaders.ContainsKey("Origin"))
{
NiconicoSession.ToolkitContext.HttpClient.DefaultRequestHeaders.Add("Origin", "https://www.nicovideo.jp");
}
NiconicoSession.ToolkitContext.HttpClient.DefaultRequestHeaders.Referer = new Uri($"https://www.nicovideo.jp/watch/{_dmcWatchData.Video.Id}");
var session = await GetDmcSessionAsync();
if (session == null)
{
if (_dmcWatchData.Media.DeliveryLegacy != null)
{
throw new NotSupportedException("DmcWatchResponse.Media.DeliveryLegacy not supported");
//return MediaSource.CreateFromUri(new Uri(DmcWatchResponse.Video.SmileInfo.Url));
}
else
{
throw new Models.Infrastructure.HohoemaExpception();
}
}
var uri = session != null ? session.Data.Session.ContentUri : null;
if (session.Data.Session.Protocol.Parameters.HttpParameters.Parameters.HttpOutputDownloadParameters != null)
{
return(MediaSource.CreateFromUri(uri));
}
else if (session.Data.Session.Protocol.Parameters.HttpParameters.Parameters.HlsParameters != null)
{
var hlsParameters = session.Data.Session.Protocol.Parameters.HttpParameters.Parameters.HlsParameters;
if (hlsParameters.Encryption?.HlsEncryptionV1?.KeyUri != null)
{
var key = await this.NiconicoSession.ToolkitContext.HttpClient.GetStringAsync(new Uri(hlsParameters.Encryption.HlsEncryptionV1.KeyUri));
}
var amsResult = await AdaptiveMediaSource.CreateFromUriAsync(uri, this.NiconicoSession.ToolkitContext.HttpClient);
if (amsResult.Status == AdaptiveMediaSourceCreationStatus.Success)
{
await NiconicoSession.ToolkitContext.Video.VideoWatch.SendOfficialHlsWatchAsync(_dmcWatchData.Video.Id, _dmcWatchData.Media.Delivery.TrackingId);
return(MediaSource.CreateFromAdaptiveMediaSource(amsResult.MediaSource));
}
}
throw new NotSupportedException("");
}
private async Task RefreshLeoPlayer()
{
if (_HLSUri == null)
{
return;
}
await ClearLeoPlayer();
_UIScheduler.Schedule(async() =>
{
try
{
// 視聴開始後にスタート時間に自動シーク
string hlsUri = _HLSUri;
if (IsWatchWithTimeshift && TimeshiftPosition != null)
{
hlsUri = MakeSeekedHLSUri(_HLSUri, TimeshiftPosition.Value);
#if DEBUG
Debug.WriteLine(hlsUri);
#endif
}
var amsCreateResult = await AdaptiveMediaSource.CreateFromUriAsync(new Uri(hlsUri), NiconicoSession.Context.HttpClient);
if (amsCreateResult.Status == AdaptiveMediaSourceCreationStatus.Success)
{
var ams = amsCreateResult.MediaSource;
_MediaSource = MediaSource.CreateFromAdaptiveMediaSource(ams);
_AdaptiveMediaSource = ams;
ams.Diagnostics.DiagnosticAvailable += Diagnostics_DiagnosticAvailable;
}
MediaPlayer.Source = _MediaSource;
// タイムシフトで見ている場合はコメントのシークも行う
if (IsWatchWithTimeshift)
{
await ClearCommentsCacheAsync();
_LiveComments.Clear();
_NicoLiveCommentClient.Seek(TimeshiftPosition.Value);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
});
}
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
var uri = new Uri("http://devimages.apple.com/iphone/samples/bipbop/bipbopall.m3u8");
var source = await AdaptiveMediaSource.CreateFromUriAsync(uri);
if (source.Status != AdaptiveMediaSourceCreationStatus.Success)
{
return;
}
MediaPlayer.SetMediaStreamSource(source.MediaSource);
}
// <SnippetBinderBindingAMS>
private async void Binder_Binding_AdaptiveMediaSource(MediaBinder sender, MediaBindingEventArgs args)
{
var deferral = args.GetDeferral();
var contentUri = new Uri("http://contoso.com/media/" + args.MediaBinder.Token);
AdaptiveMediaSourceCreationResult result = await AdaptiveMediaSource.CreateFromUriAsync(contentUri);
if (result.MediaSource != null)
{
args.SetAdaptiveMediaSource(result.MediaSource);
}
args.SetUri(contentUri);
deferral.Complete();
}
async private void InitializeAdaptiveMediaSource(System.Uri uri, MediaElement m)
{
AdaptiveMediaSourceCreationResult result = await AdaptiveMediaSource.CreateFromUriAsync(uri);
if (result.Status == AdaptiveMediaSourceCreationStatus.Success)
{
ams = result.MediaSource;
SetUpProtectionManager(ref m);
m.SetMediaStreamSource(ams);
}
else
{
rootPage.NotifyUser("Error creating the AdaptiveMediaSource\n\t" + result.Status, NotifyType.ErrorMessage);
}
}
public async void InitEmsgCueScenario()
{
// <SnippetEmsgLoadContent>
AdaptiveMediaSourceCreationResult result =
await AdaptiveMediaSource.CreateFromUriAsync(new Uri("http://contoso.com/playlist.m3u"));
if (result.Status != AdaptiveMediaSourceCreationStatus.Success)
{
// TODO: Handle adaptive media source creation errors.
return;
}
var mediaSource = MediaSource.CreateFromAdaptiveMediaSource(result.MediaSource);
var mediaPlaybackItem = new MediaPlaybackItem(mediaSource);
// </SnippetEmsgLoadContent>
// <SnippetEmsgCueTracksChanged>
mediaPlaybackItem.TimedMetadataTracksChanged += (MediaPlaybackItem sender, IVectorChangedEventArgs args) =>
{
if (args.CollectionChange == CollectionChange.ItemInserted)
{
RegisterMetadataHandlerForEmsgCues(sender, (int)args.Index);
}
else if (args.CollectionChange == CollectionChange.Reset)
{
for (int index = 0; index < sender.TimedMetadataTracks.Count; index++)
{
if (sender.TimedMetadataTracks[index].TimedMetadataKind == TimedMetadataKind.ImageSubtitle)
{
RegisterMetadataHandlerForEmsgCues(sender, index);
}
}
}
};
for (int index = 0; index < mediaPlaybackItem.TimedMetadataTracks.Count; index++)
{
RegisterMetadataHandlerForEmsgCues(mediaPlaybackItem, index);
}
// </SnippetEmsgCueTracksChanged>
// <SnippetEmsgCuePlay>
_mediaPlayer = new MediaPlayer();
mediaPlayerElement.SetMediaPlayer(_mediaPlayer);
_mediaPlayer.Source = mediaPlaybackItem;
_mediaPlayer.Play();
// </SnippetEmsgCuePlay>
}
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
try
{
if (NetworkInterface.GetIsNetworkAvailable())
{
player.Visibility = Visibility.Collapsed;
progress.Visibility = Visibility.Visible;
string videoId = String.Empty;
YoutubeVideo video = e.Parameter as YoutubeVideo;
if (video != null && !video.Id.Equals(String.Empty))
{
if (video.IsLive)
{
var streamResponse = await AdaptiveMediaSource.CreateFromUriAsync(new Uri(video.YoutubeLink));
if (streamResponse.Status == AdaptiveMediaSourceCreationStatus.Success)
{
player.SetMediaStreamSource(streamResponse.MediaSource);
}
}
else
{
//-----Get The Video Uri and set it as a player source-------//
var url = await YouTube.GetVideoUriAsync(video.Id, YouTubeQuality.Quality480P);
player.Source = url.Uri;
}
}
player.Visibility = Visibility.Visible;
progress.Visibility = Visibility.Collapsed;
}
else
{
MessageDialog message = new MessageDialog("You're not connected to Internet!");
await message.ShowAsync();
this.Frame.GoBack();
}
}
catch
{
}
base.OnNavigatedTo(e);
}
private async Task PlayHLS(Uri hsl)
{
AdaptiveMediaSourceCreationResult result = await AdaptiveMediaSource.CreateFromUriAsync(hsl);
if (result.Status == AdaptiveMediaSourceCreationStatus.Success)
{
_source = result.MediaSource;
_source.DownloadRequested += _source_DownloadRequested;
_source.DownloadCompleted += _source_DownloadCompleted;
_source.DownloadFailed += _source_DownloadFailed;
_source.DownloadBitrateChanged += _source_DownloadBitrateChanged;
_source.PlaybackBitrateChanged += _source_PlaybackBitrateChanged;
BackgroundMediaPlayer.Current.SetMediaSource(result.MediaSource);
}
}
private async Task LoadSourceFromUriAsync(Uri uri, HttpClient httpClient = null)
{
mediaPlayerElement.MediaPlayer?.DisposeSource();
AdaptiveMediaSourceCreationResult result = null;
if (httpClient != null)
{
result = await AdaptiveMediaSource.CreateFromUriAsync(uri, httpClient);
}
else
{
result = await AdaptiveMediaSource.CreateFromUriAsync(uri);
}
if (result.Status == AdaptiveMediaSourceCreationStatus.Success)
{
adaptiveMS = result.MediaSource;
bitrateHelper = new BitrateHelper(adaptiveMS.AvailableBitrates);
InitializeBitrateLists(adaptiveMS);
// At this point, we have read the manifest of the media source, and all bitrates are known.
await UpdatePlaybackBitrate(adaptiveMS.CurrentPlaybackBitrate);
await UpdateDownloadBitrate(adaptiveMS.CurrentDownloadBitrate);
// Register for events before resolving the MediaSource.
RegisterForAdaptiveMediaSourceEvents(adaptiveMS);
MediaSource source = MediaSource.CreateFromAdaptiveMediaSource(adaptiveMS);
// You can save additional information in the CustomPropertySet for future retrieval.
// Note: MediaSource.CustomProperties is a ValueSet and therefore can store
// only serializable types.
// Save the original Uri.
source.CustomProperties.Add("uri", uri.ToString());
// You're likely to put a content tracking id into the CustomProperties.
source.CustomProperties.Add("contentId", Guid.NewGuid());
mpItem = new MediaPlaybackItem(source);
}
else
{
Log("Error creating the AdaptiveMediaSource: " + result.Status);
}
}
private async Task OpenHlsAsync(DmcSessionResponse session)
{
Assert.IsTrue(HttpStatusCodeHelper.IsSuccessStatusCode(session.Meta.Status));
Debug.WriteLineIf(session.Meta.Message is not null, session.Meta.Message);
Assert.IsNotNull(session.Data.Session.ContentUri);
Assert.AreEqual("mpeg2ts", session.Data.Session.Protocol.Parameters.HttpParameters.Parameters.HlsParameters.MediaSegmentFormat);
// Try open media
var ams = await AdaptiveMediaSource.CreateFromUriAsync(session.Data.Session.ContentUri, _context.HttpClient);
Assert.AreEqual(ams.Status, AdaptiveMediaSourceCreationStatus.Success);
using (var mediaSource = MediaSource.CreateFromAdaptiveMediaSource(ams.MediaSource))
{
await mediaSource.OpenAsync();
}
}
private async void PropChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
if (e.PropertyName == nameof(CurrentChannel))
{
if (!CurrentChannel.Channel.IsSpecial) // Normal channel
{
OperateMediaStreamResult(await AdaptiveMediaSource.CreateFromUriAsync(new Uri(CurrentChannel.Channel.URL, UriKind.RelativeOrAbsolute)));
}
else // Special channel, request for a valid stream url.
{
}
}
else if (e.PropertyName == nameof(CurrentSource) && CurrentSource != null)
{
AvailableBitrates = new ObservableCollection <BitrateModelView>();
foreach (var bitrate in CurrentSource.AvailableBitrates.Where(a => a != 0))
{
AvailableBitrates.Add(new BitrateModelView()
{
Bitrate = bitrate
});
}
OnPropertyChanged("AvailableBitrates");
if (CurrentSettings.PreferedQuality == QualityEnumModel.Düşük)
{
SelectedBitrate = AvailableBitrates.OrderBy(b => b.Bitrate).FirstOrDefault(a => a.Bitrate == CurrentSource.CurrentPlaybackBitrate);
}
else if (CurrentSettings.PreferedQuality == QualityEnumModel.Yüksek)
{
SelectedBitrate = AvailableBitrates.OrderByDescending(b => b.Bitrate).FirstOrDefault(a => a.Bitrate == CurrentSource.CurrentPlaybackBitrate);
}
else if (CurrentSettings.PreferedQuality == QualityEnumModel.Orta)
{
SelectedBitrate = AvailableBitrates.OrderBy(b => b.Bitrate).FirstOrDefault(a => a.Bitrate == AvailableBitrates[AvailableBitrates.Count / 2].Bitrate);
}
}
else if (e.PropertyName == nameof(SelectedBitrate) && SelectedBitrate != null && CurrentSource != null && SelectedBitrate.Bitrate != CurrentSource.CurrentPlaybackBitrate)
{
CurrentSource.DesiredMinBitrate = SelectedBitrate.Bitrate;
}
else if (e.PropertyName == nameof(AllChannels))
{
GroupedChannels = AllChannels.OrderBy(b => b.Channel.Name).GroupBy(a => a.Channel.Category);
}
}
protected override async Task <MediaSource> GetPlyaingVideoMediaSource()
{
if (!NiconicoSession.Context.HttpClient.DefaultRequestHeaders.ContainsKey("Origin"))
{
NiconicoSession.Context.HttpClient.DefaultRequestHeaders.Add("Origin", "https://www.nicovideo.jp");
}
NiconicoSession.Context.HttpClient.DefaultRequestHeaders.Referer = new Uri($"https://www.nicovideo.jp/watch/{DmcWatchResponse.Video.Id}");
var session = await GetDmcSessionAsync();
if (session == null)
{
if (DmcWatchResponse.Video.SmileInfo != null)
{
return(MediaSource.CreateFromUri(new Uri(DmcWatchResponse.Video.SmileInfo.Url)));
}
else
{
throw new Exception();
}
}
var uri = session != null ? new Uri(session.Data.Session.ContentUri) : null;
if (session.Data.Session.Protocol.Parameters.HttpParameters.Parameters.HttpOutputDownloadParameters != null)
{
return(MediaSource.CreateFromUri(uri));
}
else if (session.Data.Session.Protocol.Parameters.HttpParameters.Parameters.HlsParameters != null)
{
var hlsParameters = session.Data.Session.Protocol.Parameters.HttpParameters.Parameters.HlsParameters;
var amsResult = await AdaptiveMediaSource.CreateFromUriAsync(uri, this.NiconicoSession.Context.HttpClient);
if (amsResult.Status == AdaptiveMediaSourceCreationStatus.Success)
{
await NiconicoSession.Context.Video.SendOfficialHlsWatchAsync(DmcWatchResponse.Video.Id, DmcWatchResponse.Video.DmcInfo.TrackingId);
return(MediaSource.CreateFromAdaptiveMediaSource(amsResult.MediaSource));
}
}
throw new NotSupportedException("");
}
private async Task <AdaptiveMediaSource> BuildHlsMediaSource()
{
var client = new HttpClient();
// Might want custom headers
//client.DefaultRequestHeaders.Add("Referer", "xyz");
var result = await AdaptiveMediaSource.CreateFromUriAsync(_dashStreamUrl, client);
if (result.Status == AdaptiveMediaSourceCreationStatus.Success)
{
Debug.WriteLine($"Success: got manifest");
return(result.MediaSource);
}
else
{
Debug.WriteLine($"Error: {result.Status}");
return(null);
}
}
private async Task ChangeChannel(string url, string title)
{
var result = await AdaptiveMediaSource.CreateFromUriAsync(new Uri(url, UriKind.Absolute));
if (result.Status == AdaptiveMediaSourceCreationStatus.Success)
{
var astream = result.MediaSource;
Player.SetMediaStreamSource(astream);
}
else
{
Player.Source = new Uri(url, UriKind.Absolute);
}
Title.Text = title;
IconSb.Begin();
}
private async void BtnPlay_Tapped(object sender, TappedRoutedEventArgs e)
{
_licenseOverride = txtLicenseOverride.Text;
if (!String.IsNullOrWhiteSpace(txtStreamUrl.Text))
{
var adaptiveMediaSourceResult = await AdaptiveMediaSource.CreateFromUriAsync(new Uri(txtStreamUrl.Text.Trim()));
if (adaptiveMediaSourceResult.Status == AdaptiveMediaSourceCreationStatus.Success)
{
mediaPlayerElement.Source = MediaSource.CreateFromAdaptiveMediaSource(adaptiveMediaSourceResult.MediaSource);
}
else
{
Debug.WriteLine("Error opening the stream");
}
}
}
private async Task LoadSourceFromUriAsync(Uri uri, HttpClient httpClient = null)
{
mediaPlayerElement.MediaPlayer?.DisposeSource();
AdaptiveMediaSourceCreationResult result = null;
if (httpClient != null)
{
result = await AdaptiveMediaSource.CreateFromUriAsync(uri, httpClient);
}
else
{
result = await AdaptiveMediaSource.CreateFromUriAsync(uri);
}
if (result.Status == AdaptiveMediaSourceCreationStatus.Success)
{
var adaptiveMS = result.MediaSource;
// Register for events before resolving the MediaSource.
RegisterForAdaptiveMediaSourceEvents(adaptiveMS);
MediaSource source = MediaSource.CreateFromAdaptiveMediaSource(adaptiveMS);
// You can save additional information in the CustomPropertySet for future retrieval.
// Note: MediaSource.CustomProperties is a ValueSet and therefore can store
// only serializable types.
// Save the original Uri.
source.CustomProperties.Add("uri", uri.ToString());
// You're likely to put a content tracking id into the CustomProperties.
source.CustomProperties.Add("contentId", Guid.NewGuid());
RegisterForMediaSourceEvents(source);
// Register for events before resolving the MediaSource.
mpItem = new MediaPlaybackItem(source);
RegisterForMediaPlaybackItemEvents(mpItem);
}
else
{
Log($"Error creating the AdaptiveMediaSource: {result.Status}");
}
}
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
string movieSource = e.Parameter as string;
mediaPlayer.Source = new System.Uri(movieSource);
AdaptiveMediaSourceCreationResult result = await AdaptiveMediaSource.CreateFromUriAsync(new System.Uri(movieSource, UriKind.Absolute));
if (result.Status == AdaptiveMediaSourceCreationStatus.Success)
{
var astream = result.MediaSource;
var ttmSource = TimedTextSource.CreateFromUri(new Uri(movieSource));
var mediaSource = MediaSource.CreateFromAdaptiveMediaSource(astream);
mediaSource.ExternalTimedTextSources.Add(ttmSource);
var mediaElement = new MediaPlaybackItem(mediaSource);
mediaPlayer.SetPlaybackSource(mediaElement);
movieLoadingRing.IsActive = false;
}
}