private WaveStream readerStream; // the waveStream which we will use for all positioning
#endregion Fields
#region Constructors
/// <summary>
/// Initializes a new instance of AudioFileReader
/// </summary>
/// <param name="fileName">The file to open</param>
public AudioFileReader(string fileName)
{
lockObject = new object();
this.fileName = fileName;
CreateReaderStream(fileName);
sourceBytesPerSample = (readerStream.WaveFormat.BitsPerSample / 8) * readerStream.WaveFormat.Channels;
sampleChannel = new SampleChannel(readerStream, false);
destBytesPerSample = 4*sampleChannel.WaveFormat.Channels;
length = SourceToDest(readerStream.Length);
}
private void load(AudioManager audio, DialogOverlay dialog, OsuColour colours, SkinManager skins, ScoreManager scores, CollectionManager collections, ManageCollectionsDialog manageCollectionsDialog, DifficultyRecommender recommender)
{
// initial value transfer is required for FilterControl (it uses our re-cached bindables in its async load for the initial filter).
transferRulesetValue();
LoadComponentAsync(Carousel = new BeatmapCarousel
{
AllowSelection = false, // delay any selection until our bindables are ready to make a good choice.
Anchor = Anchor.CentreRight,
Origin = Anchor.CentreRight,
RelativeSizeAxes = Axes.Both,
BleedTop = FilterControl.HEIGHT,
BleedBottom = Footer.HEIGHT,
SelectionChanged = updateSelectedBeatmap,
BeatmapSetsChanged = carouselBeatmapsLoaded,
GetRecommendedBeatmap = s => recommender?.GetRecommendedBeatmap(s),
}, c => carouselContainer.Child = c);
AddRangeInternal(new Drawable[]
{
new ResetScrollContainer(() => Carousel.ScrollToSelected())
{
RelativeSizeAxes = Axes.Y,
Width = 250,
},
new VerticalMaskingContainer
{
Children = new Drawable[]
{
new GridContainer // used for max width implementation
{
RelativeSizeAxes = Axes.Both,
ColumnDimensions = new[]
{
new Dimension(),
new Dimension(GridSizeMode.Relative, 0.5f, maxSize: 850),
},
Content = new[]
{
new Drawable[]
{
new ParallaxContainer
{
ParallaxAmount = 0.005f,
RelativeSizeAxes = Axes.Both,
Child = new WedgeBackground
{
RelativeSizeAxes = Axes.Both,
Padding = new MarginPadding {
Right = -150
},
},
},
carouselContainer = new Container
{
RelativeSizeAxes = Axes.Both,
Padding = new MarginPadding
{
Top = FilterControl.HEIGHT,
Bottom = Footer.HEIGHT
},
Child = new LoadingSpinner(true)
{
State = { Value = Visibility.Visible }
}
}
},
}
},
FilterControl = new FilterControl
{
RelativeSizeAxes = Axes.X,
Height = FilterControl.HEIGHT,
FilterChanged = ApplyFilterToCarousel,
},
new GridContainer // used for max width implementation
{
RelativeSizeAxes = Axes.Both,
ColumnDimensions = new[]
{
new Dimension(GridSizeMode.Relative, 0.5f, maxSize: 650),
},
Content = new[]
{
new Drawable[]
{
new Container
{
Origin = Anchor.BottomLeft,
Anchor = Anchor.BottomLeft,
RelativeSizeAxes = Axes.Both,
Children = new Drawable[]
{
beatmapInfoWedge = new BeatmapInfoWedge
{
Height = WEDGE_HEIGHT,
RelativeSizeAxes = Axes.X,
Margin = new MarginPadding
{
Top = left_area_padding,
Right = left_area_padding,
},
},
new Container
{
RelativeSizeAxes = Axes.Both,
Padding = new MarginPadding
{
Bottom = Footer.HEIGHT,
Top = WEDGE_HEIGHT + left_area_padding,
Left = left_area_padding,
Right = left_area_padding * 2,
},
Child = BeatmapDetails = CreateBeatmapDetailArea().With(d =>
{
d.RelativeSizeAxes = Axes.Both;
d.Padding = new MarginPadding {
Top = 10, Right = 5
};
})
},
}
},
},
}
}
}
},
});
if (ShowFooter)
{
AddRangeInternal(new Drawable[]
{
new GridContainer // used for max height implementation
{
RelativeSizeAxes = Axes.Both,
RowDimensions = new[]
{
new Dimension(),
new Dimension(GridSizeMode.Relative, 1f, maxSize: ModSelectOverlay.HEIGHT + Footer.HEIGHT),
},
Content = new[]
{
null,
new Drawable[]
{
FooterPanels = new Container
{
Anchor = Anchor.BottomLeft,
Origin = Anchor.BottomLeft,
RelativeSizeAxes = Axes.Both,
Padding = new MarginPadding {
Bottom = Footer.HEIGHT
},
Children = new Drawable[]
{
BeatmapOptions = new BeatmapOptionsOverlay(),
ModSelect = new ModSelectOverlay
{
Origin = Anchor.BottomCentre,
Anchor = Anchor.BottomCentre,
}
}
}
}
}
},
Footer = new Footer()
});
}
if (Footer != null)
{
Footer.AddButton(new FooterButtonMods {
Current = Mods
}, ModSelect);
Footer.AddButton(new FooterButtonRandom {
Action = triggerRandom
});
Footer.AddButton(new FooterButtonOptions(), BeatmapOptions);
BeatmapOptions.AddButton(@"Manage", @"collections", FontAwesome.Solid.Book, colours.Green, () => manageCollectionsDialog?.Show());
BeatmapOptions.AddButton(@"Delete", @"all difficulties", FontAwesome.Solid.Trash, colours.Pink, () => delete(Beatmap.Value.BeatmapSetInfo));
BeatmapOptions.AddButton(@"Remove", @"from unplayed", FontAwesome.Regular.TimesCircle, colours.Purple, null);
BeatmapOptions.AddButton(@"Clear", @"local scores", FontAwesome.Solid.Eraser, colours.Purple, () => clearScores(Beatmap.Value.BeatmapInfo));
}
dialogOverlay = dialog;
sampleChangeDifficulty = audio.Samples.Get(@"SongSelect/select-difficulty");
sampleChangeBeatmap = audio.Samples.Get(@"SongSelect/select-expand");
SampleConfirm = audio.Samples.Get(@"SongSelect/confirm-selection");
if (dialogOverlay != null)
{
Schedule(() =>
{
// if we have no beatmaps but osu-stable is found, let's prompt the user to import.
if (!beatmaps.GetAllUsableBeatmapSetsEnumerable(IncludedDetails.Minimal).Any() && beatmaps.StableInstallationAvailable)
{
dialogOverlay.Push(new ImportFromStablePopup(() =>
{
Task.Run(beatmaps.ImportFromStableAsync)
.ContinueWith(_ =>
{
Task.Run(scores.ImportFromStableAsync);
Task.Run(collections.ImportFromStableAsync);
}, TaskContinuationOptions.OnlyOnRanToCompletion);
Task.Run(skins.ImportFromStableAsync);
}));
}
});
}
}
private void load(TextureStore textures, AudioManager audio)
{
sampleClick = audio.Sample.Get(@"Menu/menuhit");
logo.Texture = textures.Get(@"Menu/logo");
ripple.Texture = textures.Get(@"Menu/logo");
}
private void load(AudioManager audio)
{
samplePopIn = audio.Samples.Get(@"UI/overlay-pop-in");
samplePopOut = audio.Samples.Get(@"UI/overlay-pop-out");
}
public void Start()
{
if (_sensor != null)
{
Stop();
}
foreach (var potentialSensor in KinectSensor.KinectSensors)
{
if (potentialSensor.Status == KinectStatus.Connected && _uniqueKinectId == potentialSensor.UniqueKinectId)
{
_sensor = potentialSensor;
break;
}
}
if (_sensor == null)
{
Logger.LogMessage("Sensor not found: " + _uniqueKinectId, "KinectStream");
return;
}
if (_skeleton)
{
_sensor.SkeletonStream.Enable();
_sensor.SkeletonFrameReady += SensorSkeletonFrameReady;
}
switch (StreamMode)
{
case 0: //color
_sensor.ColorStream.Enable(ColorImageFormat.RgbResolution640x480Fps30);
_sensor.ColorFrameReady += SensorColorFrameReady;
break;
case 1: //depth
_sensor.DepthStream.Enable(DepthImageFormat.Resolution640x480Fps30);
_sensor.DepthFrameReady += SensorDepthFrameReady;
// Allocate space to put the depth pixels we'll receive
_depthPixels = new short[_sensor.DepthStream.FramePixelDataLength];
// Allocate space to put the color pixels we'll create
_colorPixels = new byte[_sensor.DepthStream.FramePixelDataLength * sizeof(int)];
break;
case 2: //infrared
_sensor.ColorStream.Enable(ColorImageFormat.InfraredResolution640x480Fps30);
_sensor.ColorFrameReady += SensorColorFrameReady;
break;
}
// Start the sensor
try
{
_sensor.Start();
_audioStream = _sensor.AudioSource.Start();
RecordingFormat = new WaveFormat(16000, 16, 1);
_waveProvider = new BufferedWaveProvider(RecordingFormat)
{
DiscardOnBufferOverflow = true, BufferDuration = TimeSpan.FromMilliseconds(500)
};
_sampleChannel = new SampleChannel(_waveProvider);
_sampleChannel.PreVolumeMeter += SampleChannelPreVolumeMeter;
if (HasAudioStream != null)
{
HasAudioStream(this, EventArgs.Empty);
HasAudioStream = null;
}
_res = ReasonToFinishPlaying.DeviceLost;
// create and start new thread
_thread = new Thread(AudioThread)
{
Name = "kinect audio", IsBackground = true
};
_thread.Start();
}
catch (Exception ex)//IOException)
{
Logger.LogException(ex, "KinectStream");
_sensor = null;
}
}
private void load(AudioManager audio, DialogOverlay dialog, OsuColour colours, SkinManager skins, ScoreManager scores)
{
// initial value transfer is required for FilterControl (it uses our re-cached bindables in its async load for the initial filter).
transferRulesetValue();
AddRangeInternal(new Drawable[]
{
new ResetScrollContainer(() => Carousel.ScrollToSelected())
{
RelativeSizeAxes = Axes.Y,
Width = 250,
},
new VerticalMaskingContainer
{
Children = new Drawable[]
{
new GridContainer // used for max width implementation
{
RelativeSizeAxes = Axes.Both,
ColumnDimensions = new[]
{
new Dimension(),
new Dimension(GridSizeMode.Relative, 0.5f, maxSize: 850),
},
Content = new[]
{
new Drawable[]
{
new ParallaxContainer
{
ParallaxAmount = 0.005f,
RelativeSizeAxes = Axes.Both,
Child = new WedgeBackground
{
RelativeSizeAxes = Axes.Both,
Padding = new MarginPadding {
Right = -150
},
},
},
new Container
{
RelativeSizeAxes = Axes.Both,
Padding = new MarginPadding
{
Top = FilterControl.HEIGHT,
Bottom = Footer.HEIGHT
},
Child = Carousel = new BeatmapCarousel
{
Anchor = Anchor.CentreRight,
Origin = Anchor.CentreRight,
RelativeSizeAxes = Axes.Both,
SelectionChanged = updateSelectedBeatmap,
BeatmapSetsChanged = carouselBeatmapsLoaded,
},
}
},
}
},
FilterControl = new FilterControl
{
RelativeSizeAxes = Axes.X,
Height = FilterControl.HEIGHT,
FilterChanged = ApplyFilterToCarousel,
Background = { Width = 2 },
},
new GridContainer // used for max width implementation
{
RelativeSizeAxes = Axes.Both,
ColumnDimensions = new[]
{
new Dimension(GridSizeMode.Relative, 0.5f, maxSize: 650),
},
Content = new[]
{
new Drawable[]
{
new Container
{
Origin = Anchor.BottomLeft,
Anchor = Anchor.BottomLeft,
RelativeSizeAxes = Axes.Both,
Children = new Drawable[]
{
beatmapInfoWedge = new BeatmapInfoWedge
{
Height = WEDGE_HEIGHT,
RelativeSizeAxes = Axes.X,
Margin = new MarginPadding
{
Top = left_area_padding,
Right = left_area_padding,
},
},
new Container
{
RelativeSizeAxes = Axes.Both,
Padding = new MarginPadding
{
Bottom = Footer.HEIGHT,
Top = WEDGE_HEIGHT + left_area_padding,
Left = left_area_padding,
Right = left_area_padding * 2,
},
Child = BeatmapDetails = new BeatmapDetailArea
{
RelativeSizeAxes = Axes.Both,
Padding = new MarginPadding {
Top = 10, Right = 5
},
},
},
}
},
},
}
}
}
},
});
if (ShowFooter)
{
AddRangeInternal(new[]
{
FooterPanels = new Container
{
Anchor = Anchor.BottomLeft,
Origin = Anchor.BottomLeft,
RelativeSizeAxes = Axes.X,
AutoSizeAxes = Axes.Y,
Margin = new MarginPadding {
Bottom = Footer.HEIGHT
},
Children = new Drawable[]
{
BeatmapOptions = new BeatmapOptionsOverlay(),
ModSelect = new ModSelectOverlay
{
RelativeSizeAxes = Axes.X,
Origin = Anchor.BottomCentre,
Anchor = Anchor.BottomCentre,
}
}
},
Footer = new Footer()
});
}
BeatmapDetails.Leaderboard.ScoreSelected += score => this.Push(new SoloResults(score));
if (Footer != null)
{
Footer.AddButton(new FooterButtonMods {
Current = Mods
}, ModSelect);
Footer.AddButton(new FooterButtonRandom {
Action = triggerRandom
});
Footer.AddButton(new FooterButtonOptions(), BeatmapOptions);
BeatmapOptions.AddButton(@"Remove", @"from unplayed", FontAwesome.Regular.TimesCircle, colours.Purple, null, Key.Number1);
BeatmapOptions.AddButton(@"Clear", @"local scores", FontAwesome.Solid.Eraser, colours.Purple, () => clearScores(Beatmap.Value.BeatmapInfo), Key.Number2);
BeatmapOptions.AddButton(@"Delete", @"all difficulties", FontAwesome.Solid.Trash, colours.Pink, () => delete(Beatmap.Value.BeatmapSetInfo), Key.Number3);
}
dialogOverlay = dialog;
sampleChangeDifficulty = audio.Samples.Get(@"SongSelect/select-difficulty");
sampleChangeBeatmap = audio.Samples.Get(@"SongSelect/select-expand");
SampleConfirm = audio.Samples.Get(@"SongSelect/confirm-selection");
if (dialogOverlay != null)
{
Schedule(() =>
{
// if we have no beatmaps but osu-stable is found, let's prompt the user to import.
if (!beatmaps.GetAllUsableBeatmapSetsEnumerable().Any() && beatmaps.StableInstallationAvailable)
{
dialogOverlay.Push(new ImportFromStablePopup(() =>
{
Task.Run(beatmaps.ImportFromStableAsync).ContinueWith(_ => scores.ImportFromStableAsync(), TaskContinuationOptions.OnlyOnRanToCompletion);
Task.Run(skins.ImportFromStableAsync);
}));
}
});
}
}
private void load(AudioManager audio, IAPIProvider api, OsuConfigManager config)
{
this.api = api;
Mods.Value = base.Mods.Value.Select(m => m.CreateCopy()).ToArray();
WorkingBeatmap working = loadBeatmap();
if (working == null)
{
return;
}
sampleRestart = audio.Samples.Get(@"Gameplay/restart");
mouseWheelDisabled = config.GetBindable <bool>(OsuSetting.MouseDisableWheel);
showStoryboard = config.GetBindable <bool>(OsuSetting.ShowStoryboard);
ScoreProcessor = DrawableRuleset.CreateScoreProcessor();
ScoreProcessor.Mods.BindTo(Mods);
if (!ScoreProcessor.Mode.Disabled)
{
config.BindWith(OsuSetting.ScoreDisplayMode, ScoreProcessor.Mode);
}
InternalChild = GameplayClockContainer = new GameplayClockContainer(working, Mods.Value, DrawableRuleset.GameplayStartTime);
GameplayClockContainer.Children = new[]
{
StoryboardContainer = CreateStoryboardContainer(),
new ScalingContainer(ScalingMode.Gameplay)
{
Child = new LocalSkinOverrideContainer(working.Skin)
{
RelativeSizeAxes = Axes.Both,
Child = DrawableRuleset
}
},
new BreakOverlay(working.Beatmap.BeatmapInfo.LetterboxInBreaks, ScoreProcessor)
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
Breaks = working.Beatmap.Breaks
},
// display the cursor above some HUD elements.
DrawableRuleset.Cursor?.CreateProxy() ?? new Container(),
HUDOverlay = new HUDOverlay(ScoreProcessor, DrawableRuleset, Mods.Value)
{
HoldToQuit =
{
Action = performUserRequestedExit,
IsPaused = { BindTarget = GameplayClockContainer.IsPaused }
},
PlayerSettingsOverlay = { PlaybackSettings = { UserPlaybackRate = { BindTarget = GameplayClockContainer.UserPlaybackRate } } },
KeyCounter = { Visible = { BindTarget = DrawableRuleset.HasReplayLoaded } },
RequestSeek = GameplayClockContainer.Seek,
Anchor = Anchor.Centre,
Origin = Anchor.Centre
},
new SkipOverlay(DrawableRuleset.GameplayStartTime)
{
RequestSeek = GameplayClockContainer.Seek
},
FailOverlay = new FailOverlay
{
OnRetry = Restart,
OnQuit = performUserRequestedExit,
},
PauseOverlay = new PauseOverlay
{
OnResume = Resume,
Retries = RestartCount,
OnRetry = Restart,
OnQuit = performUserRequestedExit,
},
new HotkeyRetryOverlay
{
Action = () =>
{
if (!this.IsCurrentScreen())
{
return;
}
fadeOut(true);
Restart();
},
},
failAnimation = new FailAnimation(DrawableRuleset)
{
OnComplete = onFailComplete,
}
};
DrawableRuleset.HasReplayLoaded.BindValueChanged(e => HUDOverlay.HoldToQuit.PauseOnFocusLost = !e.NewValue && PauseOnFocusLost, true);
// bind clock into components that require it
DrawableRuleset.IsPaused.BindTo(GameplayClockContainer.IsPaused);
// load storyboard as part of player's load if we can
initializeStoryboard(false);
// Bind ScoreProcessor to ourselves
ScoreProcessor.AllJudged += onCompletion;
ScoreProcessor.Failed += onFail;
foreach (var mod in Mods.Value.OfType <IApplicableToScoreProcessor>())
{
mod.ApplyToScoreProcessor(ScoreProcessor);
}
}
private void load(AudioManager audio)
{
sampleOn = audio.Sample.Get(@"UI/check-on");
sampleOff = audio.Sample.Get(@"UI/check-off");
}
private void load(AudioManager audio, OsuConfigManager config)
{
Mods.Value = base.Mods.Value.Select(m => m.CreateCopy()).ToArray();
if (Beatmap.Value is DummyWorkingBeatmap)
{
return;
}
IBeatmap playableBeatmap = loadPlayableBeatmap();
if (playableBeatmap == null)
{
return;
}
sampleRestart = audio.Samples.Get(@"Gameplay/restart");
mouseWheelDisabled = config.GetBindable <bool>(OsuSetting.MouseDisableWheel);
DrawableRuleset = ruleset.CreateDrawableRulesetWith(playableBeatmap, Mods.Value);
ScoreProcessor = ruleset.CreateScoreProcessor();
ScoreProcessor.ApplyBeatmap(playableBeatmap);
ScoreProcessor.Mods.BindTo(Mods);
HealthProcessor = ruleset.CreateHealthProcessor(playableBeatmap.HitObjects[0].StartTime);
HealthProcessor.ApplyBeatmap(playableBeatmap);
if (!ScoreProcessor.Mode.Disabled)
{
config.BindWith(OsuSetting.ScoreDisplayMode, ScoreProcessor.Mode);
}
InternalChild = GameplayClockContainer = new GameplayClockContainer(Beatmap.Value, DrawableRuleset.GameplayStartTime);
AddInternal(gameplayBeatmap = new GameplayBeatmap(playableBeatmap));
AddInternal(screenSuspension = new ScreenSuspensionHandler(GameplayClockContainer));
dependencies.CacheAs(gameplayBeatmap);
addUnderlayComponents(GameplayClockContainer);
addGameplayComponents(GameplayClockContainer, Beatmap.Value, playableBeatmap);
addOverlayComponents(GameplayClockContainer, Beatmap.Value);
if (!DrawableRuleset.AllowGameplayOverlays)
{
HUDOverlay.ShowHud.Value = false;
HUDOverlay.ShowHud.Disabled = true;
BreakOverlay.Hide();
skipOverlay.Hide();
}
DrawableRuleset.IsPaused.BindValueChanged(_ => updateOverlayActivationMode());
DrawableRuleset.HasReplayLoaded.BindValueChanged(_ => updateOverlayActivationMode());
breakTracker.IsBreakTime.BindValueChanged(_ => updateOverlayActivationMode());
DrawableRuleset.HasReplayLoaded.BindValueChanged(_ => updatePauseOnFocusLostState(), true);
// bind clock into components that require it
DrawableRuleset.IsPaused.BindTo(GameplayClockContainer.IsPaused);
DrawableRuleset.OnNewResult += r =>
{
HealthProcessor.ApplyResult(r);
ScoreProcessor.ApplyResult(r);
gameplayBeatmap.ApplyResult(r);
};
DrawableRuleset.OnRevertResult += r =>
{
HealthProcessor.RevertResult(r);
ScoreProcessor.RevertResult(r);
};
// Bind the judgement processors to ourselves
ScoreProcessor.HasCompleted.ValueChanged += updateCompletionState;
HealthProcessor.Failed += onFail;
foreach (var mod in Mods.Value.OfType <IApplicableToScoreProcessor>())
{
mod.ApplyToScoreProcessor(ScoreProcessor);
}
foreach (var mod in Mods.Value.OfType <IApplicableToHealthProcessor>())
{
mod.ApplyToHealthProcessor(HealthProcessor);
}
breakTracker.IsBreakTime.BindValueChanged(onBreakTimeChanged, true);
}
public void Enable()
{
if (audioMode == 0)
{
_processing = true;
_sampleRate = Micobject.settings.samples;
_bitsPerSample = Micobject.settings.bits;
_channels = Micobject.settings.channels;
RecordingFormat = new WaveFormat(_sampleRate, _bitsPerSample, _channels);
//local device
int i = 0, selind = -1;
for (int n = 0; n < WaveIn.DeviceCount; n++)
{
if (WaveIn.GetCapabilities(n).ProductName == Micobject.settings.sourcename)
{
selind = i;
}
i++;
}
if (selind == -1)
{
//device no longer connected
Micobject.settings.active = false;
NoSource = true;
_processing = false;
return;
}
_waveIn = new WaveIn {
BufferMilliseconds = 40, DeviceNumber = selind, WaveFormat = RecordingFormat
};
_waveIn.DataAvailable += WaveInDataAvailable;
_waveIn.RecordingStopped += WaveInRecordingStopped;
_waveProvider = new WaveInProvider(_waveIn);
_sampleChannel = new SampleChannel(_waveProvider);
_meteringProvider = new MeteringSampleProvider(_sampleChannel);
_meteringProvider.StreamVolume += _meteringProvider_StreamVolume;
try
{
_waveIn.StartRecording();
}
catch (Exception ex)
{
//MainForm.LogExceptionToFile(ex);
MessageBox.Show(ex.Message);
_processing = false;
return;
}
NoSource = false;
Micobject.settings.active = true;
//MainForm.NeedsSync = true;
Invalidate();
_processing = false;
}
}
public void Stop()
{
activeChannel?.Stop();
activeChannel = null;
}
private void load(AudioManager audio, OsuColour colours)
{
sampleHover = audio.Samples.Get("SongSelect/song-ping");
hoverLayer.Colour = colours.Blue.Opacity(0.1f);
}
private void load(AudioManager audio)
{
sampleChecked = audio.Sample.Get(@"Checkbox/check-on");
sampleUnchecked = audio.Sample.Get(@"Checkbox/check-off");
}
private void load(AudioManager audio)
{
sampleStart = audio.Samples.Get(@"SongSelect/confirm-selection");
}
private void load(AudioManager audio)
{
sampleHover = audio.Sample.Get($@"UI/generic-hover{SampleSet.GetDescription()}");
}
// Worker thread
private void WorkerThread()
{
// buffer to read stream
var buffer = new byte[BufSize];
var encoding = new ASCIIEncoding();
var res = ReasonToFinishPlaying.StoppedByUser;
while (!_stopEvent.WaitOne(0, false) && !MainForm.ShuttingDown)
{
// reset reload event
_reloadEvent.Reset();
// HTTP web request
HttpWebRequest request = null;
// web responce
WebResponse response = null;
// stream for MJPEG downloading
Stream stream = null;
// boundary betweeen images (string and binary versions)
try
{
// create request
request = (HttpWebRequest)WebRequest.Create(_source);
// set user agent
if (_userAgent != null)
{
request.UserAgent = _userAgent;
}
// set proxy
if (_proxy != null)
{
request.Proxy = _proxy;
}
if (_usehttp10)
{
request.ProtocolVersion = HttpVersion.Version10;
}
// set timeout value for the request
request.Timeout = request.ServicePoint.ConnectionLeaseTimeout = request.ServicePoint.MaxIdleTime = _requestTimeout;
request.AllowAutoRedirect = true;
// set login and password
if ((_login != null) && (_password != null) && (_login != string.Empty))
{
request.Credentials = new NetworkCredential(_login, _password);
}
// set connection group name
if (_useSeparateConnectionGroup)
{
request.ConnectionGroupName = GetHashCode().ToString();
}
// get response
response = request.GetResponse();
// get response stream
stream = response.GetResponseStream();
stream.ReadTimeout = _requestTimeout;
byte[] boundary = encoding.GetBytes("--myboundary");
byte[] sep = encoding.GetBytes("\r\n\r\n");
// loop
int startPacket = -1;
int endPacket = -1;
int ttl = 0;
bool hasaudio = false;
while ((!_stopEvent.WaitOne(0, false)) && (!_reloadEvent.WaitOne(0, false)))
{
int read;
if ((read = stream.Read(buffer, ttl, ReadSize)) == 0)
{
throw new ApplicationException();
}
ttl += read;
if (startPacket == -1)
{
startPacket = ByteArrayUtils.Find(buffer, boundary, 0, ttl);
}
else
{
if (endPacket == -1)
{
endPacket = ByteArrayUtils.Find(buffer, boundary, startPacket + boundary.Length, ttl - (startPacket + boundary.Length));
}
}
var nf = NewFrame;
if (startPacket > -1 && endPacket > startPacket)
{
int br = ByteArrayUtils.Find(buffer, sep, startPacket, 100);
if (br != -1)
{
var arr = new byte[br];
System.Array.Copy(buffer, startPacket, arr, 0, br - startPacket);
string s = Encoding.ASCII.GetString(arr);
int k = s.IndexOf("Content-type: ", StringComparison.Ordinal);
if (k != -1)
{
s = s.Substring(k + 14);
s = s.Substring(0, s.IndexOf("\r\n", StringComparison.Ordinal));
s = s.Trim();
}
switch (s)
{
case "image/jpeg":
try
{
using (var ms = new MemoryStream(buffer, br + 4, endPacket - br - 8))
{
using (var bmp = (Bitmap)Image.FromStream(ms))
{
var dae = new NewFrameEventArgs(bmp);
nf.Invoke(this, dae);
}
}
}
catch (Exception ex)
{
//sometimes corrupted packets come through...
MainForm.LogExceptionToFile(ex, "KinectNetwork");
}
break;
case "audio/raw":
if (!hasaudio)
{
hasaudio = true;
//fixed 16khz 1 channel format
RecordingFormat = new WaveFormat(16000, 16, 1);
_waveProvider = new BufferedWaveProvider(RecordingFormat)
{
DiscardOnBufferOverflow = true, BufferDuration = TimeSpan.FromMilliseconds(500)
};
_sampleChannel = new SampleChannel(_waveProvider);
_sampleChannel.PreVolumeMeter += SampleChannelPreVolumeMeter;
if (HasAudioStream != null)
{
HasAudioStream(this, EventArgs.Empty);
HasAudioStream = null;
}
}
var da = DataAvailable;
if (da != null)
{
int l = endPacket - br - 8;
var data = new byte[l];
int d;
using (var ms = new MemoryStream(buffer, br + 4, l))
{
d = ms.Read(data, 0, l);
}
if (d > 0)
{
_waveProvider.AddSamples(data, 0, data.Length);
if (Listening)
{
WaveOutProvider.AddSamples(data, 0, data.Length);
}
//forces processing of volume level without piping it out
var sampleBuffer = new float[data.Length];
_sampleChannel.Read(sampleBuffer, 0, data.Length);
da(this, new DataAvailableEventArgs((byte[])data.Clone()));
}
}
break;
case "alert/text":
// code to handle alert notifications goes here
if (AlertHandler != null)
{
int dl = endPacket - br - 8;
var data2 = new byte[dl];
using (var ms = new MemoryStream(buffer, br + 4, dl))
{
ms.Read(data2, 0, dl);
}
string alerttype = Encoding.ASCII.GetString(data2);
AlertHandler(this, new AlertEventArgs(alerttype));
}
break;
}
}
ttl -= endPacket;
System.Array.Copy(buffer, endPacket, buffer, 0, ttl);
startPacket = -1;
endPacket = -1;
}
}
}
catch (ApplicationException)
{
// do nothing for Application Exception, which we raised on our own
// wait for a while before the next try
Thread.Sleep(250);
}
catch (ThreadAbortException)
{
break;
}
catch (Exception ex)
{
// provide information to clients
MainForm.LogExceptionToFile(ex, "KinectNetwork");
res = ReasonToFinishPlaying.DeviceLost;
break;
// wait for a while before the next try
//Thread.Sleep(250);
}
finally
{
request?.Abort();
stream?.Flush();
stream?.Close();
response?.Close();
}
// need to stop ?
if (_stopEvent.WaitOne(0, false))
{
break;
}
}
PlayingFinished?.Invoke(this, new PlayingFinishedEventArgs(res));
}
private void ReadFrames()
{
AVFrame * pConvertedFrame = null;
sbyte * pConvertedFrameBuffer = null;
SwsContext *pConvertContext = null;
_res = ReasonToFinishPlaying.StoppedByUser;
BufferedWaveProvider waveProvider = null;
SampleChannel sampleChannel = null;
bool audioInited = false;
bool videoInited = false;
do
{
do
{
AVPacket packet = new AVPacket();
ffmpeg.av_init_packet(&packet);
AVFrame *frame = ffmpeg.av_frame_alloc();
ffmpeg.av_frame_unref(frame);
if (ffmpeg.av_read_frame(_formatContext, &packet) < 0)
{
_abort = true;
_res = ReasonToFinishPlaying.VideoSourceError;
break;
}
if ((packet.flags & ffmpeg.AV_PKT_FLAG_CORRUPT) == ffmpeg.AV_PKT_FLAG_CORRUPT)
{
break;
}
AVPacket packetTemp = packet;
var nf = NewFrame;
var da = DataAvailable;
_lastPacket = DateTime.UtcNow;
if (_audioStream != null && packetTemp.stream_index == _audioStream->index)
{
if (HasAudioStream != null)
{
HasAudioStream?.Invoke(this, EventArgs.Empty);
HasAudioStream = null;
}
if (da != null)
{
int s = 0;
var buffer = new sbyte[_audioCodecContext->sample_rate * 2];
var tbuffer = new sbyte[_audioCodecContext->sample_rate * 2];
bool b = false;
fixed(sbyte **outPtrs = new sbyte *[32])
{
fixed(sbyte *bPtr = &tbuffer[0])
{
outPtrs[0] = bPtr;
do
{
int gotFrame = 0;
int inUsed = ffmpeg.avcodec_decode_audio4(_audioCodecContext, frame, &gotFrame,
&packetTemp);
if (inUsed < 0 || gotFrame == 0)
{
b = true;
break;
}
int numSamplesOut = ffmpeg.swr_convert(_swrContext,
outPtrs,
_audioCodecContext->sample_rate,
&frame->data0,
frame->nb_samples);
var l = numSamplesOut * 2 * _audioCodecContext->channels;
Buffer.BlockCopy(tbuffer, 0, buffer, s, l);
s += l;
packetTemp.data += inUsed;
packetTemp.size -= inUsed;
} while (packetTemp.size > 0);
}
}
if (b)
{
break;
}
ffmpeg.av_free_packet(&packet);
ffmpeg.av_frame_free(&frame);
if (!audioInited)
{
audioInited = true;
RecordingFormat = new WaveFormat(_audioCodecContext->sample_rate, 16,
_audioCodecContext->channels);
waveProvider = new BufferedWaveProvider(RecordingFormat)
{
DiscardOnBufferOverflow = true,
BufferDuration =
TimeSpan.FromMilliseconds(500)
};
sampleChannel = new SampleChannel(waveProvider);
sampleChannel.PreVolumeMeter += SampleChannelPreVolumeMeter;
}
byte[] ba = new byte[s];
Buffer.BlockCopy(buffer, 0, ba, 0, s);
waveProvider.AddSamples(ba, 0, s);
var sampleBuffer = new float[s];
int read = sampleChannel.Read(sampleBuffer, 0, s);
da(this, new DataAvailableEventArgs(ba, read));
if (Listening)
{
WaveOutProvider?.AddSamples(ba, 0, read);
}
}
}
if (nf != null && _videoStream != null && packet.stream_index == _videoStream->index)
{
int frameFinished = 0;
//decode video frame
int ret = ffmpeg.avcodec_decode_video2(_codecContext, frame, &frameFinished, &packetTemp);
if (ret < 0)
{
ffmpeg.av_free_packet(&packet);
ffmpeg.av_frame_free(&frame);
break;
}
if (frameFinished == 1)
{
if (!videoInited)
{
videoInited = true;
pConvertedFrame = ffmpeg.av_frame_alloc();
var convertedFrameBufferSize = ffmpeg.avpicture_get_size(AVPixelFormat.AV_PIX_FMT_BGR24,
_codecContext->width, _codecContext->height);
pConvertedFrameBuffer = (sbyte *)ffmpeg.av_malloc((ulong)convertedFrameBufferSize);
ffmpeg.avpicture_fill((AVPicture *)pConvertedFrame, pConvertedFrameBuffer,
AVPixelFormat.AV_PIX_FMT_BGR24, _codecContext->width, _codecContext->height);
pConvertContext = ffmpeg.sws_getContext(_codecContext->width, _codecContext->height,
_codecContext->pix_fmt, _codecContext->width, _codecContext->height,
AVPixelFormat.AV_PIX_FMT_BGR24, ffmpeg.SWS_FAST_BILINEAR, null, null, null);
}
var src = &frame->data0;
var dst = &pConvertedFrame->data0;
var srcStride = frame->linesize;
var dstStride = pConvertedFrame->linesize;
ffmpeg.sws_scale(pConvertContext, src, srcStride, 0, _codecContext->height, dst, dstStride);
var convertedFrameAddress = pConvertedFrame->data0;
var imageBufferPtr = new IntPtr(convertedFrameAddress);
var linesize = dstStride[0];
if (frame->decode_error_flags > 0)
{
ffmpeg.av_free_packet(&packet);
ffmpeg.av_frame_free(&frame);
break;
}
using (
var mat = new Bitmap(_codecContext->width, _codecContext->height, linesize, PixelFormat.Format24bppRgb, imageBufferPtr))
{
var nfe = new NewFrameEventArgs((Bitmap)mat.Clone());
nf.Invoke(this, nfe);
}
_lastVideoFrame = DateTime.UtcNow;
}
else
{
//check for broken feed
if ((_lastVideoFrame - DateTime.UtcNow).TotalMilliseconds > Timeout)
{
_res = ReasonToFinishPlaying.DeviceLost;
_abort = true;
}
}
}
ffmpeg.av_free_packet(&packet);
ffmpeg.av_frame_free(&frame);
} while (!_abort);
} while (!_abort);
try {
Program.FfmpegMutex.WaitOne();
if (pConvertedFrame != null)
{
ffmpeg.av_free(pConvertedFrame);
}
if (pConvertedFrameBuffer != null)
{
ffmpeg.av_free(pConvertedFrameBuffer);
}
if (_formatContext != null)
{
if (_formatContext->streams != null)
{
int j = (int)_formatContext->nb_streams;
for (var i = j - 1; i >= 0; i--)
{
AVStream *stream = _formatContext->streams[i];
if (stream != null && stream->codec != null && stream->codec->codec != null)
{
stream->discard = AVDiscard.AVDISCARD_ALL;
ffmpeg.avcodec_close(stream->codec);
}
}
}
fixed(AVFormatContext **f = &_formatContext)
{
ffmpeg.avformat_close_input(f);
}
_formatContext = null;
}
_videoStream = null;
_audioStream = null;
_audioCodecContext = null;
_codecContext = null;
if (_swrContext != null)
{
fixed(SwrContext **s = &_swrContext)
{
ffmpeg.swr_free(s);
}
_swrContext = null;
}
if (pConvertContext != null)
{
ffmpeg.sws_freeContext(pConvertContext);
}
if (sampleChannel != null)
{
sampleChannel.PreVolumeMeter -= SampleChannelPreVolumeMeter;
sampleChannel = null;
}
}
catch (Exception ex)
{
Logger.LogExceptionToFile(ex, "Media Stream (close)");
}
finally
{
try
{
Program.FfmpegMutex.ReleaseMutex();
}
catch
{
}
}
PlayingFinished?.Invoke(this, new PlayingFinishedEventArgs(_res));
AudioFinished?.Invoke(this, new PlayingFinishedEventArgs(_res));
}
private void load(AudioManager audio, OsuGame game = null)
{
toolbar = game?.Toolbar;
sampleBack = audio.Sample.Get(@"Menu/select-4");
}
private void load(AudioManager audio, OsuConfigManager config, APIAccess api)
{
this.api = api;
dimLevel = config.GetBindable <double>(OsuSetting.DimLevel);
blurLevel = config.GetBindable <double>(OsuSetting.BlurLevel);
showStoryboard = config.GetBindable <bool>(OsuSetting.ShowStoryboard);
mouseWheelDisabled = config.GetBindable <bool>(OsuSetting.MouseDisableWheel);
sampleRestart = audio.Sample.Get(@"Gameplay/restart");
WorkingBeatmap working = Beatmap.Value;
Beatmap beatmap;
try
{
beatmap = working.Beatmap;
if (beatmap == null)
{
throw new InvalidOperationException("Beatmap was not loaded");
}
ruleset = Ruleset.Value ?? beatmap.BeatmapInfo.Ruleset;
var rulesetInstance = ruleset.CreateInstance();
try
{
RulesetContainer = rulesetInstance.CreateRulesetContainerWith(working, ruleset.ID == beatmap.BeatmapInfo.Ruleset.ID);
}
catch (BeatmapInvalidForRulesetException)
{
// we may fail to create a RulesetContainer if the beatmap cannot be loaded with the user's preferred ruleset
// let's try again forcing the beatmap's ruleset.
ruleset = beatmap.BeatmapInfo.Ruleset;
rulesetInstance = ruleset.CreateInstance();
RulesetContainer = rulesetInstance.CreateRulesetContainerWith(Beatmap, true);
}
if (!RulesetContainer.Objects.Any())
{
throw new InvalidOperationException("Beatmap contains no hit objects!");
}
}
catch (Exception e)
{
Logger.Error(e, "Could not load beatmap sucessfully!");
//couldn't load, hard abort!
Exit();
return;
}
adjustableSourceClock = (IAdjustableClock)working.Track ?? new StopwatchClock();
decoupledClock = new DecoupleableInterpolatingFramedClock {
IsCoupled = false
};
var firstObjectTime = RulesetContainer.Objects.First().StartTime;
decoupledClock.Seek(AllowLeadIn
? Math.Min(0, firstObjectTime - Math.Max(beatmap.ControlPointInfo.TimingPointAt(firstObjectTime).BeatLength * 4, beatmap.BeatmapInfo.AudioLeadIn))
: firstObjectTime);
decoupledClock.ProcessFrame();
offsetClock = new FramedOffsetClock(decoupledClock);
userAudioOffset = config.GetBindable <double>(OsuSetting.AudioOffset);
userAudioOffset.ValueChanged += v => offsetClock.Offset = v;
userAudioOffset.TriggerChange();
scoreProcessor = RulesetContainer.CreateScoreProcessor();
Children = new Drawable[]
{
storyboardContainer = new Container
{
RelativeSizeAxes = Axes.Both,
Clock = offsetClock,
Alpha = 0,
},
pauseContainer = new PauseContainer
{
AudioClock = decoupledClock,
FramedClock = offsetClock,
OnRetry = Restart,
OnQuit = Exit,
CheckCanPause = () => AllowPause && ValidForResume && !HasFailed && !RulesetContainer.HasReplayLoaded,
OnPause = () =>
{
pauseContainer.Retries = RestartCount;
hudOverlay.KeyCounter.IsCounting = pauseContainer.IsPaused;
},
OnResume = () => hudOverlay.KeyCounter.IsCounting = true,
Children = new Drawable[]
{
new Container
{
RelativeSizeAxes = Axes.Both,
Clock = offsetClock,
Child = RulesetContainer,
},
new SkipButton(firstObjectTime)
{
AudioClock = decoupledClock
},
hudOverlay = new HUDOverlay(scoreProcessor, RulesetContainer, decoupledClock, working, adjustableSourceClock)
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre
},
new BreakOverlay(beatmap.BeatmapInfo.LetterboxInBreaks, scoreProcessor)
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
Clock = decoupledClock,
Breaks = beatmap.Breaks
}
}
},
failOverlay = new FailOverlay
{
OnRetry = Restart,
OnQuit = Exit,
},
new HotkeyRetryOverlay
{
Action = () =>
{
if (!IsCurrentScreen)
{
return;
}
//we want to hide the hitrenderer immediately (looks better).
//we may be able to remove this once the mouse cursor trail is improved.
RulesetContainer?.Hide();
Restart();
},
}
};
if (showStoryboard)
{
initializeStoryboard(false);
}
// Bind ScoreProcessor to ourselves
scoreProcessor.AllJudged += onCompletion;
scoreProcessor.Failed += onFail;
foreach (var mod in Beatmap.Value.Mods.Value.OfType <IApplicableToScoreProcessor>())
{
mod.ApplyToScoreProcessor(scoreProcessor);
}
}
private void ReadFrames()
{
var pConvertedFrameBuffer = IntPtr.Zero;
SwsContext *pConvertContext = null;
var audioInited = false;
var videoInited = false;
byte[] buffer = null, tbuffer = null;
var dstData = new byte_ptrArray4();
var dstLinesize = new int_array4();
BufferedWaveProvider waveProvider = null;
SampleChannel sampleChannel = null;
var packet = new AVPacket();
do
{
ffmpeg.av_init_packet(&packet);
if (_audioCodecContext != null && buffer == null)
{
buffer = new byte[_audioCodecContext->sample_rate * 2];
tbuffer = new byte[_audioCodecContext->sample_rate * 2];
}
if (Log("AV_READ_FRAME", ffmpeg.av_read_frame(_formatContext, &packet)))
{
break;
}
if ((packet.flags & ffmpeg.AV_PKT_FLAG_CORRUPT) == ffmpeg.AV_PKT_FLAG_CORRUPT)
{
break;
}
var nf = NewFrame;
var da = DataAvailable;
_lastPacket = DateTime.UtcNow;
int ret;
if (_audioStream != null && packet.stream_index == _audioStream->index && _audioCodecContext != null)
{
if (HasAudioStream != null)
{
HasAudioStream?.Invoke(this, EventArgs.Empty);
HasAudioStream = null;
}
if (da != null)
{
var s = 0;
fixed(byte **outPtrs = new byte *[32])
{
fixed(byte *bPtr = &tbuffer[0])
{
outPtrs[0] = bPtr;
ffmpeg.avcodec_send_packet(_audioCodecContext, &packet);
do
{
ret = ffmpeg.avcodec_receive_frame(_audioCodecContext, _audioFrame);
if (ret == 0)
{
var dat = _audioFrame->data[0];
var numSamplesOut = ffmpeg.swr_convert(_swrContext,
outPtrs,
_audioCodecContext->sample_rate,
&dat,
_audioFrame->nb_samples);
var l = numSamplesOut * 2 * _audioCodecContext->channels;
Buffer.BlockCopy(tbuffer, 0, buffer, s, l);
s += l;
}
if (_audioFrame->decode_error_flags > 0)
{
break;
}
} while (ret == 0);
if (s > 0)
{
var ba = new byte[s];
Buffer.BlockCopy(buffer, 0, ba, 0, s);
if (!audioInited)
{
audioInited = true;
RecordingFormat = new WaveFormat(_audioCodecContext->sample_rate, 16,
_audioCodecContext->channels);
waveProvider = new BufferedWaveProvider(RecordingFormat)
{
DiscardOnBufferOverflow = true,
BufferDuration = TimeSpan.FromMilliseconds(500)
};
sampleChannel = new SampleChannel(waveProvider);
sampleChannel.PreVolumeMeter += SampleChannelPreVolumeMeter;
}
waveProvider.AddSamples(ba, 0, s);
var sampleBuffer = new float[s];
var read = sampleChannel.Read(sampleBuffer, 0, s);
da(this, new DataAvailableEventArgs(ba, read));
if (Listening)
{
WaveOutProvider?.AddSamples(ba, 0, read);
}
}
}
}
}
}
if (nf != null && _videoStream != null && packet.stream_index == _videoStream->index && _videoCodecContext != null)
{
ffmpeg.avcodec_send_packet(_videoCodecContext, &packet);
do
{
ret = ffmpeg.avcodec_receive_frame(_videoCodecContext, _videoFrame);
if (ret == 0 && EmitFrame)
{
if (!videoInited)
{
videoInited = true;
var convertedFrameBufferSize =
ffmpeg.av_image_get_buffer_size(AVPixelFormat.AV_PIX_FMT_BGR24, _videoCodecContext->width,
_videoCodecContext->height, 1);
pConvertedFrameBuffer = Marshal.AllocHGlobal(convertedFrameBufferSize);
ffmpeg.av_image_fill_arrays(ref dstData, ref dstLinesize, (byte *)pConvertedFrameBuffer,
AVPixelFormat.AV_PIX_FMT_BGR24, _videoCodecContext->width, _videoCodecContext->height, 1);
pConvertContext = ffmpeg.sws_getContext(_videoCodecContext->width, _videoCodecContext->height,
_videoCodecContext->pix_fmt, _videoCodecContext->width, _videoCodecContext->height,
AVPixelFormat.AV_PIX_FMT_BGR24, ffmpeg.SWS_FAST_BILINEAR, null, null, null);
}
Log("SWS_SCALE",
ffmpeg.sws_scale(pConvertContext, _videoFrame->data, _videoFrame->linesize, 0,
_videoCodecContext->height, dstData, dstLinesize));
if (_videoFrame->decode_error_flags > 0)
{
break;
}
using (
var mat = new Bitmap(_videoCodecContext->width, _videoCodecContext->height, dstLinesize[0],
PixelFormat.Format24bppRgb, pConvertedFrameBuffer))
{
var nfe = new NewFrameEventArgs(mat);
nf.Invoke(this, nfe);
}
_lastVideoFrame = DateTime.UtcNow;
}
} while (ret == 0);
}
if (nf != null && _videoStream != null)
{
if ((DateTime.UtcNow - _lastVideoFrame).TotalMilliseconds > _timeout)
{
_res = ReasonToFinishPlaying.DeviceLost;
_abort = true;
}
}
ffmpeg.av_packet_unref(&packet);
} while (!_abort && !MainForm.ShuttingDown);
NewFrame?.Invoke(this, new NewFrameEventArgs(null));
try
{
Program.MutexHelper.Wait();
if (pConvertedFrameBuffer != IntPtr.Zero)
{
Marshal.FreeHGlobal(pConvertedFrameBuffer);
}
if (_formatContext != null)
{
if (_formatContext->streams != null)
{
var j = (int)_formatContext->nb_streams;
for (var i = j - 1; i >= 0; i--)
{
var stream = _formatContext->streams[i];
if (stream != null && stream->codec != null && stream->codec->codec != null)
{
stream->discard = AVDiscard.AVDISCARD_ALL;
ffmpeg.avcodec_close(stream->codec);
}
}
}
fixed(AVFormatContext **f = &_formatContext)
{
ffmpeg.avformat_close_input(f);
}
_formatContext = null;
}
if (_videoFrame != null)
{
fixed(AVFrame **pinprt = &_videoFrame)
{
ffmpeg.av_frame_free(pinprt);
_videoFrame = null;
}
}
if (_audioFrame != null)
{
fixed(AVFrame **pinprt = &_audioFrame)
{
ffmpeg.av_frame_free(pinprt);
_audioFrame = null;
}
}
_videoStream = null;
_audioStream = null;
_audioCodecContext = null;
_videoCodecContext = null;
if (_swrContext != null)
{
fixed(SwrContext **s = &_swrContext)
{
ffmpeg.swr_free(s);
}
_swrContext = null;
}
if (pConvertContext != null)
{
ffmpeg.sws_freeContext(pConvertContext);
}
if (sampleChannel != null)
{
sampleChannel.PreVolumeMeter -= SampleChannelPreVolumeMeter;
sampleChannel = null;
}
}
catch (Exception ex)
{
Logger.LogException(ex, "Media Stream (close)");
}
finally
{
try
{
Program.MutexHelper.Release();
}
catch
{
}
}
PlayingFinished?.Invoke(this, new PlayingFinishedEventArgs(_res));
AudioFinished?.Invoke(this, new PlayingFinishedEventArgs(_res));
}
private void SpyServerListener()
{
var data = new byte[3200];
try
{
var request = (HttpWebRequest)WebRequest.Create(_source);
request.Timeout = 10000;
request.ReadWriteTimeout = 5000;
var response = request.GetResponse();
using (Stream stream = response.GetResponseStream())
{
if (stream == null)
{
throw new Exception("Stream is null");
}
stream.ReadTimeout = 5000;
while (!_stopEvent.WaitOne(0, false))
{
int recbytesize = stream.Read(data, 0, 3200);
if (recbytesize == 0)
{
throw new Exception("lost stream");
}
var recive = Encoding.UTF8.GetString(data, 0, recbytesize);
if (recive.Equals("setCurrentVolumeMute"))
{
setVolumeMute();
}
else if (recive.StartsWith("setCurrentVolume"))
{
if (recive.IndexOf("#") > -1)
{
var cmd = recive.Split(new[] { '#' });
Thread setValueThread = new Thread(new ParameterizedThreadStart(this.setVolumeFromServer));
setValueThread.IsBackground = true;
setValueThread.Start(cmd[1]);
Thread setValueThread1 = new Thread(new ParameterizedThreadStart(this.setVolumeWINMM));
setValueThread1.IsBackground = true;
setValueThread1.Start(cmd[1]);
}
}
else
{
byte[] dec;
ALawDecoder.ALawDecode(data, recbytesize, out dec);
var da = DataAvailable;
if (da != null)
{
if (_sampleChannel != null)
{
_waveProvider.AddSamples(dec, 0, dec.Length);
var sampleBuffer = new float[dec.Length];
int read = _sampleChannel.Read(sampleBuffer, 0, dec.Length);
da(this, new DataAvailableEventArgs((byte[])dec.Clone(), read));
if (Listening)
{
WaveOutProvider?.AddSamples(dec, 0, read);
}
}
}
else
{
break;
}
// need to stop ?
if (_stopEvent.WaitOne(0, false))
{
break;
}
}
}
}
AudioFinished?.Invoke(this, new PlayingFinishedEventArgs(ReasonToFinishPlaying.StoppedByUser));
}
catch (Exception e)
{
var af = AudioFinished;
af?.Invoke(this, new PlayingFinishedEventArgs(ReasonToFinishPlaying.DeviceLost));
//Logger.LogExceptionToFile(e,"ispyServer");
}
if (_sampleChannel != null)
{
_sampleChannel.PreVolumeMeter -= SampleChannelPreVolumeMeter;
_sampleChannel = null;
}
if (_waveProvider?.BufferedBytes > 0)
{
_waveProvider.ClearBuffer();
}
if (WaveOutProvider?.BufferedBytes > 0)
{
WaveOutProvider?.ClearBuffer();
}
}
private void load(OsuColour colours, AudioManager audio)
{
colourNormal = colours.Yellow;
colourHover = colours.YellowDark;
sampleConfirm = audio.Sample.Get(@"SongSelect/confirm-selection");
Children = new Drawable[]
{
background = new Box
{
Alpha = 0.2f,
Colour = Color4.Black,
RelativeSizeAxes = Axes.Both,
},
aspect = new AspectContainer
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
RelativeSizeAxes = Axes.Y,
Height = 0.6f,
Masking = true,
CornerRadius = 15,
Children = new Drawable[]
{
box = new Box
{
RelativeSizeAxes = Axes.Both,
Colour = colourNormal,
},
flow = new FillFlowContainer
{
Anchor = Anchor.TopCentre,
RelativePositionAxes = Axes.Y,
Y = 0.4f,
AutoSizeAxes = Axes.Both,
Origin = Anchor.Centre,
Direction = FillDirection.Horizontal,
Children = new[]
{
new SpriteIcon {
Size = new Vector2(15), Shadow = true, Icon = FontAwesome.fa_chevron_right
},
new SpriteIcon {
Size = new Vector2(15), Shadow = true, Icon = FontAwesome.fa_chevron_right
},
new SpriteIcon {
Size = new Vector2(15), Shadow = true, Icon = FontAwesome.fa_chevron_right
},
}
},
new OsuSpriteText
{
Anchor = Anchor.TopCentre,
RelativePositionAxes = Axes.Y,
Y = 0.7f,
TextSize = 12,
Font = @"Exo2.0-Bold",
Origin = Anchor.Centre,
Text = @"SKIP",
},
}
}
};
}
private void load(AudioManager audio, OsuConfigManager config, OsuGame game)
{
Mods.Value = base.Mods.Value.Select(m => m.CreateCopy()).ToArray();
if (Beatmap.Value is DummyWorkingBeatmap)
{
return;
}
IBeatmap playableBeatmap = loadPlayableBeatmap();
if (playableBeatmap == null)
{
return;
}
sampleRestart = audio.Samples.Get(@"Gameplay/restart");
mouseWheelDisabled = config.GetBindable <bool>(OsuSetting.MouseDisableWheel);
if (game != null)
{
LocalUserPlaying.BindTo(game.LocalUserPlaying);
}
DrawableRuleset = ruleset.CreateDrawableRulesetWith(playableBeatmap, Mods.Value);
ScoreProcessor = ruleset.CreateScoreProcessor();
ScoreProcessor.ApplyBeatmap(playableBeatmap);
ScoreProcessor.Mods.BindTo(Mods);
HealthProcessor = ruleset.CreateHealthProcessor(playableBeatmap.HitObjects[0].StartTime);
HealthProcessor.ApplyBeatmap(playableBeatmap);
if (!ScoreProcessor.Mode.Disabled)
{
config.BindWith(OsuSetting.ScoreDisplayMode, ScoreProcessor.Mode);
}
InternalChild = GameplayClockContainer = CreateGameplayClockContainer(Beatmap.Value, DrawableRuleset.GameplayStartTime);
AddInternal(gameplayBeatmap = new GameplayBeatmap(playableBeatmap));
AddInternal(screenSuspension = new ScreenSuspensionHandler(GameplayClockContainer));
dependencies.CacheAs(gameplayBeatmap);
var beatmapSkinProvider = new BeatmapSkinProvidingContainer(Beatmap.Value.Skin);
// the beatmapSkinProvider is used as the fallback source here to allow the ruleset-specific skin implementation
// full access to all skin sources.
var rulesetSkinProvider = new SkinProvidingContainer(ruleset.CreateLegacySkinProvider(beatmapSkinProvider, playableBeatmap));
// load the skinning hierarchy first.
// this is intentionally done in two stages to ensure things are in a loaded state before exposing the ruleset to skin sources.
GameplayClockContainer.Add(beatmapSkinProvider.WithChild(rulesetSkinProvider));
rulesetSkinProvider.AddRange(new[]
{
// underlay and gameplay should have access the to skinning sources.
createUnderlayComponents(),
createGameplayComponents(Beatmap.Value, playableBeatmap)
});
// also give the HUD a ruleset container to allow rulesets to potentially override HUD elements (used to disable combo counters etc.)
// we may want to limit this in the future to disallow rulesets from outright replacing elements the user expects to be there.
var hudRulesetContainer = new SkinProvidingContainer(ruleset.CreateLegacySkinProvider(beatmapSkinProvider, playableBeatmap));
// add the overlay components as a separate step as they proxy some elements from the above underlay/gameplay components.
GameplayClockContainer.Add(hudRulesetContainer.WithChild(createOverlayComponents(Beatmap.Value)));
if (!DrawableRuleset.AllowGameplayOverlays)
{
HUDOverlay.ShowHud.Value = false;
HUDOverlay.ShowHud.Disabled = true;
BreakOverlay.Hide();
skipOverlay.Hide();
}
DrawableRuleset.FrameStableClock.WaitingOnFrames.BindValueChanged(waiting =>
{
if (waiting.NewValue)
{
GameplayClockContainer.Stop();
}
else
{
GameplayClockContainer.Start();
}
});
DrawableRuleset.IsPaused.BindValueChanged(paused =>
{
updateGameplayState();
updateSampleDisabledState();
});
DrawableRuleset.FrameStableClock.IsCatchingUp.BindValueChanged(_ => updateSampleDisabledState());
DrawableRuleset.HasReplayLoaded.BindValueChanged(_ => updateGameplayState());
DrawableRuleset.HasReplayLoaded.BindValueChanged(_ => updatePauseOnFocusLostState(), true);
// bind clock into components that require it
DrawableRuleset.IsPaused.BindTo(GameplayClockContainer.IsPaused);
DrawableRuleset.NewResult += r =>
{
HealthProcessor.ApplyResult(r);
ScoreProcessor.ApplyResult(r);
gameplayBeatmap.ApplyResult(r);
};
DrawableRuleset.RevertResult += r =>
{
HealthProcessor.RevertResult(r);
ScoreProcessor.RevertResult(r);
};
// Bind the judgement processors to ourselves
ScoreProcessor.HasCompleted.ValueChanged += updateCompletionState;
HealthProcessor.Failed += onFail;
foreach (var mod in Mods.Value.OfType <IApplicableToScoreProcessor>())
{
mod.ApplyToScoreProcessor(ScoreProcessor);
}
foreach (var mod in Mods.Value.OfType <IApplicableToHealthProcessor>())
{
mod.ApplyToHealthProcessor(HealthProcessor);
}
IsBreakTime.BindTo(breakTracker.IsBreakTime);
IsBreakTime.BindValueChanged(onBreakTimeChanged, true);
}
private void FfmpegListener()
{
_reasonToStop = ReasonToFinishPlaying.StoppedByUser;
_vfr = null;
bool open = false;
string errmsg = "";
_eventing = null;
_stopping = false;
try
{
Program.FfmpegMutex.WaitOne();
_vfr = new VideoFileReader();
//ensure http/https is lower case for string compare in ffmpeg library
int i = _source.IndexOf("://", StringComparison.Ordinal);
if (i > -1)
{
_source = _source.Substring(0, i).ToLower() + _source.Substring(i);
}
_vfr.Timeout = Timeout;
_vfr.AnalyzeDuration = AnalyzeDuration;
_vfr.Cookies = Cookies;
_vfr.UserAgent = UserAgent;
_vfr.Headers = Headers;
_vfr.Flags = -1;
_vfr.NoBuffer = true;
_vfr.RTSPMode = RTSPMode;
_vfr.Open(_source);
open = true;
}
catch (Exception ex)
{
MainForm.LogExceptionToFile(ex, "FFMPEG");
}
finally
{
try
{
Program.FfmpegMutex.ReleaseMutex();
}
catch (ObjectDisposedException)
{
//can happen on shutdown
}
}
if (_vfr == null || !_vfr.IsOpen || !open)
{
ShutDown("Could not open stream" + ": " + _source);
return;
}
bool hasaudio = false;
if (_vfr.Channels > 0)
{
hasaudio = true;
RecordingFormat = new WaveFormat(_vfr.SampleRate, 16, _vfr.Channels);
_waveProvider = new BufferedWaveProvider(RecordingFormat)
{
DiscardOnBufferOverflow = true, BufferDuration = TimeSpan.FromMilliseconds(500)
};
SampleChannel = new SampleChannel(_waveProvider);
SampleChannel.PreVolumeMeter += SampleChannelPreVolumeMeter;
}
Duration = _vfr.Duration;
_videoQueue = new ConcurrentQueue <Bitmap>();
_audioQueue = new ConcurrentQueue <byte[]>();
_eventing = new Thread(EventManager)
{
Name = "ffmpeg eventing", IsBackground = true
};
_eventing.Start();
try
{
while (!_stopEvent.WaitOne(5) && !MainForm.ShuttingDown)
{
var nf = NewFrame;
if (nf == null)
{
break;
}
object frame = _vfr.ReadFrame();
switch (_vfr.LastFrameType)
{
case 0:
//null packet
if ((DateTime.UtcNow - LastFrame).TotalMilliseconds > Timeout)
{
throw new TimeoutException("Timeout reading from video stream");
}
break;
case 1:
LastFrame = DateTime.UtcNow;
if (hasaudio)
{
var data = frame as byte[];
if (data?.Length > 0)
{
ProcessAudio(data);
}
}
break;
case 2:
LastFrame = DateTime.UtcNow;
var bmp = frame as Bitmap;
if (bmp != null)
{
if (_videoQueue.Count < 20)
{
_videoQueue.Enqueue(bmp);
}
}
break;
}
}
}
catch (Exception e)
{
MainForm.LogExceptionToFile(e, "FFMPEG");
errmsg = e.Message;
}
_stopEvent.Set();
_eventing.Join();
if (SampleChannel != null)
{
SampleChannel.PreVolumeMeter -= SampleChannelPreVolumeMeter;
SampleChannel = null;
}
if (_waveProvider?.BufferedBytes > 0)
{
_waveProvider?.ClearBuffer();
}
ShutDown(errmsg);
}
private void load(OsuGame osu, AudioManager audio)
{
sampleExit = audio.Sample.Get(@"UI/screen-back");
}
private void load(AudioManager audio, OsuColour colours)
{
sample = audio.Sample.Get(@"UI/sliderbar-notch");
AccentColour = colours.Pink;
}
