Skip to content

v1.28.7

Choose a tag to compare

View all tags
@github-actions github-actions released this 05 Sep 22:27
· 128 commits to main since this release
v1.28.7
eb80204

The subclassing release: a GStreamer element written in C# is a first-class element now. Twenty eight classes are subclassable — Gst.Element and Gst.Bin, Gst.Pad, the GstBase sources, sinks, transforms, parsers and aggregators, the GstAudio and GstVideo decoders, encoders, filters and sinks, and seven GES timeline classes — with thirty class struct mirrors and 242 vfunc slots, every mirror probed against the running library. The surface is generated, not hand written, which is what made it possible to go from the six hand-bound bases of the previous release to twenty eight in one cycle. An instance the library creates reaches managed code as its managed type, so ElementFactory.Make of a registered type, a pad built from a template and a pad an aggregator requests all dispatch their vfuncs; a managed type installs GObject properties, defines signals and implements GstURIHandler; and a lent GstSegment, GstVideoInfo or GstVideoCodecFrame is wrapped without a copy and invalidated when the call returns. Beside it, an eighteenth package ships for the first time — GstSharp.Net.RtspServer, libgstrtspserver-1.0 — and the introspection half of GObject arrives: the GParamSpec subclasses with their ranges and defaults, the enumeration, flags and interface tables of a GType, and Object.As<T>(). Three samples are new, RtspServer, GesCustomSource and GesLaunch, the last a port of ges-launch-1.0; samples/GstInspect prints every section the real gst-inspect-1.0 prints and CI diffs the two; and benches/ holds a BenchmarkDotNet harness for the dispatch, property and mapping paths. All eighteen packages ship as one version, 1.28.7, generated from the GStreamer 1.28 girs, 249 commits after 1.28.6.

