Clipchamp

Whether update is already prompted in Windows app. When this is true, the web app should not prompt for update again.

This flag indicates whether the app supports force refresh in AcquireToken flow

A flag indicating whether the sign in screen is shown before entering into the app.

A flag indicating whether the error message should not show on sign in screen.

Deprecated

Allow Serializer to find and register the concrete type for polymorphism deserialization. Only implement this interface when you actually need polymorphism deserialization.

Made public only for tests purposes. DO NOT access underlying strategies in app.

Auto-generated

Owns nothing about what crosses it, so anything built on shared memory can compose on this without going through a transfer.

Cancelling before the window closes means work waiting on the web app fails now rather than staying blocked on a reply that is no longer coming.

DO NOT use this property on any logic. This is to be used in ECS only. The value is copied directly from SPO HTML so the value is unstable and out of our control.

An upscale that failed before it had scalers to work with. It is an upscale failure like any other, because preparing the upscaler is the first thing an upscale does rather than something that happened to it earlier.

What a reason means for the user, and what to offer them in response, is decided by the web app, which ships far more often than this does.

Only is called; the others hold their places in the method table.

Decodes as fast as the machine allows because there is no playback clock to keep up with. Every call must come from the same MTA thread: the reader is an apartment-bound COM object, not a thread-safe service.

How the decoded frames should be read: colour space, range, and the shape of a pixel. Taken from the type the file declares rather than the one decoding produces, because converting to NV12 describes the buffer rather than the source, dropping both what the samples mean and the shape they were meant to have. Copied without being interpreted, so an unrecognised value travels as easily as a known one.

Returns null once the stream ends. A terminal stream error throws instead of returning null, because a truncated video that reports success is worse than one that fails.

Access is read-write because one buffer carries both directions: the web app writes the input into it and reads the output back out of it.

Answers either way, whether or not an upscale was still there to stop. Neither answer proves the upscale received the stop: the first says only that handling returned.

Buffers are reached through the WebView2 that is going away, so they go with it. Work that was using them is stopped first, because a result it finished producing would have nowhere left to go.

Releasing always succeeds. A buffer that is already gone is still reported as released, because the command asks for an end state rather than for an action, and a window that refuses to close is left to process teardown rather than failing the caller.

A buffer is reachable only from the page that asked for it, so a page left behind takes every buffer it held out of reach and no release comes back for them. A navigation the commercial app cancels reloads immediately afterwards, so giving them up early costs nothing it was going to keep.

When true the event is never logged, its dispatch lifecycle is never logged, and it is left out of the generated taxonomy, so a message that crosses the boundary many times a second can still be dispatched without burying everything else in the log.

Cached because this is consulted on every dispatch of every message.

Customly log a message without going through the Dispatcher. NOTE: Typically it is better to dispatch the message instead of only logging it. Please double check if you really need to call this.

The message DO NOT PROVIDE THIS. This will be auto-filled DO NOT PROVIDE THIS. This will be auto-filled DO NOT PROVIDE THIS. This will be auto-filled

Log an astray.

The exception DO NOT PROVIDE THIS. This will be auto-filled DO NOT PROVIDE THIS. This will be auto-filled DO NOT PROVIDE THIS. This will be auto-filled

Log a checkpoint. NOTE: The provided string will not be logged and will instead be discarded.

The description of the checkpoint (will be discarded) DO NOT PROVIDE THIS. This will be auto-filled DO NOT PROVIDE THIS. This will be auto-filled DO NOT PROVIDE THIS. This will be auto-filled

Only the context is recorded; the payload is recorded once, by whoever dispatches the message.

NB: This method is not implemented as AstrayHistory inherits its Scope from IAstray. It should not be updated after set in constructor.

Asking twice, or asking for an upscale that already finished, is not an error: this only starts a cancellation, and the upscale it names is what reports how it ended.

Identifies the upscale to stop, not this request to stop it.

The other half of , so how a stop was handled is recorded either way.

NB: This method is not implemented as LogHistory inherits its Scope from DispatchableContext. It should not be updated after set in constructor.

Fraction from 0 to 1 through this stage, null while the stage cannot say. What a stage is worth against the whole operation is left to the web app, which can rebalance it without a new native build.

Named after what the operation is doing rather than how far along it is, so a stage that takes no time on a given input can be skipped without leaving a gap in the sequence. Every upscale asks for a pool, and the three preparation stages are simply skipped by one handed a pool that is already standing, which is the same thing happening for the same reason. The numbers are the order these occur in. The pool compares them while it reports the preparation it shares, so a later arrival cannot drag the reported position backwards for everyone waiting on it. Nothing compares the stages after preparation, which one upscale reaches on its own. They are written out so that inserting a stage in the middle, or reordering two, cannot be done without it being obvious in the diff.

The same value identifies the request, its shared buffer, and every message that belongs to it, so nothing has to be correlated across two identifiers.

The web app holds the source file, so only it can say how many bytes the transfer must carry.

The reason says which bucket the failure belongs in. It is classified by whatever caught it rather than read back off the exception here, so a message stays a description of what is being sent and does not have to know the exception types the upscaler throws.

What preparing the scaler pool cost. Reported as part of the upscale that needed the pool, because preparing one is the first thing an upscale does rather than a phase of its own.

A fixed set of scalars. Nothing here grows with frame, chunk, or scaler count, and nothing identifies a scaler, a worker, or a file.

Auto-generated

The buffer stays committed for as long as it is open, so nothing larger than this gets a window of its own.

is clamped, so no caller can rely on getting it and every caller must still tolerate being chunked.

The entry is gone before the window is closed, so a window that refuses to close is forgotten rather than kept. The OS reclaims its memory once the web app has released it too, and unconditionally when this process ends.

Closes every open buffer and reports what it closed, so the caller can still announce them. A later buffer can be created again, because the WebView2 that owns them can be torn down and replaced while the app keeps running.

The buffer is a window, not a container: a payload larger than it takes as many exchanges as it needs and one that fits takes a single exchange, and callers cannot tell the two apart.

The encoder writes video alone, so the sound is taken from the source and muxed back in afterwards. Both halves are written again on the way through, so anything the finished file should still declare has to be put on the profile deliberately. Colour is the exception, and it is worth knowing before changing anything here. The render re-decides colour from the output size and ignores what the profile asks for, so a picture that arrives as BT.601 leaves as BT.709 once the output is 720p or larger. The finished file is therefore left declaring no colour at all, and that omission is what keeps it correct: readers fall back to the same size-based guess the render just made. Declaring the source's colour here instead would label the picture as something it no longer is.

One upscaled frame is tens of megabytes, so the same buffers are reused for the whole operation instead of asking the allocator for a new one thirty times a second. Renting never waits for a buffer to come back: what bounds memory is the pipeline's own backpressure, and waiting here for a buffer the encoder is holding would deadlock against the encoder waiting for a frame.

The most buffers ever held at once, which multiplied by the frame size is the memory this operation actually needed. Nothing here bounds it, so it is worth reporting.

The frames an encoder attempt is still holding, each of which can be taken back once. The platform does not promise to say it has finished with a frame exactly once, and two notifications for the same frame would put one buffer back in the pool twice, where it would be rented to two writers at the same time. Taking a frame out of here is what settles which notification owns it: the others find nothing and have nothing to give back.

Takes back the frame lent under this index. False means another notification about the same frame already took it, which the platform is allowed to send.

The attempt is over and the pool these came from goes with it, so nothing still on loan needs returning.

Scalers finish out of order, but an encoder can only be fed in order. Frames arriving early are held until the one before them arrives, and every index that becomes consecutive is released immediately rather than at the end of a batch.

The most frames ever held at once, which is what the memory bound is really made of.

How many frames may be held while waiting for the one to release next. How many workers will publish, so completion needs no separate signal.

Blocks while the buffer is full, except for the frame the consumer is waiting on: that one is always admitted, so frames held ahead can never starve the one that would let them all through.