Highlights

  • Managed subclasses, generated. Every subclassable class gets its subclassing surface emitted by the generator rather than written by hand. Nineteen of them are the core and base-library classes — Gst.Element, Gst.Bin, GstBase BaseSrc, PushSrc, BaseSink, BaseTransform, Aggregator and BaseParse, GstAudio AudioBaseSink, AudioBaseSrc, AudioSink, AudioSrc, AudioFilter, AudioDecoder and AudioEncoder, GstVideo VideoSink, VideoFilter, VideoDecoder and VideoEncoder. Each class struct is mirrored, and every mirror's layout is checked against the running library by the integration tests, so a slot patched at the wrong offset fails a test run rather than a pipeline. More than twenty gir annotation corrections were needed to make the slots come out right. A lent boxed record — a GstSegment, an AudioInfo or VideoInfo, a BaseParseFrame, a VideoCodecFrame or VideoCodecState — is wrapped around the address the caller owns instead of copied, and detached when the call returns, which is also what binds six slots the first wave had to skip (BaseSrc::do_seek and ::prepare_seek_segment, BaseTransform::filter_meta, AudioFilter::setup, VideoFilter and VideoSink::set_info); VideoCodecFrame.Copy() and VideoCodecState.Copy() are there for a handler that needs one past the call. AudioDecoder.OnPrePush(ref Buffer?) and its encoder sibling take the inout parameter whose ownership transfers in both directions. handle_frame is required at DefineSubclass time for the parser and the four codec classes, the way a pad template is.
  • Native-initiated construction. IManagedSubclass<TSelf>.CreateWrapper and a generic DefineSubclass<TSelf> overload let an instance GStreamer creates arrive as its managed type with its vfuncs dispatched: an element made through ElementFactory.Make, a pad built from a PadTemplate.NewWithGtype template, a pad an aggregator requests. SubclassType.NewInstance(IReadOnlyDictionary<string, object?>) passes construct-only properties, which is what a GstPad needs for its direction. Gst.Pad and GstBase.AggregatorPad are subclassable in their own right — OnLinked, OnUnlinked, OnFlush, OnSkipBuffer — and Aggregator.OnCreateNewPad is bound. A type defined with the non-generic DefineSubclass keeps the ancestor-wrapper behaviour it had. docs/subclassing.md §5.4 states the fabrication rules: never sink, one winner per handle, and a CreateWrapper that runs on a streaming thread and must do nothing but forward its arguments.
  • Properties, signals and GstURIHandler. ObjectClassConfig.InstallProperty with OnSetProperty and OnGetProperty installs a GObject property on a managed type, Object.Notify(ParamSpec) emits its notification, and Object.SetPropertyOverride/GetPropertyOverride reach a property a base class owns. AddSignal defines a signal with a class handler and an accumulator, SignalAccumulator.TrueHandled or FirstWins. A DefineSubclass<TSelf>(…, SubclassOptions, …) overload on every subclassable class adds interfaces, GstURIHandler first, through URIHandlerImplementation.For<TSelf>(). CONSTRUCT and CONSTRUCT_ONLY are refused by design: GObject dispatches the write to the class that owns the property while the instance is still being built, before the wrapper that would serve it exists. Twenty ParamSpecX.New factories cover the GObject kinds, plus ParamSpecFraction and ParamSpecArray, and five more ParamSpec classes are bound — boxed, object, pointer, param and variant.
  • GES subclassing. GES.TimelineElement, TrackElement, Source, VideoSource, AudioSource, Clip and SourceClip join the subclassable set, with OnCreateSource, OnCreateTrackElement, OnSetParent and the timeline-element setters; class struct mirrors lay out <union> members for it, and Asset.Extract<T>() is hand bound, because that is the child contract a managed OnCreateTrackElement has to satisfy. A create_source or create_element override that answers null or throws gets an identity element substituted and the failure reported: GES 1.28.6 would otherwise free the track element's nleobject while it is still referenced.
  • GstSharp.Net.RtspServer — GstRtspServer. The eighteenth package binds libgstrtspserver-1.0: 18 classes and 41 signals, including the 21 request signals of RTSPClient and the eight socket members of RTSPStream. RTSPMountPoints.AddFactory is hand written so the factory wrapper and its handlers stay alive as long as the mount point holds them, and RTSPServer.Detach is hand written too. samples/RtspServer is a port of the upstream test-launch.c. docs/ownership.md gains an "RTSP server" section with the lock, thread and shutdown rules. Skipped on purpose: the set_send_func pair, which asserts on every reachable path, and RTSPThreadPool.GetThread and RTSPThread.New, which leak a thread without a stop.
  • GParamSpec and GType introspection, and Object.As<T>(). The ParamSpec subclasses are bound — ParamSpecInt through ParamSpecGType in Gst.GObject, plus Gst.ParamSpecFraction and ParamSpecArray — with Minimum, Maximum, Default, Epsilon, Values and IsAType, and ParamSpec itself gains Nick, Blurb, OwnerType, NativeType, DefaultValue as a borrowed ValueView, RedirectTarget and FromNative. GType.GetEnumValues, GetFlagsValues, GetInterfaces and IsInterface read the tables a GType carries, SignalQuery.List(GType) lists its signals, Gst.Object.Flags and IsFlagSet read the object's own flags, and Object.As<T>() casts to an interface through a generated adapter — the module that declares the interface has to be initialised first. ModuleInterfaceEntry and a three-argument NativeModule carry that registration.
  • Runtime additions. Gst.GObject.Object.ListProperties(GType) lists the properties of a class without an instance, which is what gst-inspect-1.0 prints as "Pad Properties". Discoverer.TryDiscoverUri(uri, out GException? error) hands back the DiscovererInfo together with the error, so a missing-plugin result keeps its installer details; DiscoverUri still throws. Gst.GLib.UserDirectories.CacheDir reads g_get_user_cache_dir.
  • Pad functions. A pad's chain, chain-list, get-range, event, event-full, query, iterate-internal-links, link, unlink, activate and activate-mode functions can be set from C# — Pad.SetChainFunction through SetActivateModeFunction, keyed by the pad instance, with null unsetting — and CollectPads.SetBufferFunction and SetClipFunction beside them.
  • Samples and tools. samples/GstInspect is a full port: properties with their ranges and their enumeration and flags tables, element flags, clocking, implemented interfaces, URI protocols, pads with their Type: and pad-property blocks, signals and action signals, children, presets and typefind extensions. CI diffs the page against the real gst-inspect-1.0 on every leg whose tool is new enough. samples/GesLaunch ports ges-launch-1.0 — the ges: timeline grammar, project load and save, rendering, preview sinks, track options, --list-transitions and the interactive keyboard — and shows the one thing the C tool hides inside its GMainLoop: GESProject::loaded is always deferred to the default GMainContext, so a loop-less application pumps Gst.GLib.MainContext.Default.Iteration(false) on the extracting thread until Loaded or ErrorLoading. samples/GesCustomSource is a managed GES source end to end. samples/GstDiscoverer prints installer details, strips arrays of buffers out of its caps and answers --print-cache-dir; samples/GstTranscode runs on the Linux CI leg. Every sample and the integration tests build with the analyzers applied, so a sample that uses the binding the way a rule forbids fails the build.
  • benches/GstSharp.Benchmarks. A BenchmarkDotNet harness for the four paths that carry the cost — trampoline dispatch against a native identity, property get and set with their boxing, Buffer.Map as a span against a copy, and interned wrapper lookup. Every CI job builds it and none of them runs it. The numbers in benches/README.md put 32 bytes per buffer on a managed transform_ip, which is the borrowed Buffer wrapper, and zero allocation on the typed property and mapping paths.
  • Generator and documentation. Every generated method parameter carries its gir documentation now; more than 4,200 <param> lines were placeholders before. Markdown links in gir prose are rewritten, which clears the DocFX invalid-link and invalid-bookmark warnings. rename reaches a vfunc slot (Ns.Class::vfunc), two overlay sections are new — vfuncSiblingArguments and lentOpaqueRecords — and four diagnostics, GEN0044 through GEN0047, report what an overlay got wrong; a record field that embeds a GstMiniObject by value is refused by the generator itself — the six MIKEY payload pt fields. Gst.Audio.AudioSink.OnStopDevice binds GstAudioSinkClass.stop under a name of its own, GES.TimelineElement.OnDeepCopy binds deep_copy, Gst.RtspServer.RTSPClient.CheckRequirements is bound as an event, Gst.Allocators.DRMDumbAllocator.DrmDevicePath is readable, and MIKEYPayloadX.FromPayload casts a MIKEYPayload to its six payload types. The borrowed-return note of nine vfunc overrides no longer claims the override has to keep the object alive, and the DefineSubclass documentation names the interface ArgumentExceptions it can throw.