Called once by each worker as it stops publishing. The consumer ends when every worker has finished and nothing is left held, so it never waits on a producer that is itself waiting.

Reports the platform's memory counters, or reports nothing when the platform will not supply them. A counter is only ever measured or absent, never invented: zero means "not measured", because no running process holds zero bytes.

Samples process memory for as long as it is alive and keeps the highest reading. Reading only at the end would miss the peak, because the pipeline releases its buffers before the operation reports.

What an upscale is willing to spend on asking a scaler the same question again. A wallet per scaler rather than per frame, because a scaler that fails once is more likely to fail again, and a per-frame allowance would let one unhappy scaler spend the whole operation retrying. Credits do not come back until the next upscale: a wallet that refilled would turn a scaler failing steadily into an upscale that never ends.

Keyed by the scaler itself rather than by where it sits in the generation, so what a scaler has already spent follows it into the second encoder attempt.

Reported separately from the total because one scaler spending everything and every scaler spending a little are the same total and quite different machines.

Every stage in the pipeline can report success and still leave a file nobody can play, so the result is opened again from disk and asked what it actually contains. The pipeline says what to expect of it; only the file says what is there. Each check opens a reader and finishes with it before returning, because the reader is apartment-bound and every call on it has to come from the one thread.

Checks what the pipeline produced, before any audio is restored. The length is exactly the frames that were written at this point, which is the only point it is.

Checks the file the user is handed once the audio is back, and answers how long it runs. How long that is belongs to the muxer rather than to the frame count: restoring the audio re-encodes it, and the priming and padding that adds leave the file legitimately longer than the video inside it.

Captures a generation of scalers on the way in and keeps that same set for its whole life, so a pool that is rebuilt or invalidated underneath it changes nothing about the video being made.

Some hardware encoders cannot produce particular sizes and frame rates, and say so either by refusing or by quietly never finishing. Neither is a reason to give the whole upscale up while the software encoder has not been asked, so it is asked once. The second attempt repeats the decode and the scaling as well, because frames are pulled by the encoder rather than held anywhere they could be handed over. It upscales with the same scalers the first attempt captured.

One instance runs one attempt. What it counted stays readable afterwards so that an attempt can describe itself even when it was stopped part way.

What the attempt had done when it ended. Kept rather than only returned, because an attempt that was stopped part way hands its caller nothing to read this from.

What this attempt did, whether it finished or was stopped. Reported from here because a stopped attempt throws instead of handing back the result its numbers would arrive in.

Watches for a scaler call that stopped answering, which is the one failure an upscale cannot notice from the inside: the call cannot be cancelled and the thread inside it cannot be taken back. Crossing the threshold ends the upscale and costs that scaler for the rest of the process. Nothing is released on the way out, because the thread still inside the call is what holds its surfaces, and freeing what a running call is reading from is worse than never freeing it at all.

Gives up the scaler of every worker that never stopped. A call cannot be taken back and a worker between calls now will be inside another shortly, so a later upscale handed that scaler would be the second thread inside it. Settling waits on the decode as well, so a worker that has finished keeps its scaler rather than paying for whatever else was late.

Which of two failures an upscale should be told about: the one that reached the caller, or the first one a stage recorded on its way out. A stage that fails stops every other stage, so a cancellation reaching the caller is usually the consequence rather than the reason, and the recorded fault is the reason. A failure that already says what it was keeps saying it: the stages it just cancelled would otherwise replace it with the cancelling of everything else, and a reason nothing can act on is how a recoverable failure stops being recoverable. Conversely, an encoder error caused by another stage stopping its input does not replace that stage's fault.

What an attempt whose stages would not settle failed with. Always a reason no second attempt is offered for, whatever surfaced first: the scalers this one is still inside are the ones the attempt after it would be handed. A scaler this attempt already gave up is why nothing settled, so the reason that says a scaler stopped answering is kept rather than replaced by the symptom it produced. Anything else that would not settle has no reason of its own yet, and one that says so is better than reporting whatever the cancelling of everything else threw.