Behavioural notes

PushSrc.OnCreate answering Gst.FlowReturn.Ok with a null buffer surfaces as a native element error. The override contract is that Ok means a buffer was produced. An override that answers Ok and leaves the out parameter null used to raise a managed exception out of the trampoline; the NULL is passed through to the base class now, which posts an element error on the bus for it, the same failure a C source that did the same thing produces. Answering Ok without a buffer is not a way to produce nothing: a source with nothing to hand out answers a flow result that says so — Eos, Flushing or an error.

An untransferred Buffer, BufferList, Event or Query reaching a callback is borrowed. Such an object is handed to managed code as a borrowed wrapper now — writable, and valid only for the duration of the call — where it used to arrive as a wrapper holding a reference of its own. Holding that reference is what made the object read-only, so gst_query_set_* and metadata writes failed on exactly the objects a handler is meant to fill in. Five parameters of four shipped callbacks move: CollectPadsEventFunction#event, CollectPadsQueryFunction#query, CustomMetaTransformFunction#transbuf and #buffer, and AppSinkProposeAllocationCallback#query. A handler that stored one of those wrappers past the call now holds a detached one, which throws ObjectDisposedException rather than reading a handle the library may have freed.

Gst.Meta.Flags on a removed item throws ObjectDisposedException instead of dereferencing the zero handle a Buffer.RemoveMeta that answered true, or a ForeachMeta that removed the item, left behind.