Asks one scaler for one frame, and asks again while it is willing to pay to. Which failure the platform names is not read, so a status this build has never heard of is tried again rather than treated as hopeless. A scaler that answers anything but success for its whole allowance, with fresh surfaces between each answer, is given up: handing it to the next upscale would only lose that one too.

The pair of surfaces one worker scales through. Renewing destroys before it creates, so a surface a failed call left in an unknown state is gone before its replacement exists and can never be handed to another frame.

A native-only identifier leads every name, so the web app cannot predict a path before it is created. Disposing takes all the files rather than the one a failure stopped at.

Kept here because the workspace is what has to clear up after every attempt, so the limit and the files that limit brings into being cannot drift apart.

Each attempt writes somewhere of its own, so an attempt that failed cannot be mistaken for the result and a straggler still holding its file cannot spoil the one that follows.

The encoder pulls: it asks for a sample whenever it is ready for one, which is what keeps the whole pipeline from running further ahead than the slowest stage.

Which failures a second attempt in software could get past. Everything the encoder was not responsible for is left alone: encoding it again the slow way would spend a second pass over the video to arrive at the same answer.

is walked by whichever thread the encoder asks on, one frame at a time, so it must be a sequence that blocks until the next frame is ready rather than one that ends early.

Ends this attempt's interest in what it lent. A call already on its way in can still lend after this, which costs nothing: the loans, the buffers and the encoder all belong to the attempt that is ending, so whatever arrives late is dropped along with them.

One worker owns one handle for the length of an upscale, so the serial lane each scaler requires follows from ownership instead of from a lock.

False once this scaler has been given up, which cannot be undone.

How long this scaler has been inside the one call it cannot be interrupted in, or zero between calls. A call that never returns never clears it, which is the only sign there is that a scaler stopped answering. Written by the worker that owns this handle and read by whoever is watching it, so both go through Volatile: without that the watcher could keep reading a stamp from before the call it is trying to time.

Gives this scaler up for the rest of the process; a call still inside it is left to run, because there is no way to ask it to stop.

Returns the platform's own status, which the caller carries into the failure it reports.

Raised when preparing left the device readier than it was found. Only the one change this type makes is announced: readiness can also fall back on its own, and nothing here is watching for that.

Prepares the scaler and answers with what it found before doing so. A caller cannot ask afterwards, because by then everything reports ready and there is nothing left to say whether a model had to be downloaded and installed first. Progress is reported as a fraction from 0 to 1.

The cost callback is told what preparing cost, once, when an attempt finishes either way. It reaches whoever is still waiting at that point, which need not be the caller that started it. A caller handed a pool that is already standing hears nothing, because it did not pay for one.

An unreported progress counts as zero, so it never overtakes a measured one.

What the two stages that can install something cost, and what the scaler reported before this attempt touched it. Kept together because a duration on its own cannot tell an upscale that waited for a model to arrive from one that found it already there.

When stopping was first asked for, or -1 while nothing has asked.

True for the first ending only, so success, failure and cancellation cannot each announce one for the same upscale.

Caching DispatcherQueue when Window is set to workaround a bug in Window::get_DispatcherQueueImpl which causes dangling pointer to DispatcherQueue when app is closing. See https://microsoft.visualstudio.com/DefaultCollection/OS/_workitems/edit/54449040/

Registration is a per-process download shared by every Windows AI feature, so it is owned here rather than by whichever feature happens to need it first. Concurrent callers share one preparation, and a failure leaves it unregistered so the next caller retries.

A flag to indicate whether the viewmodel is interactable (or not a loading screen) DO NOT OVERRIDE/MUTATE THIS FLAG!!! This should only be read and written by the parent viewmodel (e.g., RouterViewModel), unless the interactable state can only be determined during Initialize (e.g., SignInViewModel).

Auto-generated

Provides application-specific behavior to supplement the default Application class.

InitializeComponent()

GetXamlType(Type)

GetXamlType(String)

GetXmlnsDefinitions()

InitializeComponent()

Connect()