A DefineSubclass on one of the seventeen template-requiring bases whose class initialiser adds no required pad template now fails as a failed class initialiser, from inside class_init: the type name stays taken, because a static GType cannot be unregistered, but the type is not published to the wrapper registry, and a retry reports why the name is taken.

Every member that hands out a ParamSpec returns the derived class. FindProperty, ListProperties, IChildProxy.Lookup, notify handlers and the StreamCollection and GES lookups answer a ParamSpecInt, a ParamSpecEnum and so on; ParamSpec is no longer sealed, and a pattern match or a cast against a subclass is how the range and default are read. Existing code that treats the result as a ParamSpec is unaffected. One compile-time consequence: a managed Gst.Object subclass that declares its own Flags member gets CS0108, because Gst.Object.Flags now exists — new on the declaration, or a different name, resolves it.

The analyzer release list is complete. AnalyzerReleases.Shipped.md lists all five rules: GST0001 (a wrapper that is never disposed) and GST0002 (a buffer mapping that is never released) have shipped since 1.28.0 but were never listed, and three are new — GST0003 (an overridden vfunc that DefineSubclass does not declare), GST0004 (a declared slot that nothing overrides) and GST0005 (a CreateWrapper that ignores its SubclassCtorArgs). All five are warnings, and docs/analyzers.md states each rule and its fix.

Nothing else that shipped changed. The five behavioural notes above are the whole of it — the sixth records a list that was incomplete, not a member that moved — and four of the five are behaviour that was wrong: the null-buffer path could only ever throw, the borrowed callback parameters could only ever fail the write they were handed, the removed metadata item could only ever answer zero, and the missing pad template could only ever produce a type the library refuses. Everything else in this release is new surface. The generated subclassing surface, native-initiated construction, properties, signals and GstURIHandler, GES subclassing, the introspection members, the pad function setters and the whole of GstSharp.Net.RtspServer — a package that has never been published — are all first appearances however they moved during development. Pad.SetEventFullFunction(null) restoring GStreamer's default event handler, rather than leaving the pad on a NULL full-function the next event would call, is a correction inside this release: the setters land here and no released version ever had the other behaviour.

How that is checked. PackageValidationBaselineVersion in src/Directory.Build.props is 1.28.6, and CI's "Pack against the published surface" step, which packs the whole solution against that baseline, is green on the tag commit. Seventeen of the eighteen packages are compared that way; GstSharp.Net.RtspServer is the one that is not, because it has never been published and there is no baseline on nuget.org to restore. The size of the subclassing surface is frozen by the census tests — thirty class struct mirrors, 242 slots, and a virtual ledger of twenty slots a mirror lays out and the managed surface deliberately leaves alone, each with the sentence that says why — so a slot that appears or disappears fails the build rather than the release. The mirrors are probed against the running library on every CI leg with a native GStreamer installation, and the gst-inspect-1.0 page diff is what keeps the introspection members honest against the tool they reproduce.

Changes

  • Name where the profile deserializer is registered
  • Parse the render format through the value deserializer
  • Say which job wins when the config and the command line disagree
  • Let a job on the command line reach the benchmarks
  • Let the benchmarks run until they settle
  • Say what the rendering the trampoline hid behind actually cost
  • Rewrite the benches README from the run the fixed benchmarks produced
  • Build the benches with the analyzers the package ships
  • Sum the mapped buffer in lanes and give the map a row of its own
  • Measure the trampoline against a source that does no work
  • Use the repository's Value shape in the benches and tighten their README
  • Record the benches precedent in the docs
  • Add the BenchmarkDotNet harness under benches/
  • Report a failed save instead of throwing and name the seek keys
  • Say that the smart profile guess is not ported either
  • Say where the extra track type separators come from
  • Give the CI clips a duration in seconds and fail a failing save
  • End the run on Ctrl+C instead of the process
  • Fail the run when the listing or the restriction caps did not work
  • Report a bad --timeout and read the "/" the flags deserializer accepts
  • Spell the test clip pattern in the GesLaunch examples
  • List the GES and RTSP server samples in the README
  • Run GesLaunch on the three native CI legs
  • Add the GesLaunch sample, a port of ges-launch-1.0
  • Say that the deep_copy wrapper takes a reference of its own
  • Regenerate after the batch B rebase and renumber the borrowed-return note diagnostic
  • Name the reference the caller of a request pad owns
  • Say who references what a vfunc answers borrowed
  • Name the interface conditions in the registration that declares them
  • Rewrite the Markdown links of a gir doc into what they mean
  • Give every planned parameter the doc its gir wrote
  • Resolve a sibling before a wrapper the call has to undo is built
  • Say what the guard covers and observe what the slot ran
  • Deep copy a group the hazard test never built
  • Detach a lent opaque wrapper when the call returns
  • Resolve a copy a slot is handed without settling its reference
  • Give a colliding virtual method a name of its own
  • Refuse an embedded mini object in the generator itself
  • Hand a signal handler a NULL terminated vector of strings
  • Plan a filename property the way a string one is planned
  • Leave the server's thread pool to the collector as well
  • Say what the discoverer sample and the analyzer projects really do
  • Say what the burnt name really means, whatever burnt it
  • Leave the interned accessor results in the tests to the collector
  • Say nothing where the C tool says nothing about properties
  • Drop two notes that no longer say anything
  • Leave the last two disposed buses to the collector as well
  • Print the discoverer cache directory the C tool prints
  • Print the report of a failed discovery beside its error
  • Print the pad class of a template and the properties it adds
  • Strip arrays of buffers from the caps the discoverer prints
  • Run the transcoder sample on the Linux job
  • Leave the tests' interned buses to the collector
  • Leave the samples' interned wrappers to the collector
  • Build the samples and the tests with the analyzers
  • Say when the parent class of a failed definition is captured
  • Point the citations at the lines that say what they are quoted for
  • Keep a burnt type good for the one thing it is still good for
  • Ask GLib for the cache directory where native calls are allowed
  • Read the cache directory GLib resolves for the user
  • Hand out what a discovery found together with what went wrong
  • List the properties of a class without an instance of it
  • Take a pad back to its default handler when the full event function is unset
  • Pin the missing pad template as a failed class initialiser
  • Check the required pad templates inside class_init
  • Leave the bus to the collector as the ownership doctrine says
  • Speak of stage 3 in the tense it has earned
  • Name the class that really implements create_element
  • Give the required-slot fixture the symbol prefix GstBase really has
  • Prove a gir that already said borrowed keeps its sentence
  • Put each planner method back under its own doc comment
  • Record GST0001 and GST0002 under the release that first shipped them
  • Release the bus the remaining subclass tests asked for
  • Release the substituted element like its sibling does
  • Read the verbose flag off the run, not off a static
  • Say the run to the end of the stream once, and release the bus
  • Release the parsed pipeline when an assertion throws first
  • Prove the guard on a refused create_element too
  • Let a fixture reach the required-slot diagnostic
  • Correct two sentences the earlier commits left standing
  • Widen the adopt branch to every wrapper the runtime fabricates
  • Drop the release sentence from a return an overlay borrowed
  • Stop claiming the wrapping constructor always sinks
  • Name the property-id collision behind the one-level rule
  • Say what disposing the property slot's pspec costs
  • Say plainly why the discovered GError is copied
  • Say that every stage of the subclassing design has shipped
  • Record the analyzer rules under the releases that ship them
  • Say only what is verified about a substituted source
  • Say the same thing about a refused source everywhere
  • Write the files the wave touched without a byte order mark
  • Say what the editing services sample needs and where the layer refuses
  • Let the fabricated wrappers go before their timeline
  • Add a clip whose source refuses to build an element
  • Answer an element where a source refused to build one
  • Run the editing services sample on all three native legs
  • Play a timeline built out of managed types
  • Say which lookup the chain-up rule is the rule for
  • Say that the clip keeps the reference the track element carries
  • Say what the caller of paste takes, not what it is handed
  • Name the third source of a skipped virtual
  • Refuse a class struct union the mirror can only guess at
  • Ask one question about a function pointer field
  • Say which construction window the chain-up rule is about
  • Say how a managed source joins the editing services
  • Build a clip and its source out of managed types
  • Extract the object an asset describes
  • Let a managed subclass be a GES source and the clip that builds it
  • Pair a slot the gir spells with a callback typedef
  • Lay a class struct union out at the size of its largest member
  • List a class struct function pointer nothing overrides
  • Write the property from a thread of our own, not the pool
  • Say that the specification a property slot receives is borrowed
  • Count the specification factories, and say the queue may be frozen
  • Say in §5.7 that the protocol vector is pinned once per type
  • Compile a property, a signal and a URI handler ahead of time
  • Write down what stage 3b landed with, and what it refuses
  • Pin the protocols of a type once, and say which type declared the interface
  • Refuse a property nothing could reach, and name the offender in the warning
  • Declare the definition the GST0005 example instantiates through
  • Pair the property slots by the same stem as every other one
  • Warn about a CreateWrapper that throws its arguments away
  • Keep the reason a handler gave for refusing a URI
  • Write down that an interface is declared once, when the type is defined
  • Make an element from a URI and land in a managed handler
  • Let a managed element answer for the URIs it handles
  • Emit a registration overload that takes the optional parts
  • Let a managed subclass declare the interfaces it implements
  • Stop calling installable properties a future question
  • Write down how an installed property finds its way to a subclass
  • Install properties and signals on a probe and watch them arrive
  • Let a managed subclass define signals of its own
  • Let a managed subclass answer for properties of its own
  • Say why the tests still import the constructors themselves
  • Build a specification of every kind against the installed library
  • Let a caller build a property description of any kind
  • Say what becomes of a collected wrapper of a factory-registered subclass
  • Say that the constructor runs inside the gate, and stop crediting the pad
  • Run a pipeline description over a managed source and watch it be wrapped
  • Ask the interning table before anything a fabrication would touch
  • Write down how an instance GStreamer created gets its wrapper
  • Make the smoke test ask a factory for a managed element
  • Wrap the instances of a managed subclass GStreamer creates
  • Sink the floating instance a fabricated wrapper was handed
  • Keep the fabrication gate outside the interning lock
  • Pin the decisions fabrication makes before it touches native code
  • Let a subclass state its wrapper, and open the two pad classes
  • Build the wrapper of a managed subclass native code created
  • Add the analyzer release tracking move to the tagging checklist
  • Answer a refusal from a link function and let the collection report its end
  • Test the overlay keys the pad functions are bound through
  • Borrow only the four mini objects a callback handler is meant to write
  • Name the wrapper the event full setter leaves behind
  • Drive a managed chain function from the AOT smoke sample
  • Say what the instance keyed callbacks ship as and how they are keyed
  • Borrow the mini object a callback is handed and let a pad have no parent
  • Bind the pad function setters and the collect pads buffer and clip ones
  • Key the callbacks that carry no user data by their instance
  • Name the members of a GValueArray property, and keep the interned wrappers
  • Print a GValueArray property the way the C tool does
  • Skip the gst-inspect diff where the C tool is older than its page format
  • Count the blacklisted plugins out of the census, and harden the gate
  • Name the two pages GstInspect still cannot match
  • Diff the GstInspect page against gst-inspect-1.0 in CI
  • Print the installer details and strip the caps buffers in GstDiscoverer
  • Print every section of an element page that gst-inspect-1.0 prints
  • Put VideoEncoder.OnPrePush back among the boxed borrows and require audioconvert
  • Require non-null caps from the codec getcaps slots and give codec frames a Copy
  • Correct the class count and the templates the codec bases need
  • Document the codec classes, the third form and the boxed borrow
  • Run a managed parser and the four managed codecs through a pipeline
  • Probe the handle_frame slot of the five codec base classes
  • Note where stage 2b wave 1 stands
  • Write the output buffer and the flags of a parse frame
  • Let a caps query without a filter reach the codec slots
  • Subclass the parser and the four codec base classes
  • Lend and hand over a boxed value across a class struct slot
  • Pair vfunc overrides across intermediate base classes and widen the analyzer tests
  • Add the GST0003/GST0004 override-declaration pairing analyzer
  • Tighten the subclassing limits and require videoconvert on the Linux leg
  • Merge branch e5-tails into e5-stage2
  • Stop a class that reaches the emitter before its parent
  • Say what a lent GObject, render_list and transform_ip really promise
  • Convert a runtime enumeration whose numbers are the platform's
  • Refuse an inout handle the caller hands over
  • Hand a returned mini object over instead of referencing it twice
  • Cast a MIKEY payload to the variant its type names
  • Write an optional out parameter only when the caller asked for it
  • Hand a signal handler a copy of a plain structure
  • Refuse a slot that hides an inherited member of another return type
  • Leave the audio sink stop slot to a naming decision
  • Accept the NULL the base classes pass to three lent parameters
  • Count the overlay keys and the smoke subclasses correctly
  • Document the generated subclassing surface
  • Require the unprepare slot and cover the audio and video sinks under ILC
  • Run the audio and video subclasses through real pipelines
  • Require the prepare slot of an audio sink and an audio source
  • Subclass the seven audio and video base classes
  • Project a counted block of a virtual method onto a span
  • Register a subclassable class whose own slots are all skipped
  • Lend an opaque record to a virtual method
  • Remove the wave handoff notes
  • Say what a copy of a lent boxed parameter would hide
  • Answer the pooled allocation for a NULL PushSrc alloc slot
  • Probe every mirrored class struct against the running library
  • Fire every stale key diagnostic of the subclassing overlays
  • Freeze the size of the subclassing surface
  • Record the state of the wave after the review fixes
  • Drive the identity chain-up through a running pipeline
  • Document what a slot says and what it owes
  • Let a slot say that its answer may not be null
  • Refuse a C long in a class struct mirror
  • Answer what the base class answers for a NULL slot
  • Refuse a slot that lends a boxed instance
  • Chain up on raw handles below the managed surface
  • Let a chain-up honour an identity preserving handle
  • Record the state of the wave at the end of the session
  • Exercise the new subclassing slots against the library
  • Lend a mini object of any type to an override
  • Hand a produced handle over only on success
  • Hand the wave over at the swap
  • Plan the inout handle of a virtual method
  • Generate the subclassing surface of the Gst and GstBase leg
  • Emit the subclassing surface of an allowlisted class
  • Plan the marshalling of a virtual method
  • Qualify what the annotation corrections depend on
  • Record where the vfunc generation wave stands
  • Let the mirrors describe themselves to the ABI probes
  • Emit the mirror of a class struct
  • Build the class struct model before anything is emitted
  • Correct three claims of the handoff notes
  • Record where the vfunc generation wave stands
  • Pair class struct slots with their virtual methods
  • Require the volume element on the Linux leg
  • Word the type function of an interface for an interface
  • Add Object.As() for GObject interfaces
  • Hand out the derived ParamSpec from notify handlers
  • Tighten ParamSpec and signal introspection after review
  • Wrap generated GParamSpec returns through FromNative
  • Bind GParamSpec and GType introspection
  • Let a media-configure handler configure the media
  • Tighten the RTSP server docs and tests after review
  • Add the RtspServer sample
  • Bind AddFactory and Detach by hand for the RTSP server
  • Add the GstRtspServer module
  • Say that the XR readers trust the block length
  • Say why the texture upload meta attach call is skipped
  • Guard the 1.28.6 surface too
  • Say 1.28.6 when nobody passes a version

Full Changelog: v1.28.6...v1.28.7

Assets 20
Loading