mirrors/gstreamer-rs
mirrors/gstreamer-rs
1
1
Fork 1
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer-rs.git synced 2024-12-18 22:26:32 +00:00
Code Issues Projects Releases Wiki Activity
gstreamer-rs/Cargo.lock

3153 lines
71 KiB
Text
Raw Normal View History

Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 3
Update Cargo.lock
2024-08-27 17:31:33 +00:00
[[package]]
name = "adler2"
version = "2.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
name = "ahash"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1410>
2024-03-19 07:18:16 +00:00
version = "0.8.11"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1410>
2024-03-19 07:18:16 +00:00
checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
dependencies = [
"cfg-if",
"getrandom",
"once_cell",
"version_check",
"zerocopy",
]
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
name = "android-activity"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1379>
2024-01-29 10:55:54 +00:00
version = "0.5.2"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1379>
2024-01-29 10:55:54 +00:00
checksum = "ee91c0c2905bae44f84bfa4e044536541df26b7703fd0888deeb9060fcc44289"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
dependencies = [
"android-properties",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
"bitflags 2.6.0",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"cc",
"cesu8",
"jni",
"jni-sys",
"libc",
"log",
"ndk",
"ndk-context",
"ndk-sys",
"num_enum",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
"thiserror 1.0.69",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
]
[[package]]
name = "android-properties"
version = "0.2.2"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
checksum = "fc7eb209b1518d6bb87b283c20095f5228ecda460da70b44f0802523dea6da04"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
name = "anyhow"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1583>
2024-11-06 08:38:46 +00:00
version = "1.0.93"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1583>
2024-11-06 08:38:46 +00:00
checksum = "4c95c10ba0b00a02636238b814946408b1322d5ac4760326e6fb8ec956d85775"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
[[package]]
name = "as-raw-xcb-connection"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1369>
2023-12-22 13:10:36 +00:00
version = "1.0.1"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1369>
2023-12-22 13:10:36 +00:00
checksum = "175571dd1d178ced59193a6fc02dde1b972eb0bc56c892cde9beeceac5bf0f6b"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "async-channel"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1443>
2024-05-20 11:06:30 +00:00
version = "2.3.1"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1443>
2024-05-20 11:06:30 +00:00
checksum = "89b47800b0be77592da0afd425cc03468052844aff33b84e33cc696f64e77b6a"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"concurrent-queue",
"event-listener-strategy",
"futures-core",
"pin-project-lite",
]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
[[package]]
name = "atomic-waker"
version = "1.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "atomic_refcell"
version = "0.1.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "41e67cd8309bbd06cd603a9e693a784ac2e5d1e955f11286e355089fcab3047c"
[[package]]
name = "autocfg"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1550>
2024-09-28 09:17:06 +00:00
version = "1.4.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1550>
2024-09-28 09:17:06 +00:00
checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "base64"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1379>
2024-01-29 10:55:54 +00:00
version = "0.21.7"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1379>
2024-01-29 10:55:54 +00:00
checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "bitflags"
version = "1.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
[[package]]
name = "bitflags"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
version = "2.6.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"serde",
]
[[package]]
name = "block"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0d8c1fef690941d3e7788d328517591fecc684c084084702d6ff1641e993699a"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
[[package]]
name = "block-sys"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1379>
2024-01-29 10:55:54 +00:00
version = "0.2.1"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1379>
2024-01-29 10:55:54 +00:00
checksum = "ae85a0696e7ea3b835a453750bf002770776609115e6d25c6d2ff28a8200f7e7"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
dependencies = [
"objc-sys",
]
[[package]]
name = "block2"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "15b55663a85f33501257357e6421bb33e769d5c9ffb5ba0921c975a123e35e68"
dependencies = [
"block-sys",
"objc2",
]
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "bumpalo"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1427>
2024-04-25 07:49:41 +00:00
version = "3.16.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1427>
2024-04-25 07:49:41 +00:00
checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "byte-slice-cast"
version = "1.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c3ac9f8b63eca6fd385229b3675f6cc0dc5c8a5c8a54a59d4f52ffd670d87b0c"
[[package]]
name = "bytemuck"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
version = "1.20.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
checksum = "8b37c88a63ffd85d15b406896cc343916d7cf57838a847b3a6f2ca5d39a5695a"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "byteorder"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
[[package]]
name = "bytes"
Update gtk-rs dependencies from master to main branch Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1569>
2024-10-22 11:28:07 +00:00
version = "1.8.0"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update gtk-rs dependencies from master to main branch Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1569>
2024-10-22 11:28:07 +00:00
checksum = "9ac0150caa2ae65ca5bd83f25c7de183dea78d4d366469f148435e2acfbad0da"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "cairo-rs"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:48:19 +00:00
version = "0.21.0"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
source = "git+https://github.com/gtk-rs/gtk-rs-core?branch=main#c3fffcacfb5c420c12475bbb853318dc54ce531e"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
"bitflags 2.6.0",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"cairo-sys-rs",
"glib",
"libc",
]
[[package]]
name = "cairo-sys-rs"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:48:19 +00:00
version = "0.21.0"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
source = "git+https://github.com/gtk-rs/gtk-rs-core?branch=main#c3fffcacfb5c420c12475bbb853318dc54ce531e"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"glib-sys",
"libc",
"system-deps",
]
[[package]]
name = "calloop"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1379>
2024-01-29 10:55:54 +00:00
version = "0.12.4"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1379>
2024-01-29 10:55:54 +00:00
checksum = "fba7adb4dd5aa98e5553510223000e7148f621165ec5f9acd7113f6ca4995298"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
"bitflags 2.6.0",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"log",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"polling",
"rustix",
"slab",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
"thiserror 1.0.69",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
]
[[package]]
name = "calloop-wayland-source"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0f0ea9b9476c7fad82841a8dbb380e2eae480c21910feba80725b46931ed8f02"
dependencies = [
"calloop",
"rustix",
"wayland-backend",
"wayland-client",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "cc"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
version = "1.2.1"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
checksum = "fd9de9f2205d5ef3fd67e685b0df337994ddd4495e2a28d185500d0e1edfea47"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1410>
2024-03-19 07:18:16 +00:00
"jobserver",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"libc",
Update Cargo.lock
2024-08-27 17:31:33 +00:00
"shlex",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
[[package]]
name = "cesu8"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "cfg-expr"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
version = "0.17.1"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
checksum = "c360837f8f19e2e4468275138f1c0dec1647d1e17bb7c0215fe3cd7530e93c25"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"smallvec",
"target-lexicon",
]
[[package]]
name = "cfg-if"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
[[package]]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
name = "cfg_aliases"
version = "0.1.1"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
name = "cgl"
version = "0.3.2"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
checksum = "0ced0551234e87afee12411d535648dd89d2e7f34c78b753395567aff3d447ff"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"libc",
]
[[package]]
name = "cocoa"
examples: Update to cocoa 0.26 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1512>
2024-08-27 17:44:07 +00:00
version = "0.26.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
examples: Update to cocoa 0.26 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1512>
2024-08-27 17:44:07 +00:00
checksum = "f79398230a6e2c08f5c9760610eb6924b52aa9e7950a619602baba59dcbbdbb2"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
examples: Update to cocoa 0.26 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1512>
2024-08-27 17:44:07 +00:00
"bitflags 2.6.0",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"block",
"cocoa-foundation",
examples: Update to cocoa 0.26 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1512>
2024-08-27 17:44:07 +00:00
"core-foundation 0.10.0",
"core-graphics 0.24.0",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"foreign-types",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"libc",
"objc",
]
[[package]]
name = "cocoa-foundation"
examples: Update to cocoa 0.26 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1512>
2024-08-27 17:44:07 +00:00
version = "0.2.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
examples: Update to cocoa 0.26 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1512>
2024-08-27 17:44:07 +00:00
checksum = "e14045fb83be07b5acf1c0884b2180461635b433455fa35d1cd6f17f1450679d"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
examples: Update to cocoa 0.26 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1512>
2024-08-27 17:44:07 +00:00
"bitflags 2.6.0",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"block",
examples: Update to cocoa 0.26 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1512>
2024-08-27 17:44:07 +00:00
"core-foundation 0.10.0",
"core-graphics-types 0.2.0",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"libc",
"objc",
]
[[package]]
name = "color_quant"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
[[package]]
name = "combine"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1427>
2024-04-25 07:49:41 +00:00
version = "4.6.7"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1427>
2024-04-25 07:49:41 +00:00
checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
dependencies = [
"bytes",
"memchr",
]
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "concurrent-queue"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1435>
2024-04-30 09:35:39 +00:00
version = "2.5.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1435>
2024-04-30 09:35:39 +00:00
checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"crossbeam-utils",
]
[[package]]
name = "core-foundation"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1361>
2023-12-09 10:14:28 +00:00
version = "0.9.4"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1361>
2023-12-09 10:14:28 +00:00
checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"core-foundation-sys",
"libc",
]
examples: Update to cocoa 0.26 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1512>
2024-08-27 17:44:07 +00:00
[[package]]
name = "core-foundation"
version = "0.10.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b55271e5c8c478ad3f38ad24ef34923091e0548492a266d19b3c0b4d82574c63"
dependencies = [
"core-foundation-sys",
"libc",
]
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "core-foundation-sys"
Update Cargo.lock
2024-08-27 17:31:33 +00:00
version = "0.8.7"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock
2024-08-27 17:31:33 +00:00
checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "core-graphics"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1418>
2024-04-08 05:58:10 +00:00
version = "0.23.2"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1418>
2024-04-08 05:58:10 +00:00
checksum = "c07782be35f9e1140080c6b96f0d44b739e2278479f64e02fdab4e32dfd8b081"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"bitflags 1.3.2",
examples: Update to cocoa 0.26 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1512>
2024-08-27 17:44:07 +00:00
"core-foundation 0.9.4",
"core-graphics-types 0.1.3",
"foreign-types",
"libc",
]
[[package]]
name = "core-graphics"
version = "0.24.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fa95a34622365fa5bbf40b20b75dba8dfa8c94c734aea8ac9a5ca38af14316f1"
dependencies = [
"bitflags 2.6.0",
"core-foundation 0.10.0",
"core-graphics-types 0.2.0",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"foreign-types",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"libc",
]
[[package]]
name = "core-graphics-types"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1361>
2023-12-09 10:14:28 +00:00
version = "0.1.3"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1361>
2023-12-09 10:14:28 +00:00
checksum = "45390e6114f68f718cc7a830514a96f903cccd70d02a8f6d9f643ac4ba45afaf"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"bitflags 1.3.2",
examples: Update to cocoa 0.26 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1512>
2024-08-27 17:44:07 +00:00
"core-foundation 0.9.4",
"libc",
]
[[package]]
name = "core-graphics-types"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3d44a101f213f6c4cdc1853d4b78aef6db6bdfa3468798cc1d9912f4735013eb"
dependencies = [
"bitflags 2.6.0",
"core-foundation 0.10.0",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"libc",
]
[[package]]
name = "crc32fast"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1455>
2024-06-07 16:27:03 +00:00
version = "1.4.2"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1455>
2024-06-07 16:27:03 +00:00
checksum = "a97769d94ddab943e4510d138150169a2758b5ef3eb191a9ee688de3e23ef7b3"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"cfg-if",
]
[[package]]
name = "crossbeam-utils"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1443>
2024-05-20 11:06:30 +00:00
version = "0.8.20"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1443>
2024-05-20 11:06:30 +00:00
checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
name = "cursor-icon"
version = "1.1.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
checksum = "96a6ac251f4a2aca6b3f91340350eab87ae57c3f127ffeb585e92bd336717991"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
rtsp server: allow custom authentication Enables subclassing gst_rtsp_server::RTSPAuth and overriding its authenticate/check/generate_authenticate_header methods Also add new methods in RTSPContext to retrieve RTSP request/response, and to get/replace tokens. Additionally, added RTSPMessage with methods to add an authentication header to a request / retrieve authentication parameters from a response. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1359>
2023-12-08 15:48:03 +00:00
[[package]]
name = "data-encoding"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1435>
2024-04-30 09:35:39 +00:00
version = "2.6.0"
rtsp server: allow custom authentication Enables subclassing gst_rtsp_server::RTSPAuth and overriding its authenticate/check/generate_authenticate_header methods Also add new methods in RTSPContext to retrieve RTSP request/response, and to get/replace tokens. Additionally, added RTSPMessage with methods to add an authentication header to a request / retrieve authentication parameters from a response. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1359>
2023-12-08 15:48:03 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1435>
2024-04-30 09:35:39 +00:00
checksum = "e8566979429cf69b49a5c740c60791108e86440e8be149bbea4fe54d2c32d6e2"
rtsp server: allow custom authentication Enables subclassing gst_rtsp_server::RTSPAuth and overriding its authenticate/check/generate_authenticate_header methods Also add new methods in RTSPContext to retrieve RTSP request/response, and to get/replace tokens. Additionally, added RTSPMessage with methods to add an authentication header to a request / retrieve authentication parameters from a response. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1359>
2023-12-08 15:48:03 +00:00
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "derive_more"
examples: Update to derive_more 1.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:30:28 +00:00
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4a9b99b9cbbe49445b21764dc0625032a89b145a2642e67603e1c936f5458d05"
dependencies = [
"derive_more-impl",
]
[[package]]
name = "derive_more-impl"
version = "1.0.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
examples: Update to derive_more 1.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:30:28 +00:00
checksum = "cb7330aeadfbe296029522e6c40f315320aba36fc43a5b3632f3795348f3bd22"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"proc-macro2",
"quote",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1462>
2024-06-17 05:38:13 +00:00
"syn",
examples: Update to derive_more 1.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:30:28 +00:00
"unicode-xid",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "dispatch"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bd0c93bb4b0c6d9b77f4435b0ae98c24d17f1c45b2ff844c6151a07256ca923b"
[[package]]
name = "dlib"
version = "0.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "330c60081dcc4c72131f8eb70510f1ac07223e5d4163db481a04a0befcffa412"
dependencies = [
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1369>
2023-12-22 13:10:36 +00:00
"libloading",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "downcast-rs"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1418>
2024-04-08 05:58:10 +00:00
version = "1.2.1"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1418>
2024-04-08 05:58:10 +00:00
checksum = "75b325c5dbd37f80359721ad39aca5a29fb04c89279657cffdda8736d0c0b9d2"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "either"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
version = "1.13.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "equivalent"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
[[package]]
name = "errno"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1440>
2024-05-10 06:52:57 +00:00
version = "0.3.9"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1440>
2024-05-10 06:52:57 +00:00
checksum = "534c5cf6194dfab3db3242765c03bbe257cf92f22b38f6bc0c58d59108a820ba"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"libc",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1361>
2023-12-09 10:14:28 +00:00
"windows-sys 0.52.0",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "event-listener"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1455>
2024-06-07 16:27:03 +00:00
version = "5.3.1"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1455>
2024-06-07 16:27:03 +00:00
checksum = "6032be9bd27023a771701cc49f9f053c751055f71efb2e0ae5c15809093675ba"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"concurrent-queue",
"parking",
"pin-project-lite",
]
[[package]]
name = "event-listener-strategy"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1435>
2024-04-30 09:35:39 +00:00
version = "0.5.2"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1435>
2024-04-30 09:35:39 +00:00
checksum = "0f214dc438f977e6d4e3500aaa277f5ad94ca83fbbd9b1a15713ce2344ccc5a1"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"event-listener",
"pin-project-lite",
]
[[package]]
name = "examples"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"anyhow",
examples: Add an example that shows how to write subclasses with virtual methods Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1356>
2023-12-03 13:01:53 +00:00
"atomic_refcell",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"byte-slice-cast",
"cairo-rs",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"cocoa",
rtsp server: allow custom authentication Enables subclassing gst_rtsp_server::RTSPAuth and overriding its authenticate/check/generate_authenticate_header methods Also add new methods in RTSPContext to retrieve RTSP request/response, and to get/replace tokens. Additionally, added RTSPMessage with methods to add an authentication header to a request / retrieve authentication parameters from a response. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1359>
2023-12-08 15:48:03 +00:00
"data-encoding",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"derive_more",
"futures",
"gio",
"gl_generator",
"glib",
"glutin",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"glutin-winit",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"gstreamer",
"gstreamer-allocators",
"gstreamer-app",
"gstreamer-audio",
"gstreamer-base",
"gstreamer-editing-services",
"gstreamer-gl",
"gstreamer-gl-egl",
"gstreamer-gl-x11",
"gstreamer-pbutils",
"gstreamer-play",
"gstreamer-player",
"gstreamer-rtsp",
"gstreamer-rtsp-server",
"gstreamer-sdp",
"gstreamer-video",
"image",
"memfd",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"memmap2",
examples/tutorials: fix macOS run() wrapper terminating too early Using terminate() kills the whole process instead of just stopping the event loop, so we're back to the 'old' way. However, if the provided function finishes too early, that can also fail (will call stop() on a not-yet-running NSApp). Creating a delegate and waiting for the callback makes sure NSApp is running before the actual main() is called. Also, for whatever reason only tutorials were changed to use terminate(). Now both tutorials and examples are using identical code. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1378>
2024-01-29 13:12:40 +00:00
"objc",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"pango",
"pangocairo",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1369>
2023-12-22 13:10:36 +00:00
"raw-window-handle",
Add workaround for linking against macOS SDK's relocatable dylibs See https://github.com/rust-lang/cargo/issues/5077#issuecomment-1284482987 and https://github.com/rust-lang/rust/issues/127100 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1516>
2024-09-06 17:37:30 +00:00
"system-deps",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"uds",
"windows",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"winit",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "fastrand"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
version = "2.2.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
checksum = "486f806e73c5707928240ddc295403b1b93c96a02038563881c4a2fd84b81ac4"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "fdeflate"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1581>
2024-11-01 07:18:58 +00:00
version = "0.3.6"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1581>
2024-11-01 07:18:58 +00:00
checksum = "07c6f4c64c1d33a3111c4466f7365ebdcc37c5bd1ea0d62aae2e3d722aacbedb"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"simd-adler32",
]
[[package]]
name = "flate2"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
version = "1.0.35"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
checksum = "c936bfdafb507ebbf50b8074c54fa31c5be9a1e7e5f467dd659697041407d07c"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"crc32fast",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1550>
2024-09-28 09:17:06 +00:00
"miniz_oxide",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "foreign-types"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965"
dependencies = [
"foreign-types-macros",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"foreign-types-shared",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "foreign-types-macros"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1a5c6c585bc94aaf2c7b51dd4c2ba22680844aba4c687be581871a6f518c5742"
dependencies = [
"proc-macro2",
"quote",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1462>
2024-06-17 05:38:13 +00:00
"syn",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "foreign-types-shared"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b"
[[package]]
name = "futures"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
version = "0.3.31"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"futures-channel",
"futures-core",
"futures-executor",
"futures-io",
"futures-sink",
"futures-task",
"futures-util",
]
[[package]]
name = "futures-channel"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
version = "0.3.31"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"futures-core",
"futures-sink",
]
[[package]]
name = "futures-core"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
version = "0.3.31"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "futures-executor"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
version = "0.3.31"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"futures-core",
"futures-task",
"futures-util",
]
[[package]]
name = "futures-io"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
version = "0.3.31"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "futures-macro"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
version = "0.3.31"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"proc-macro2",
"quote",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1462>
2024-06-17 05:38:13 +00:00
"syn",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "futures-sink"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
version = "0.3.31"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "futures-task"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
version = "0.3.31"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "futures-util"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
version = "0.3.31"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"futures-channel",
"futures-core",
"futures-io",
"futures-macro",
"futures-sink",
"futures-task",
"memchr",
"pin-project-lite",
"pin-utils",
"slab",
]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
[[package]]
name = "gethostname"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1369>
2023-12-22 13:10:36 +00:00
version = "0.4.3"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1369>
2023-12-22 13:10:36 +00:00
checksum = "0176e0459c2e4a1fe232f984bca6890e681076abb9934f6cea7c326f3fc47818"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
dependencies = [
"libc",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1369>
2023-12-22 13:10:36 +00:00
"windows-targets 0.48.5",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
]
[[package]]
name = "getrandom"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1440>
2024-05-10 06:52:57 +00:00
version = "0.2.15"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1440>
2024-05-10 06:52:57 +00:00
checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
dependencies = [
"cfg-if",
"libc",
"wasi",
]
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "gio"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:48:19 +00:00
version = "0.21.0"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
source = "git+https://github.com/gtk-rs/gtk-rs-core?branch=main#c3fffcacfb5c420c12475bbb853318dc54ce531e"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"futures-channel",
"futures-core",
"futures-io",
"futures-util",
"gio-sys",
"glib",
"libc",
"pin-project-lite",
"smallvec",
]
[[package]]
name = "gio-sys"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:48:19 +00:00
version = "0.21.0"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
source = "git+https://github.com/gtk-rs/gtk-rs-core?branch=main#c3fffcacfb5c420c12475bbb853318dc54ce531e"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"glib-sys",
"gobject-sys",
"libc",
"system-deps",
Update Cargo.lock
2024-08-27 17:31:33 +00:00
"windows-sys 0.59.0",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "gir-format-check"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3a5da913a8586ce748f1164c890e1ebe75a7bbc472668f57b7f9fb893d7ac416"
[[package]]
name = "gl_generator"
version = "0.14.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1a95dfc23a2b4a9a2f5ab41d194f8bfda3cabec42af4e39f08c339eb2a0c124d"
dependencies = [
"khronos_api",
"log",
"xml-rs",
]
[[package]]
name = "glib"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:48:19 +00:00
version = "0.21.0"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
source = "git+https://github.com/gtk-rs/gtk-rs-core?branch=main#c3fffcacfb5c420c12475bbb853318dc54ce531e"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
"bitflags 2.6.0",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"futures-channel",
"futures-core",
"futures-executor",
"futures-task",
"futures-util",
"gio-sys",
"glib-macros",
"glib-sys",
"gobject-sys",
"libc",
"memchr",
"smallvec",
]
[[package]]
name = "glib-macros"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:48:19 +00:00
version = "0.21.0"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
source = "git+https://github.com/gtk-rs/gtk-rs-core?branch=main#c3fffcacfb5c420c12475bbb853318dc54ce531e"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"heck",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"proc-macro-crate",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"proc-macro2",
"quote",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1462>
2024-06-17 05:38:13 +00:00
"syn",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "glib-sys"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:48:19 +00:00
version = "0.21.0"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
source = "git+https://github.com/gtk-rs/gtk-rs-core?branch=main#c3fffcacfb5c420c12475bbb853318dc54ce531e"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"libc",
"system-deps",
]
[[package]]
name = "glutin"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1395>
2024-02-16 12:22:40 +00:00
version = "0.31.3"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1395>
2024-02-16 12:22:40 +00:00
checksum = "18fcd4ae4e86d991ad1300b8f57166e5be0c95ef1f63f3f5b827f8a164548746"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
"bitflags 2.6.0",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"cfg_aliases",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"cgl",
examples: Update to cocoa 0.26 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1512>
2024-08-27 17:44:07 +00:00
"core-foundation 0.9.4",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"dispatch",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"glutin_egl_sys",
"glutin_glx_sys",
examples: Add Windows support to `glupload` WGL does not have the concept of a `Display` connection, presumably because there's always only one compositor active. All interop and sharing is happening from the `Context` afterwards. After all `glutin` doesn't have a pointer inside `RawDisplay::Wgl`, and upstream `gstreamer` code creates a dummy display on Win32. WINRT is not taken into account & tested yet. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1468>
2024-06-20 08:49:14 +00:00
"glutin_wgl_sys",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"icrate",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1369>
2023-12-22 13:10:36 +00:00
"libloading",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"objc2",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"once_cell",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1369>
2023-12-22 13:10:36 +00:00
"raw-window-handle",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"wayland-sys",
examples: Add Windows support to `glupload` WGL does not have the concept of a `Display` connection, presumably because there's always only one compositor active. All interop and sharing is happening from the `Context` afterwards. After all `glutin` doesn't have a pointer inside `RawDisplay::Wgl`, and upstream `gstreamer` code creates a dummy display on Win32. WINRT is not taken into account & tested yet. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1468>
2024-06-20 08:49:14 +00:00
"windows-sys 0.48.0",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"x11-dl",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
name = "glutin-winit"
version = "0.4.2"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
checksum = "1ebcdfba24f73b8412c5181e56f092b5eff16671c514ce896b258a0a64bd7735"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"cfg_aliases",
"glutin",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1369>
2023-12-22 13:10:36 +00:00
"raw-window-handle",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"winit",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
name = "glutin_egl_sys"
version = "0.6.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
checksum = "77cc5623f5309ef433c3dd4ca1223195347fe62c413da8e2fdd0eb76db2d9bcd"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"gl_generator",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"windows-sys 0.48.0",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "glutin_glx_sys"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
version = "0.5.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
checksum = "a165fd686c10dcc2d45380b35796e577eacfd43d4660ee741ec8ebe2201b3b4f"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"gl_generator",
"x11-dl",
]
examples: Add Windows support to `glupload` WGL does not have the concept of a `Display` connection, presumably because there's always only one compositor active. All interop and sharing is happening from the `Context` afterwards. After all `glutin` doesn't have a pointer inside `RawDisplay::Wgl`, and upstream `gstreamer` code creates a dummy display on Win32. WINRT is not taken into account & tested yet. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1468>
2024-06-20 08:49:14 +00:00
[[package]]
name = "glutin_wgl_sys"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6c8098adac955faa2d31079b65dc48841251f69efd3ac25477903fc424362ead"
dependencies = [
"gl_generator",
]
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "gobject-sys"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:48:19 +00:00
version = "0.21.0"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
source = "git+https://github.com/gtk-rs/gtk-rs-core?branch=main#c3fffcacfb5c420c12475bbb853318dc54ce531e"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"glib-sys",
"libc",
"system-deps",
]
[[package]]
name = "gstreamer"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"cfg-if",
"futures-channel",
"futures-core",
"futures-executor",
"futures-util",
"gir-format-check",
"glib",
"gstreamer-sys",
"itertools",
gst: implement IdStr bindings and compatibility versions IdStr represents UTF-8 immutable strings which perform optimizations for short strings (< 16 bytes). The C type `GstIdStr` was introduced in GStreamer 1.26 as a replacement for GQuarks. This commit adds Rust bindings for the C type `GstIdStr`. Since this type will be used in API which previously relied on GQuarks, the commit also adds a compatibility implementation which can be used with GStreamer versions prior to 1.26, which is the first version to implement and use `GstIdStr`. The crate [KString] was used as the inner implementation for the compatibility version as it performs similar optimizations as `GstIdStr` and uses the same threshold to trigger heap allocation. See also: https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/7432 [KString]: https://crates.io/crates/kstring Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1531>
2024-09-30 19:20:02 +00:00
"kstring",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"libc",
log: `Log` trait adapter around the GStreamer debug system Allows usage of normal `log` crate macros, and for other crates using those macros to have their log messages go to the GStreamer debug logs. This implementation is based on the one found in Servo. Fixes #187 DebugCategoryLogger is optional via 'log' feature check category above threshold skip_assert_initialized for constructor and helper Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1426>
2024-04-20 23:12:31 +00:00
"log",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"muldiv",
"num-integer",
"num-rational",
"option-operations",
"paste",
"pin-project-lite",
"ron",
"serde",
"serde_bytes",
"serde_json",
"smallvec",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
"thiserror 2.0.3",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "gstreamer-allocators"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"gir-format-check",
"glib",
"gstreamer",
"gstreamer-allocators-sys",
"libc",
]
[[package]]
name = "gstreamer-allocators-sys"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"glib-sys",
"gobject-sys",
"gstreamer-sys",
"libc",
"shell-words",
"system-deps",
"tempfile",
]
analytics: Add bindings for apps/plugins The whole API to use the Analytics meta is implemented. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1358>
2023-11-28 15:39:18 +00:00
[[package]]
name = "gstreamer-analytics"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
analytics: Add bindings for apps/plugins The whole API to use the Analytics meta is implemented. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1358>
2023-11-28 15:39:18 +00:00
dependencies = [
"gir-format-check",
"glib",
"gstreamer",
"gstreamer-analytics-sys",
"libc",
]
[[package]]
name = "gstreamer-analytics-sys"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
analytics: Add bindings for apps/plugins The whole API to use the Analytics meta is implemented. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1358>
2023-11-28 15:39:18 +00:00
dependencies = [
"glib-sys",
"gstreamer-sys",
"libc",
"shell-words",
"system-deps",
"tempfile",
]
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "gstreamer-app"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"futures-core",
"futures-executor",
"futures-sink",
"futures-util",
"gir-format-check",
"glib",
"gstreamer",
"gstreamer-app-sys",
"gstreamer-base",
"libc",
]
[[package]]
name = "gstreamer-app-sys"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"glib-sys",
"gstreamer-base-sys",
"gstreamer-sys",
"libc",
"shell-words",
"system-deps",
"tempfile",
]
[[package]]
name = "gstreamer-audio"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"cfg-if",
"gir-format-check",
"glib",
"gstreamer",
"gstreamer-audio-sys",
"gstreamer-base",
"itertools",
"libc",
"serde",
"serde_json",
audio: Add array-based accessor for all audio buffer planes' data at once This is mostly useful for getting mutable access to all planes at once. Using `plane_data_mut()` for this is not possible as it would require borrowing the frame mutably multiple times. As each plane's data is not overlapping with any other plane we can still provide such functionality safely. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1367>
2023-12-19 08:14:00 +00:00
"smallvec",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "gstreamer-audio-sys"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"glib-sys",
"gobject-sys",
"gstreamer-base-sys",
"gstreamer-sys",
"libc",
"shell-words",
"system-deps",
"tempfile",
]
[[package]]
name = "gstreamer-base"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"atomic_refcell",
"cfg-if",
"gir-format-check",
"glib",
"gstreamer",
"gstreamer-base-sys",
"libc",
]
[[package]]
name = "gstreamer-base-sys"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"glib-sys",
"gobject-sys",
"gstreamer-sys",
"libc",
"shell-words",
"system-deps",
"tempfile",
]
[[package]]
name = "gstreamer-check"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"gir-format-check",
"glib",
"gstreamer",
"gstreamer-check-sys",
]
[[package]]
name = "gstreamer-check-sys"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"glib-sys",
"gobject-sys",
"gstreamer-sys",
"libc",
"shell-words",
"system-deps",
"tempfile",
]
[[package]]
name = "gstreamer-controller"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"gir-format-check",
"glib",
"gstreamer",
"gstreamer-controller-sys",
]
[[package]]
name = "gstreamer-controller-sys"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"glib-sys",
"gobject-sys",
"gstreamer-sys",
"libc",
"pkg-config",
"shell-words",
"system-deps",
"tempfile",
]
[[package]]
name = "gstreamer-editing-services"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"gio",
"gir-format-check",
"glib",
"gstreamer",
"gstreamer-base",
"gstreamer-editing-services-sys",
"gstreamer-pbutils",
"libc",
"serde",
"serde_json",
]
[[package]]
name = "gstreamer-editing-services-sys"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"gio-sys",
"glib-sys",
"gobject-sys",
"gstreamer-pbutils-sys",
"gstreamer-sys",
"libc",
"shell-words",
"system-deps",
"tempfile",
]
[[package]]
name = "gstreamer-gl"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"gir-format-check",
"glib",
"gstreamer",
"gstreamer-base",
"gstreamer-gl-sys",
"gstreamer-video",
"libc",
"serde",
"serde_json",
]
[[package]]
name = "gstreamer-gl-egl"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"gir-format-check",
"glib",
"gstreamer",
"gstreamer-gl",
"gstreamer-gl-egl-sys",
"libc",
]
[[package]]
name = "gstreamer-gl-egl-sys"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"glib-sys",
"gstreamer-gl-sys",
"libc",
"shell-words",
"system-deps",
"tempfile",
]
[[package]]
name = "gstreamer-gl-sys"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"glib-sys",
"gobject-sys",
"gstreamer-base-sys",
"gstreamer-sys",
"gstreamer-video-sys",
"libc",
"shell-words",
"system-deps",
"tempfile",
]
[[package]]
name = "gstreamer-gl-wayland"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"gir-format-check",
"glib",
"gstreamer",
"gstreamer-gl",
"gstreamer-gl-wayland-sys",
"libc",
]
[[package]]
name = "gstreamer-gl-wayland-sys"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"glib-sys",
"gstreamer-gl-sys",
"libc",
"shell-words",
"system-deps",
"tempfile",
]
[[package]]
name = "gstreamer-gl-x11"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"gir-format-check",
"glib",
"gstreamer",
"gstreamer-gl",
"gstreamer-gl-x11-sys",
"libc",
]
[[package]]
name = "gstreamer-gl-x11-sys"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"glib-sys",
"gstreamer-gl-sys",
"libc",
"shell-words",
"system-deps",
"tempfile",
]
[[package]]
name = "gstreamer-mpegts"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"gir-format-check",
"glib",
"gstreamer",
"gstreamer-mpegts-sys",
]
[[package]]
name = "gstreamer-mpegts-sys"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"glib-sys",
"gstreamer-base-sys",
"gstreamer-sys",
"libc",
"shell-words",
"system-deps",
"tempfile",
]
[[package]]
name = "gstreamer-net"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"gio",
"gir-format-check",
"glib",
"gstreamer",
"gstreamer-net-sys",
]
[[package]]
name = "gstreamer-net-sys"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"gio-sys",
"glib-sys",
"gstreamer-sys",
"libc",
"shell-words",
"system-deps",
"tempfile",
]
[[package]]
name = "gstreamer-pbutils"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"gir-format-check",
"glib",
"gstreamer",
"gstreamer-audio",
"gstreamer-pbutils-sys",
"gstreamer-video",
"libc",
"serde",
"serde_json",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
"thiserror 2.0.3",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "gstreamer-pbutils-sys"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"glib-sys",
"gobject-sys",
"gstreamer-audio-sys",
"gstreamer-sys",
"gstreamer-video-sys",
"libc",
"shell-words",
"system-deps",
"tempfile",
]
[[package]]
name = "gstreamer-play"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"gir-format-check",
"glib",
"gstreamer",
"gstreamer-play-sys",
"gstreamer-video",
"libc",
]
[[package]]
name = "gstreamer-play-sys"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"glib-sys",
"gobject-sys",
"gstreamer-sys",
"gstreamer-video-sys",
"libc",
"shell-words",
"system-deps",
"tempfile",
]
[[package]]
name = "gstreamer-player"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"gir-format-check",
"glib",
"gstreamer",
"gstreamer-player-sys",
"gstreamer-video",
"libc",
]
[[package]]
name = "gstreamer-player-sys"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"glib-sys",
"gobject-sys",
"gstreamer-sys",
"gstreamer-video-sys",
"libc",
"shell-words",
"system-deps",
"tempfile",
]
[[package]]
name = "gstreamer-rtp"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"gir-format-check",
"glib",
"gstreamer",
"gstreamer-rtp-sys",
"libc",
"serde",
"serde_json",
]
[[package]]
name = "gstreamer-rtp-sys"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"glib-sys",
"gstreamer-base-sys",
"gstreamer-sys",
"libc",
"shell-words",
"system-deps",
"tempfile",
]
[[package]]
name = "gstreamer-rtsp"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"gir-format-check",
"glib",
"gstreamer",
"gstreamer-rtsp-sys",
"gstreamer-sdp",
"libc",
"serde",
"serde_json",
]
[[package]]
name = "gstreamer-rtsp-server"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"gio",
"gir-format-check",
"glib",
"gstreamer",
"gstreamer-net",
"gstreamer-rtsp",
"gstreamer-rtsp-server-sys",
"gstreamer-sdp",
"libc",
"serde",
"serde_json",
]
[[package]]
name = "gstreamer-rtsp-server-sys"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"gio-sys",
"glib-sys",
"gobject-sys",
"gstreamer-net-sys",
"gstreamer-rtsp-sys",
"gstreamer-sdp-sys",
"gstreamer-sys",
"libc",
"shell-words",
"system-deps",
"tempfile",
]
[[package]]
name = "gstreamer-rtsp-sys"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"gio-sys",
"glib-sys",
"gobject-sys",
"gstreamer-sdp-sys",
"gstreamer-sys",
"libc",
"shell-words",
"system-deps",
"tempfile",
]
[[package]]
name = "gstreamer-sdp"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"gir-format-check",
"glib",
"gstreamer",
"gstreamer-sdp-sys",
]
[[package]]
name = "gstreamer-sdp-sys"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"glib-sys",
"gstreamer-sys",
"libc",
"shell-words",
"system-deps",
"tempfile",
]
[[package]]
name = "gstreamer-sys"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
gst-sys: add manual implementation for GstIdStr Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1531>
2024-09-19 15:28:14 +00:00
"cfg-if",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"glib-sys",
"gobject-sys",
"libc",
"shell-words",
"system-deps",
"tempfile",
]
[[package]]
name = "gstreamer-tag"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"glib",
"gstreamer",
"gstreamer-tag-sys",
"libc",
]
[[package]]
name = "gstreamer-tag-sys"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"glib-sys",
"gobject-sys",
"gstreamer-sys",
"libc",
"shell-words",
"system-deps",
"tempfile",
]
[[package]]
name = "gstreamer-utils"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"futures",
"gstreamer",
"gstreamer-app",
"gstreamer-video",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
"thiserror 2.0.3",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "gstreamer-validate"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"gir-format-check",
"glib",
"gstreamer",
"gstreamer-validate-sys",
"libc",
"tempfile",
]
[[package]]
name = "gstreamer-validate-sys"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"gio-sys",
"glib-sys",
"gobject-sys",
"gstreamer-sys",
"libc",
"shell-words",
"system-deps",
"tempfile",
]
[[package]]
name = "gstreamer-video"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"cfg-if",
"futures-channel",
"gir-format-check",
"glib",
"gstreamer",
"gstreamer-base",
gstreamer-video: Add VideoSeiUserDataUnregisteredMeta Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1375>
2024-01-08 08:33:53 +00:00
"gstreamer-check",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"gstreamer-video-sys",
"itertools",
"libc",
"serde",
"serde_json",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
"thiserror 2.0.3",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "gstreamer-video-sys"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"glib-sys",
"gobject-sys",
"gstreamer-base-sys",
"gstreamer-sys",
"libc",
"shell-words",
"system-deps",
"tempfile",
]
[[package]]
name = "gstreamer-webrtc"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"gir-format-check",
"glib",
"gstreamer",
"gstreamer-sdp",
"gstreamer-webrtc-sys",
"libc",
]
[[package]]
name = "gstreamer-webrtc-sys"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"glib-sys",
"gstreamer-sdp-sys",
"gstreamer-sys",
"libc",
"shell-words",
"system-deps",
"tempfile",
]
[[package]]
name = "hashbrown"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1583>
2024-11-06 08:38:46 +00:00
version = "0.15.1"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1583>
2024-11-06 08:38:46 +00:00
checksum = "3a9bfc1af68b1726ea47d3d5109de126281def866b33970e10fbab11b5dafab3"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "heck"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1410>
2024-03-19 07:18:16 +00:00
version = "0.5.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1410>
2024-03-19 07:18:16 +00:00
checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1418>
2024-04-08 05:58:10 +00:00
[[package]]
name = "hermit-abi"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1462>
2024-06-17 05:38:13 +00:00
version = "0.4.0"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1418>
2024-04-08 05:58:10 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1462>
2024-06-17 05:38:13 +00:00
checksum = "fbf6a919d6cf397374f7dfeeea91d974c7c0a7221d0d0f4f20d859d329e53fcc"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1418>
2024-04-08 05:58:10 +00:00
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
name = "icrate"
version = "0.0.4"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
checksum = "99d3aaff8a54577104bafdf686ff18565c3b6903ca5782a2026ef06e2c7aa319"
dependencies = [
"block2",
"dispatch",
"objc2",
]
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "image"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1401>
2024-02-26 09:52:59 +00:00
version = "0.24.9"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1401>
2024-02-26 09:52:59 +00:00
checksum = "5690139d2f55868e080017335e4b94cb7414274c74f1669c84fb5feba2c9f69d"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"bytemuck",
"byteorder",
"color_quant",
"jpeg-decoder",
"num-traits",
"png",
]
[[package]]
name = "indexmap"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1553>
2024-10-02 06:15:45 +00:00
version = "2.6.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1553>
2024-10-02 06:15:45 +00:00
checksum = "707907fe3c25f5424cce2cb7e1cbcafee6bdbe735ca90ef77c29e84591e5b9da"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"equivalent",
"hashbrown",
]
[[package]]
name = "itertools"
Update to itertools 0.13 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1443>
2024-05-20 11:03:58 +00:00
version = "0.13.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update to itertools 0.13 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1443>
2024-05-20 11:03:58 +00:00
checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"either",
]
[[package]]
name = "itoa"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
version = "1.0.13"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
checksum = "540654e97a3f4470a492cd30ff187bc95d89557a903a2bbf112e2fae98104ef2"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
name = "jni"
version = "0.21.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97"
dependencies = [
"cesu8",
"cfg-if",
"combine",
"jni-sys",
"log",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
"thiserror 1.0.69",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"walkdir",
"windows-sys 0.45.0",
]
[[package]]
name = "jni-sys"
version = "0.3.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1410>
2024-03-19 07:18:16 +00:00
[[package]]
name = "jobserver"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1496>
2024-08-05 09:17:21 +00:00
version = "0.1.32"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1410>
2024-03-19 07:18:16 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1496>
2024-08-05 09:17:21 +00:00
checksum = "48d1dbcbbeb6a7fec7e059840aa538bd62aaccf972c7346c4d9d2059312853d0"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1410>
2024-03-19 07:18:16 +00:00
dependencies = [
"libc",
]
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "jpeg-decoder"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1379>
2024-01-29 10:55:54 +00:00
version = "0.3.1"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1379>
2024-01-29 10:55:54 +00:00
checksum = "f5d4a7da358eff58addd2877a45865158f0d78c911d43a5784ceb7bbf52833b0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "js-sys"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
version = "0.3.72"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
checksum = "6a88f1bda2bd75b0452a14784937d796722fdebfe50df998aeb3f0b7603019a9"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"wasm-bindgen",
]
[[package]]
name = "khronos_api"
version = "3.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e2db585e1d738fc771bf08a151420d3ed193d9d895a36df7f6f8a9456b911ddc"
gst: implement IdStr bindings and compatibility versions IdStr represents UTF-8 immutable strings which perform optimizations for short strings (< 16 bytes). The C type `GstIdStr` was introduced in GStreamer 1.26 as a replacement for GQuarks. This commit adds Rust bindings for the C type `GstIdStr`. Since this type will be used in API which previously relied on GQuarks, the commit also adds a compatibility implementation which can be used with GStreamer versions prior to 1.26, which is the first version to implement and use `GstIdStr`. The crate [KString] was used as the inner implementation for the compatibility version as it performs similar optimizations as `GstIdStr` and uses the same threshold to trigger heap allocation. See also: https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/7432 [KString]: https://crates.io/crates/kstring Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1531>
2024-09-30 19:20:02 +00:00
[[package]]
name = "kstring"
version = "2.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "558bf9508a558512042d3095138b1f7b8fe90c5467d94f9f1da28b3731c5dbd1"
dependencies = [
"static_assertions",
]
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "libc"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
version = "0.2.164"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
checksum = "433bfe06b8c75da9b2e3fbea6e5329ff87748f0b144ef75306e674c3f6f7c13f"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "libloading"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1496>
2024-08-05 09:17:21 +00:00
version = "0.8.5"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1496>
2024-08-05 09:17:21 +00:00
checksum = "4979f22fdb869068da03c9f7528f8297c6fd2606bc3a4affe42e6a823fdb8da4"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"cfg-if",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
"windows-targets 0.52.6",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "libredox"
version = "0.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3af92c55d7d839293953fcd0fda5ecfe93297cfde6ffbdec13b41d99c0ba6607"
dependencies = [
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
"bitflags 2.6.0",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"libc",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"redox_syscall 0.4.1",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
[[package]]
name = "libredox"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
dependencies = [
"bitflags 2.6.0",
"libc",
"redox_syscall 0.5.7",
]
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "linux-raw-sys"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1443>
2024-05-20 11:06:30 +00:00
version = "0.4.14"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1443>
2024-05-20 11:06:30 +00:00
checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "log"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
version = "0.4.22"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "malloc_buf"
version = "0.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "62bb907fe88d54d8d9ce32a3cceab4218ed2f6b7d35617cafe9adf84e43919cb"
dependencies = [
"libc",
]
[[package]]
name = "memchr"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1462>
2024-06-17 05:38:13 +00:00
version = "2.7.4"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1462>
2024-06-17 05:38:13 +00:00
checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "memfd"
version = "0.6.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b2cffa4ad52c6f791f4f8b15f0c05f9824b2ced1160e88cc393d64fff9a8ac64"
dependencies = [
"rustix",
]
[[package]]
name = "memmap2"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1550>
2024-09-28 09:17:06 +00:00
version = "0.9.5"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1550>
2024-09-28 09:17:06 +00:00
checksum = "fd3f7eed9d3848f8b98834af67102b720745c4ec028fcd0aa0239277e7de374f"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"libc",
]
Update Cargo.lock
2024-08-27 17:31:33 +00:00
[[package]]
name = "miniz_oxide"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e2d80299ef12ff69b16a84bb182e3b9df68b5a91574d3d4fa6e41b65deec4df1"
dependencies = [
"adler2",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1550>
2024-09-28 09:17:06 +00:00
"simd-adler32",
Update Cargo.lock
2024-08-27 17:31:33 +00:00
]
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "muldiv"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "956787520e75e9bd233246045d19f42fb73242759cc57fba9611d940ae96d4b0"
[[package]]
name = "ndk"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
version = "0.8.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
checksum = "2076a31b7010b17a38c01907c45b945e8f11495ee4dd588309718901b1f7a5b7"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
"bitflags 2.6.0",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"jni-sys",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"log",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"ndk-sys",
"num_enum",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1369>
2023-12-22 13:10:36 +00:00
"raw-window-handle",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
"thiserror 1.0.69",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "ndk-context"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "27b02d87554356db9e9a873add8782d4ea6e3e58ea071a9adb9a2e8ddb884a8b"
[[package]]
name = "ndk-sys"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
version = "0.5.0+25.2.9519653"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
checksum = "8c196769dd60fd4f363e11d948139556a344e79d451aeb2fa2fd040738ef7691"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"jni-sys",
]
[[package]]
name = "num-integer"
Update Cargo.lock
2024-02-08 13:01:11 +00:00
version = "0.1.46"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock
2024-02-08 13:01:11 +00:00
checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"num-traits",
]
[[package]]
name = "num-rational"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1440>
2024-05-10 06:52:57 +00:00
version = "0.4.2"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1440>
2024-05-10 06:52:57 +00:00
checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"num-integer",
"num-traits",
"serde",
]
[[package]]
name = "num-traits"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1440>
2024-05-10 06:52:57 +00:00
version = "0.2.19"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1440>
2024-05-10 06:52:57 +00:00
checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"autocfg",
]
[[package]]
name = "num_enum"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1496>
2024-08-05 09:17:21 +00:00
version = "0.7.3"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1496>
2024-08-05 09:17:21 +00:00
checksum = "4e613fc340b2220f734a8595782c551f1250e969d87d3be1ae0579e8d4065179"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"num_enum_derive",
]
[[package]]
name = "num_enum_derive"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1496>
2024-08-05 09:17:21 +00:00
version = "0.7.3"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1496>
2024-08-05 09:17:21 +00:00
checksum = "af1844ef2428cc3e1cb900be36181049ef3d3193c63e43026cfe202983b27a56"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"proc-macro-crate",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"proc-macro2",
"quote",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1462>
2024-06-17 05:38:13 +00:00
"syn",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "numtoa"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b8f8bdf33df195859076e54ab11ee78a1b208382d3a26ec40d142ffc1ecc49ef"
[[package]]
name = "objc"
version = "0.2.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "915b1b472bc21c53464d6c8461c9d3af805ba1ef837e1cac254428f4a77177b1"
dependencies = [
"malloc_buf",
]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
[[package]]
name = "objc-sys"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1455>
2024-06-07 16:27:03 +00:00
version = "0.3.5"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1455>
2024-06-07 16:27:03 +00:00
checksum = "cdb91bdd390c7ce1a8607f35f3ca7151b65afc0ff5ff3b34fa350f7d7c7e4310"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
[[package]]
name = "objc2"
version = "0.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "559c5a40fdd30eb5e344fbceacf7595a81e242529fb4e21cf5f43fb4f11ff98d"
dependencies = [
"objc-sys",
"objc2-encode",
]
[[package]]
name = "objc2-encode"
version = "3.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d079845b37af429bfe5dfa76e6d087d788031045b25cfc6fd898486fd9847666"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "once_cell"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
version = "1.20.2"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "option-operations"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7c26d27bb1aeab65138e4bf7666045169d1717febcc9ff870166be8348b223d0"
dependencies = [
"paste",
]
[[package]]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
name = "orbclient"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
version = "0.3.48"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
checksum = "ba0b26cec2e24f08ed8bb31519a9333140a6599b867dac464bb150bdb796fd43"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
"libredox 0.1.3",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "pango"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:48:19 +00:00
version = "0.21.0"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
source = "git+https://github.com/gtk-rs/gtk-rs-core?branch=main#c3fffcacfb5c420c12475bbb853318dc54ce531e"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"gio",
"glib",
"libc",
"pango-sys",
]
[[package]]
name = "pango-sys"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:48:19 +00:00
version = "0.21.0"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
source = "git+https://github.com/gtk-rs/gtk-rs-core?branch=main#c3fffcacfb5c420c12475bbb853318dc54ce531e"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"glib-sys",
"gobject-sys",
"libc",
"system-deps",
]
[[package]]
name = "pangocairo"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:48:19 +00:00
version = "0.21.0"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
source = "git+https://github.com/gtk-rs/gtk-rs-core?branch=main#c3fffcacfb5c420c12475bbb853318dc54ce531e"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"cairo-rs",
"glib",
"libc",
"pango",
"pangocairo-sys",
]
[[package]]
name = "pangocairo-sys"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:48:19 +00:00
version = "0.21.0"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
source = "git+https://github.com/gtk-rs/gtk-rs-core?branch=main#c3fffcacfb5c420c12475bbb853318dc54ce531e"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"cairo-sys-rs",
"glib-sys",
"libc",
"pango-sys",
"system-deps",
]
[[package]]
name = "parking"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1512>
2024-09-10 05:32:07 +00:00
version = "2.2.1"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1512>
2024-09-10 05:32:07 +00:00
checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "paste"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1440>
2024-05-10 06:52:57 +00:00
version = "1.0.15"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1440>
2024-05-10 06:52:57 +00:00
checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "percent-encoding"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1361>
2023-12-09 10:14:28 +00:00
version = "2.3.1"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1361>
2023-12-09 10:14:28 +00:00
checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "pin-project-lite"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1581>
2024-11-01 07:18:58 +00:00
version = "0.2.15"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1581>
2024-11-01 07:18:58 +00:00
checksum = "915a1e146535de9163f3987b8944ed8cf49a18bb0056bcebcdcece385cece4ff"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "pin-utils"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
[[package]]
name = "pkg-config"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1550>
2024-09-28 09:17:06 +00:00
version = "0.3.31"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1550>
2024-09-28 09:17:06 +00:00
checksum = "953ec861398dccce10c670dfeaf3ec4911ca479e9c02154b3a215178c5f566f2"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "png"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1550>
2024-09-28 09:17:06 +00:00
version = "0.17.14"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1550>
2024-09-28 09:17:06 +00:00
checksum = "52f9d46a34a05a6a57566bc2bfae066ef07585a6e3fa30fbbdff5936380623f0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"bitflags 1.3.2",
"crc32fast",
"fdeflate",
"flate2",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1550>
2024-09-28 09:17:06 +00:00
"miniz_oxide",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
name = "polling"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
version = "3.7.4"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
checksum = "a604568c3202727d1507653cb121dbd627a58684eb09a820fd746bee38b4442f"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
dependencies = [
"cfg-if",
"concurrent-queue",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1418>
2024-04-08 05:58:10 +00:00
"hermit-abi",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"pin-project-lite",
"rustix",
"tracing",
Update Cargo.lock
2024-08-27 17:31:33 +00:00
"windows-sys 0.59.0",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
]
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "proc-macro-crate"
Update Cargo.lock
2024-08-27 17:31:33 +00:00
version = "3.2.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock
2024-08-27 17:31:33 +00:00
checksum = "8ecf48c7ca261d60b74ab1a7b20da18bede46776b2e55535cb958eb595c5fa7b"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
Update Cargo.lock
2024-08-27 17:31:33 +00:00
"toml_edit",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "proc-macro2"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
version = "1.0.92"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"unicode-ident",
]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
[[package]]
name = "quick-xml"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1550>
2024-09-28 09:17:06 +00:00
version = "0.36.2"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1550>
2024-09-28 09:17:06 +00:00
checksum = "f7649a7b4df05aed9ea7ec6f628c67c9953a43869b8bc50929569b2999d443fe"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
dependencies = [
"memchr",
]
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "quote"
Update Cargo.lock
2024-08-27 17:31:33 +00:00
version = "1.0.37"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock
2024-08-27 17:31:33 +00:00
checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"proc-macro2",
]
[[package]]
name = "raw-window-handle"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
version = "0.5.2"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
checksum = "f2ff9a1f06a88b01621b7ae906ef0211290d1c8a168a15542486a8f61c0833b9"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
[[package]]
name = "redox_syscall"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29"
dependencies = [
"bitflags 1.3.2",
]
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "redox_syscall"
version = "0.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
dependencies = [
"bitflags 1.3.2",
]
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
[[package]]
name = "redox_syscall"
version = "0.5.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9b6dfecf2c74bce2466cabf93f6664d6998a69eb21e39f4207930065b27b771f"
dependencies = [
"bitflags 2.6.0",
]
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "redox_termios"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "20145670ba436b55d91fc92d25e71160fbfbdd57831631c8d7d36377a476f1cb"
[[package]]
name = "ron"
version = "0.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b91f7eff05f748767f183df4320a63d6936e9c6107d97c9e6bdd9784f4289c94"
dependencies = [
"base64",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
"bitflags 2.6.0",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"serde",
"serde_derive",
]
[[package]]
name = "rustix"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
version = "0.38.41"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
checksum = "d7f649912bc1495e167a6edee79151c84b1bad49748cb4f1f1167f459f6224f6"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
"bitflags 2.6.0",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"errno",
"libc",
"linux-raw-sys",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1361>
2023-12-09 10:14:28 +00:00
"windows-sys 0.52.0",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "ryu"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1440>
2024-05-10 06:52:57 +00:00
version = "1.0.18"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1440>
2024-05-10 06:52:57 +00:00
checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
name = "same-file"
version = "1.0.6"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"winapi-util",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "scoped-tls"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
[[package]]
name = "serde"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
version = "1.0.215"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
checksum = "6513c1ad0b11a9376da888e3e0baa0077f1aed55c17f50e7b2397136129fb88f"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"serde_derive",
]
[[package]]
name = "serde_bytes"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
version = "0.11.15"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
checksum = "387cc504cb06bb40a96c8e04e951fe01854cf6bc921053c954e4a606d9675c6a"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"serde",
]
[[package]]
name = "serde_derive"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
version = "1.0.215"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
checksum = "ad1e866f866923f252f05c889987993144fb74e722403468a4ebd70c3cd756c0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"proc-macro2",
"quote",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1462>
2024-06-17 05:38:13 +00:00
"syn",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "serde_json"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
version = "1.0.133"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
checksum = "c7fceb2473b9166b2294ef05efcb65a3db80803f0b03ef86a5fc88a2b85ee377"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"itoa",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1496>
2024-08-05 09:17:21 +00:00
"memchr",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"ryu",
"serde",
]
[[package]]
name = "serde_spanned"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1550>
2024-09-28 09:17:06 +00:00
version = "0.6.8"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1550>
2024-09-28 09:17:06 +00:00
checksum = "87607cb1398ed59d48732e575a4c28a7a8ebf2454b964fe3f224f2afc07909e1"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"serde",
]
[[package]]
name = "shell-words"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "24188a676b6ae68c3b2cb3a01be17fbf7240ce009799bb56d5b1409051e78fde"
Update Cargo.lock
2024-08-27 17:31:33 +00:00
[[package]]
name = "shlex"
version = "1.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "simd-adler32"
version = "0.3.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe"
[[package]]
name = "slab"
version = "0.4.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
dependencies = [
"autocfg",
]
[[package]]
name = "smallvec"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1413>
2024-03-21 13:41:23 +00:00
version = "1.13.2"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1413>
2024-03-21 13:41:23 +00:00
checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "smithay-client-toolkit"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1395>
2024-02-16 12:22:40 +00:00
version = "0.18.1"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1395>
2024-02-16 12:22:40 +00:00
checksum = "922fd3eeab3bd820d76537ce8f582b1cf951eceb5475c28500c7457d9d17f53a"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
"bitflags 2.6.0",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"calloop",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"calloop-wayland-source",
"cursor-icon",
"libc",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"log",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"memmap2",
"rustix",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
"thiserror 1.0.69",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"wayland-backend",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"wayland-client",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"wayland-csd-frame",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"wayland-cursor",
"wayland-protocols",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"wayland-protocols-wlr",
"wayland-scanner",
"xkeysym",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
name = "smol_str"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1443>
2024-05-20 11:06:30 +00:00
version = "0.2.2"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1443>
2024-05-20 11:06:30 +00:00
checksum = "dd538fb6910ac1099850255cf94a94df6551fbdd602454387d0adb2d1ca6dead"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
dependencies = [
"serde",
]
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
gst: implement IdStr bindings and compatibility versions IdStr represents UTF-8 immutable strings which perform optimizations for short strings (< 16 bytes). The C type `GstIdStr` was introduced in GStreamer 1.26 as a replacement for GQuarks. This commit adds Rust bindings for the C type `GstIdStr`. Since this type will be used in API which previously relied on GQuarks, the commit also adds a compatibility implementation which can be used with GStreamer versions prior to 1.26, which is the first version to implement and use `GstIdStr`. The crate [KString] was used as the inner implementation for the compatibility version as it performs similar optimizations as `GstIdStr` and uses the same threshold to trigger heap allocation. See also: https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/7432 [KString]: https://crates.io/crates/kstring Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1531>
2024-09-30 19:20:02 +00:00
[[package]]
name = "static_assertions"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "syn"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
version = "2.0.89"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
checksum = "44d46482f1c1c87acd84dea20c1bf5ebff4c757009ed6bf19cfd36fb10e92c4e"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"proc-macro2",
"quote",
"unicode-ident",
]
[[package]]
name = "system-deps"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1550>
2024-09-28 09:17:06 +00:00
version = "7.0.3"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1550>
2024-09-28 09:17:06 +00:00
checksum = "66d23aaf9f331227789a99e8de4c91bf46703add012bdfd45fdecdfb2975a005"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"cfg-expr",
"heck",
"pkg-config",
"toml",
"version-compare",
]
[[package]]
name = "target-lexicon"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1496>
2024-08-05 09:17:21 +00:00
version = "0.12.16"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1496>
2024-08-05 09:17:21 +00:00
checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "tempfile"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
version = "3.14.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
checksum = "28cce251fcbc87fac86a866eeb0d6c2d536fc16d06f184bb61aeae11aa4cee0c"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"cfg-if",
"fastrand",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1496>
2024-08-05 09:17:21 +00:00
"once_cell",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"rustix",
Update Cargo.lock
2024-08-27 17:31:33 +00:00
"windows-sys 0.59.0",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "termion"
examples: Update to termion 3 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1379>
2024-01-29 11:01:51 +00:00
version = "3.0.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
examples: Update to termion 3 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1379>
2024-01-29 11:01:51 +00:00
checksum = "417813675a504dfbbf21bfde32c03e5bf9f2413999962b479023c02848c1c7a5"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"libc",
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
"libredox 0.0.2",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"numtoa",
"redox_termios",
]
[[package]]
name = "thiserror"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
version = "1.0.69"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
"thiserror-impl 1.0.69",
Update to thiserror 2 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1583>
2024-11-06 08:38:33 +00:00
]
[[package]]
name = "thiserror"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
version = "2.0.3"
Update to thiserror 2 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1583>
2024-11-06 08:38:33 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
checksum = "c006c85c7651b3cf2ada4584faa36773bd07bac24acfb39f3c431b36d7e667aa"
Update to thiserror 2 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1583>
2024-11-06 08:38:33 +00:00
dependencies = [
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
"thiserror-impl 2.0.3",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "thiserror-impl"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
version = "1.0.69"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"proc-macro2",
"quote",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1462>
2024-06-17 05:38:13 +00:00
"syn",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
Update to thiserror 2 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1583>
2024-11-06 08:38:33 +00:00
[[package]]
name = "thiserror-impl"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
version = "2.0.3"
Update to thiserror 2 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1583>
2024-11-06 08:38:33 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
checksum = "f077553d607adc1caf65430528a576c757a71ed73944b66ebb58ef2bbd243568"
Update to thiserror 2 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1583>
2024-11-06 08:38:33 +00:00
dependencies = [
"proc-macro2",
"quote",
"syn",
]
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "toml"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1496>
2024-08-05 09:17:21 +00:00
version = "0.8.19"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1496>
2024-08-05 09:17:21 +00:00
checksum = "a1ed1f98e3fdc28d6d910e6737ae6ab1a93bf1985935a1193e68f93eeb68d24e"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"serde",
"serde_spanned",
"toml_datetime",
Update Cargo.lock
2024-08-27 17:31:33 +00:00
"toml_edit",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "toml_datetime"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1496>
2024-08-05 09:17:21 +00:00
version = "0.6.8"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1496>
2024-08-05 09:17:21 +00:00
checksum = "0dd7358ecb8fc2f8d014bf86f6f638ce72ba252a2c3a2572f2a795f1d23efb41"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"serde",
]
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1385>
2024-02-06 08:28:23 +00:00
[[package]]
name = "toml_edit"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1550>
2024-09-28 09:17:06 +00:00
version = "0.22.22"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1385>
2024-02-06 08:28:23 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1550>
2024-09-28 09:17:06 +00:00
checksum = "4ae48d6208a266e853d946088ed816055e556cc6028c5e8e2b84d9fa5dd7c7f5"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"indexmap",
"serde",
"serde_spanned",
"toml_datetime",
Update Cargo.lock
2024-08-27 17:31:33 +00:00
"winnow",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
[[package]]
name = "tracing"
version = "0.1.40"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef"
dependencies = [
"pin-project-lite",
"tracing-core",
]
[[package]]
name = "tracing-core"
version = "0.1.32"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "tutorials"
Update versions to 0.24.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1481>
2024-07-11 14:49:18 +00:00
version = "0.24.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"anyhow",
"async-channel",
"byte-slice-cast",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"cocoa",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"futures",
"glib",
"gstreamer",
"gstreamer-app",
"gstreamer-audio",
"gstreamer-pbutils",
"gstreamer-video",
"objc",
Add workaround for linking against macOS SDK's relocatable dylibs See https://github.com/rust-lang/cargo/issues/5077#issuecomment-1284482987 and https://github.com/rust-lang/rust/issues/127100 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1516>
2024-09-06 17:37:30 +00:00
"system-deps",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"termion",
]
[[package]]
name = "uds"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1379>
2024-01-29 10:55:54 +00:00
version = "0.4.2"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1379>
2024-01-29 10:55:54 +00:00
checksum = "885c31f06fce836457fe3ef09a59f83fe8db95d270b11cd78f40a4666c4d1661"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"libc",
]
[[package]]
name = "unicode-ident"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
version = "1.0.14"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
name = "unicode-segmentation"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1550>
2024-09-28 09:17:06 +00:00
version = "1.12.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1550>
2024-09-28 09:17:06 +00:00
checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
examples: Update to derive_more 1.0 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:30:28 +00:00
[[package]]
name = "unicode-xid"
version = "0.2.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "version-compare"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1410>
2024-03-19 07:18:16 +00:00
version = "0.2.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1410>
2024-03-19 07:18:16 +00:00
checksum = "852e951cb7832cb45cb1169900d19760cfa39b82bc0ea9c0e5a14ae88411c98b"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "version_check"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1496>
2024-08-05 09:17:21 +00:00
version = "0.9.5"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1496>
2024-08-05 09:17:21 +00:00
checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
[[package]]
name = "walkdir"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1410>
2024-03-19 07:18:16 +00:00
version = "2.5.0"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1410>
2024-03-19 07:18:16 +00:00
checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
dependencies = [
"same-file",
"winapi-util",
]
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "wasi"
version = "0.11.0+wasi-snapshot-preview1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
[[package]]
name = "wasm-bindgen"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
version = "0.2.95"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
checksum = "128d1e363af62632b8eb57219c8fd7877144af57558fb2ef0368d0087bddeb2e"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"cfg-if",
Update Cargo.lock
2024-08-27 17:31:33 +00:00
"once_cell",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"wasm-bindgen-macro",
]
[[package]]
name = "wasm-bindgen-backend"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
version = "0.2.95"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
checksum = "cb6dd4d3ca0ddffd1dd1c9c04f94b868c37ff5fac97c30b97cff2d74fce3a358"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"bumpalo",
"log",
"once_cell",
"proc-macro2",
"quote",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1462>
2024-06-17 05:38:13 +00:00
"syn",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"wasm-bindgen-shared",
]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
[[package]]
name = "wasm-bindgen-futures"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
version = "0.4.45"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
checksum = "cc7ec4f8827a71586374db3e87abdb5a2bb3a15afed140221307c3ec06b1f63b"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
dependencies = [
"cfg-if",
"js-sys",
"wasm-bindgen",
"web-sys",
]
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "wasm-bindgen-macro"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
version = "0.2.95"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
checksum = "e79384be7f8f5a9dd5d7167216f022090cf1f9ec128e6e6a482a2cb5c5422c56"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"quote",
"wasm-bindgen-macro-support",
]
[[package]]
name = "wasm-bindgen-macro-support"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
version = "0.2.95"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
checksum = "26c6ab57572f7a24a4985830b120de1594465e5d500f24afe89e16b4e833ef68"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"proc-macro2",
"quote",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1462>
2024-06-17 05:38:13 +00:00
"syn",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"wasm-bindgen-backend",
"wasm-bindgen-shared",
]
[[package]]
name = "wasm-bindgen-shared"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
version = "0.2.95"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
checksum = "65fc09f10666a9f147042251e0dda9c18f166ff7de300607007e96bdebc1068d"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
name = "wayland-backend"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1512>
2024-09-10 05:32:07 +00:00
version = "0.3.7"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1512>
2024-09-10 05:32:07 +00:00
checksum = "056535ced7a150d45159d3a8dc30f91a2e2d588ca0b23f70e56033622b8016f6"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"cc",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"downcast-rs",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1379>
2024-01-29 10:55:54 +00:00
"rustix",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"scoped-tls",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"smallvec",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"wayland-sys",
]
[[package]]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
name = "wayland-client"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1581>
2024-11-01 07:18:58 +00:00
version = "0.31.7"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1581>
2024-11-01 07:18:58 +00:00
checksum = "b66249d3fc69f76fd74c82cc319300faa554e9d865dab1f7cd66cc20db10b280"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
"bitflags 2.6.0",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1379>
2024-01-29 10:55:54 +00:00
"rustix",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"wayland-backend",
"wayland-scanner",
]
[[package]]
name = "wayland-csd-frame"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "625c5029dbd43d25e6aa9615e88b829a5cad13b2819c4ae129fdbb7c31ab4c7e"
dependencies = [
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
"bitflags 2.6.0",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"cursor-icon",
"wayland-backend",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "wayland-cursor"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1581>
2024-11-01 07:18:58 +00:00
version = "0.31.7"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1581>
2024-11-01 07:18:58 +00:00
checksum = "32b08bc3aafdb0035e7fe0fdf17ba0c09c268732707dca4ae098f60cb28c9e4c"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
Switch from once_cell to std::sync::OnceLock where it makes sense Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1379>
2024-01-29 16:31:21 +00:00
"rustix",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"wayland-client",
"xcursor",
]
[[package]]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
name = "wayland-protocols"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1379>
2024-01-29 10:55:54 +00:00
version = "0.31.2"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1379>
2024-01-29 10:55:54 +00:00
checksum = "8f81f365b8b4a97f422ac0e8737c438024b5951734506b0e1d775c73030561f4"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
"bitflags 2.6.0",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"wayland-backend",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"wayland-client",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"wayland-scanner",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
name = "wayland-protocols-plasma"
version = "0.2.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
checksum = "23803551115ff9ea9bce586860c5c5a971e360825a0309264102a9495a5ff479"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
"bitflags 2.6.0",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"wayland-backend",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"wayland-client",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"wayland-protocols",
"wayland-scanner",
]
[[package]]
name = "wayland-protocols-wlr"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ad1f61b76b6c2d8742e10f9ba5c3737f6530b4c243132c2a2ccc8aa96fe25cd6"
dependencies = [
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
"bitflags 2.6.0",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"wayland-backend",
"wayland-client",
"wayland-protocols",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"wayland-scanner",
]
[[package]]
name = "wayland-scanner"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1512>
2024-09-10 05:32:07 +00:00
version = "0.31.5"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1512>
2024-09-10 05:32:07 +00:00
checksum = "597f2001b2e5fc1121e3d5b9791d3e78f05ba6bfa4641053846248e3a13661c3"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"proc-macro2",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"quick-xml",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"quote",
]
[[package]]
name = "wayland-sys"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1512>
2024-09-10 05:32:07 +00:00
version = "0.31.5"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1512>
2024-09-10 05:32:07 +00:00
checksum = "efa8ac0d8e8ed3e3b5c9fc92c7881406a268e11555abe36493efabe649a29e09"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"dlib",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"log",
"once_cell",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"pkg-config",
]
[[package]]
name = "web-sys"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
version = "0.3.72"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update dependencies Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1563>
2024-10-19 14:36:13 +00:00
checksum = "f6488b90108c040df0fe62fa815cbdee25124641df01814dd7282749234c6112"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"js-sys",
"wasm-bindgen",
]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
[[package]]
name = "web-time"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1379>
2024-01-29 10:55:54 +00:00
version = "0.2.4"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1379>
2024-01-29 10:55:54 +00:00
checksum = "aa30049b1c872b72c89866d458eae9f20380ab280ffd1b1e18df2d3e2d98cfe0"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
dependencies = [
"js-sys",
"wasm-bindgen",
]
[[package]]
name = "winapi-util"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1496>
2024-08-05 09:17:21 +00:00
version = "0.1.9"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1496>
2024-08-05 09:17:21 +00:00
checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
dependencies = [
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
"windows-sys 0.59.0",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
]
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "windows"
examples: Update to windows 0.58 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:41:24 +00:00
version = "0.58.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
examples: Update to windows 0.58 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:41:24 +00:00
checksum = "dd04d41d93c4992d421894c18c8b43496aa748dd4c081bac0dc93eb0489272b6"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"windows-core",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
"windows-targets 0.52.6",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "windows-core"
examples: Update to windows 0.58 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:41:24 +00:00
version = "0.58.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
examples: Update to windows 0.58 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:41:24 +00:00
checksum = "6ba6d44ec8c2591c134257ce647b7ea6b20335bf6379a27dac5f1641fcf59f99"
examples: Update to windows 0.54 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1403>
2024-02-29 09:31:26 +00:00
dependencies = [
examples: Update to windows 0.56 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1427>
2024-04-25 07:32:38 +00:00
"windows-implement",
"windows-interface",
examples: Update to windows 0.54 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1403>
2024-02-29 09:31:26 +00:00
"windows-result",
examples: Update to windows 0.58 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:41:24 +00:00
"windows-strings",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
"windows-targets 0.52.6",
examples: Update to windows 0.56 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1427>
2024-04-25 07:32:38 +00:00
]
[[package]]
name = "windows-implement"
examples: Update to windows 0.58 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:41:24 +00:00
version = "0.58.0"
examples: Update to windows 0.56 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1427>
2024-04-25 07:32:38 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
examples: Update to windows 0.58 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:41:24 +00:00
checksum = "2bbd5b46c938e506ecbce286b6628a02171d56153ba733b6c741fc627ec9579b"
examples: Update to windows 0.56 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1427>
2024-04-25 07:32:38 +00:00
dependencies = [
"proc-macro2",
"quote",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1462>
2024-06-17 05:38:13 +00:00
"syn",
examples: Update to windows 0.56 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1427>
2024-04-25 07:32:38 +00:00
]
[[package]]
name = "windows-interface"
examples: Update to windows 0.58 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:41:24 +00:00
version = "0.58.0"
examples: Update to windows 0.56 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1427>
2024-04-25 07:32:38 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
examples: Update to windows 0.58 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:41:24 +00:00
checksum = "053c4c462dc91d3b1504c6fe5a726dd15e216ba718e84a0e46a88fbe5ded3515"
examples: Update to windows 0.56 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1427>
2024-04-25 07:32:38 +00:00
dependencies = [
"proc-macro2",
"quote",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1462>
2024-06-17 05:38:13 +00:00
"syn",
examples: Update to windows 0.54 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1403>
2024-02-29 09:31:26 +00:00
]
[[package]]
name = "windows-result"
examples: Update to windows 0.58 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:41:24 +00:00
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1d1043d8214f791817bab27572aaa8af63732e11bf84aa21a45a78d6c317ae0e"
dependencies = [
"windows-targets 0.52.6",
]
[[package]]
name = "windows-strings"
version = "0.1.0"
examples: Update to windows 0.54 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1403>
2024-02-29 09:31:26 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
examples: Update to windows 0.58 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:41:24 +00:00
checksum = "4cd9b125c486025df0eabcb585e62173c6c9eddcec5d117d3b6e8c30e2ee4d10"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
examples: Update to windows 0.58 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:41:24 +00:00
"windows-result",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
"windows-targets 0.52.6",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "windows-sys"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
version = "0.45.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"windows-targets 0.42.2",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "windows-sys"
version = "0.48.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
dependencies = [
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"windows-targets 0.48.5",
]
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1361>
2023-12-09 10:14:28 +00:00
[[package]]
name = "windows-sys"
version = "0.52.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
dependencies = [
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
"windows-targets 0.52.6",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1361>
2023-12-09 10:14:28 +00:00
]
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1496>
2024-08-05 09:17:21 +00:00
[[package]]
name = "windows-sys"
version = "0.59.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
dependencies = [
"windows-targets 0.52.6",
]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
[[package]]
name = "windows-targets"
version = "0.42.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
dependencies = [
"windows_aarch64_gnullvm 0.42.2",
"windows_aarch64_msvc 0.42.2",
"windows_i686_gnu 0.42.2",
"windows_i686_msvc 0.42.2",
"windows_x86_64_gnu 0.42.2",
"windows_x86_64_gnullvm 0.42.2",
"windows_x86_64_msvc 0.42.2",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
name = "windows-targets"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
dependencies = [
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"windows_aarch64_gnullvm 0.48.5",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"windows_aarch64_msvc 0.48.5",
"windows_i686_gnu 0.48.5",
"windows_i686_msvc 0.48.5",
"windows_x86_64_gnu 0.48.5",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"windows_x86_64_gnullvm 0.48.5",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"windows_x86_64_msvc 0.48.5",
]
examples: Update to windows 0.52 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1351>
2023-11-17 08:58:40 +00:00
[[package]]
name = "windows-targets"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
version = "0.52.6"
examples: Update to windows 0.52 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1351>
2023-11-17 08:58:40 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
examples: Update to windows 0.52 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1351>
2023-11-17 08:58:40 +00:00
dependencies = [
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
"windows_aarch64_gnullvm 0.52.6",
"windows_aarch64_msvc 0.52.6",
"windows_i686_gnu 0.52.6",
examples: Update to windows 0.56 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1427>
2024-04-25 07:32:38 +00:00
"windows_i686_gnullvm",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
"windows_i686_msvc 0.52.6",
"windows_x86_64_gnu 0.52.6",
"windows_x86_64_gnullvm 0.52.6",
"windows_x86_64_msvc 0.52.6",
examples: Update to windows 0.52 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1351>
2023-11-17 08:58:40 +00:00
]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
[[package]]
name = "windows_aarch64_gnullvm"
version = "0.42.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "windows_aarch64_gnullvm"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
examples: Update to windows 0.52 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1351>
2023-11-17 08:58:40 +00:00
[[package]]
name = "windows_aarch64_gnullvm"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
version = "0.52.6"
examples: Update to windows 0.52 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1351>
2023-11-17 08:58:40 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
examples: Update to windows 0.52 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1351>
2023-11-17 08:58:40 +00:00
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "windows_aarch64_msvc"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
version = "0.42.2"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "windows_aarch64_msvc"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
examples: Update to windows 0.52 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1351>
2023-11-17 08:58:40 +00:00
[[package]]
name = "windows_aarch64_msvc"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
version = "0.52.6"
examples: Update to windows 0.52 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1351>
2023-11-17 08:58:40 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
examples: Update to windows 0.52 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1351>
2023-11-17 08:58:40 +00:00
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "windows_i686_gnu"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
version = "0.42.2"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "windows_i686_gnu"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
examples: Update to windows 0.52 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1351>
2023-11-17 08:58:40 +00:00
[[package]]
name = "windows_i686_gnu"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
version = "0.52.6"
examples: Update to windows 0.56 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1427>
2024-04-25 07:32:38 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
examples: Update to windows 0.56 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1427>
2024-04-25 07:32:38 +00:00
[[package]]
name = "windows_i686_gnullvm"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
version = "0.52.6"
examples: Update to windows 0.52 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1351>
2023-11-17 08:58:40 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
examples: Update to windows 0.52 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1351>
2023-11-17 08:58:40 +00:00
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "windows_i686_msvc"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
version = "0.42.2"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "windows_i686_msvc"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
examples: Update to windows 0.52 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1351>
2023-11-17 08:58:40 +00:00
[[package]]
name = "windows_i686_msvc"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
version = "0.52.6"
examples: Update to windows 0.52 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1351>
2023-11-17 08:58:40 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
examples: Update to windows 0.52 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1351>
2023-11-17 08:58:40 +00:00
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "windows_x86_64_gnu"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
version = "0.42.2"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "windows_x86_64_gnu"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
examples: Update to windows 0.52 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1351>
2023-11-17 08:58:40 +00:00
[[package]]
name = "windows_x86_64_gnu"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
version = "0.52.6"
examples: Update to windows 0.52 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1351>
2023-11-17 08:58:40 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
examples: Update to windows 0.52 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1351>
2023-11-17 08:58:40 +00:00
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
[[package]]
name = "windows_x86_64_gnullvm"
version = "0.42.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "windows_x86_64_gnullvm"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
examples: Update to windows 0.52 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1351>
2023-11-17 08:58:40 +00:00
[[package]]
name = "windows_x86_64_gnullvm"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
version = "0.52.6"
examples: Update to windows 0.52 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1351>
2023-11-17 08:58:40 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
examples: Update to windows 0.52 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1351>
2023-11-17 08:58:40 +00:00
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "windows_x86_64_msvc"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
version = "0.42.2"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "windows_x86_64_msvc"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
examples: Update to windows 0.52 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1351>
2023-11-17 08:58:40 +00:00
[[package]]
name = "windows_x86_64_msvc"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
version = "0.52.6"
examples: Update to windows 0.52 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1351>
2023-11-17 08:58:40 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
examples: Update to windows 0.52 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1351>
2023-11-17 08:58:40 +00:00
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "winit"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1410>
2024-03-19 07:18:16 +00:00
version = "0.29.15"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1410>
2024-03-19 07:18:16 +00:00
checksum = "0d59ad965a635657faf09c8f062badd885748428933dad8e8bdd64064d92e5ca"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"ahash",
"android-activity",
"atomic-waker",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
"bitflags 2.6.0",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"bytemuck",
"calloop",
"cfg_aliases",
examples: Update to cocoa 0.26 Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1512>
2024-08-27 17:44:07 +00:00
"core-foundation 0.9.4",
"core-graphics 0.23.2",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"cursor-icon",
"icrate",
"js-sys",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"libc",
"log",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"memmap2",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"ndk",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"ndk-sys",
"objc2",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"once_cell",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"orbclient",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"percent-encoding",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1369>
2023-12-22 13:10:36 +00:00
"raw-window-handle",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"redox_syscall 0.3.5",
"rustix",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"smithay-client-toolkit",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"smol_str",
"unicode-segmentation",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"wasm-bindgen",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"wasm-bindgen-futures",
"wayland-backend",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"wayland-client",
"wayland-protocols",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"wayland-protocols-plasma",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"web-sys",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"web-time",
"windows-sys 0.48.0",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"x11-dl",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"x11rb",
"xkbcommon-dl",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1395>
2024-02-16 12:22:40 +00:00
[[package]]
name = "winnow"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1550>
2024-09-28 09:17:06 +00:00
version = "0.6.20"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1395>
2024-02-16 12:22:40 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1550>
2024-09-28 09:17:06 +00:00
checksum = "36c1fec1a2bb5866f07c25f68c26e565c4c200aebb96d7e55710c19d3e8ac49b"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
"memchr",
]
[[package]]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
name = "x11-dl"
version = "2.21.0"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
checksum = "38735924fedd5314a6e548792904ed8c6de6636285cb9fec04d5b1db85c1516f"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"libc",
"once_cell",
"pkg-config",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
]
[[package]]
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
name = "x11rb"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1440>
2024-05-10 06:52:57 +00:00
version = "0.13.1"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1440>
2024-05-10 06:52:57 +00:00
checksum = "5d91ffca73ee7f68ce055750bf9f6eca0780b8c85eff9bc046a3b0da41755e12"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
dependencies = [
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"as-raw-xcb-connection",
"gethostname",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"libc",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1369>
2023-12-22 13:10:36 +00:00
"libloading",
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
"once_cell",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1369>
2023-12-22 13:10:36 +00:00
"rustix",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"x11rb-protocol",
]
[[package]]
name = "x11rb-protocol"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1440>
2024-05-10 06:52:57 +00:00
version = "0.13.1"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1440>
2024-05-10 06:52:57 +00:00
checksum = "ec107c4503ea0b4a98ef47356329af139c0a4f7750e621cf2973cd3385ebcb3d"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "xcursor"
Update Cargo.lock
2024-08-27 17:31:33 +00:00
version = "0.3.8"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock
2024-08-27 17:31:33 +00:00
checksum = "0ef33da6b1660b4ddbfb3aef0ade110c8b8a781a3b6382fa5f2b5b040fd55f61"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
[[package]]
name = "xkbcommon-dl"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1395>
2024-02-16 12:22:40 +00:00
version = "0.4.2"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1395>
2024-02-16 12:22:40 +00:00
checksum = "d039de8032a9a8856a6be89cea3e5d12fdd82306ab7c94d74e6deab2460651c5"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
dependencies = [
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
"bitflags 2.6.0",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
"dlib",
"log",
"once_cell",
"xkeysym",
]
[[package]]
name = "xkeysym"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1455>
2024-06-07 16:27:03 +00:00
version = "0.2.1"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1455>
2024-06-07 16:27:03 +00:00
checksum = "b9cc00251562a284751c9973bace760d86c0276c471b4be569fe6b068ee97a56"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
[[package]]
name = "xml-rs"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
version = "0.8.23"
Add Cargo.lock to the repository This makes sure that any broken dependency updates are not breaking our build, at the cost of requiring us to update the lock file regularly. See also https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1340>
2023-11-09 08:04:09 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1600>
2024-11-22 12:17:20 +00:00
checksum = "af310deaae937e48a26602b730250b4949e125f468f11e6990be3e5304ddd96f"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
[[package]]
name = "zerocopy"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
version = "0.7.35"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
dependencies = [
"zerocopy-derive",
]
[[package]]
name = "zerocopy-derive"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
version = "0.7.35"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1480>
2024-07-08 06:36:49 +00:00
checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
dependencies = [
"proc-macro2",
"quote",
Update Cargo.lock Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1462>
2024-06-17 05:38:13 +00:00
"syn",
examples/glupload: Upgrade to `glutin 0.31` Glutin completely detached from `winit` in the `0.30` upgrade, concerning itself exclusively with OpenGL and WSI APIs around it and leaving any windowing system interop to the `raw-window-handle` crate specifically designed for this purpose. This untanglement massively cleans up and simplifies the `glutin` codebase, and expands on surfaceless rendering as well as drawing to simple views (textures) on the screen as is common on Android, without having control over the entire "window" and event loop. Some winit boilerplate is however still provided as part of the `glutin-winit` crate. Most of the `glutin`+`winit` flow in this `glupload` example is adopted from `glutin`'s example, following platform-specific initialization sequences that heavily clutter the code (only creating a window upfront on Windows, only forcing transparency on macOS, and trying various fallback attributes to create a context). At the same time `winit`'s `Event::Resumed` and `Event::Suspended` event strategy is adopted: this event was previously for Android and iOS exclusively - where window handles come and go at the merit of the OS, rather than existing for the lifetime of the application - but is now emitted on all platforms for consistency. A `Surface` (via `RawWindowHandle`) is only available and usable after `Event::Resumed`, where we can create a GL surface and "current" the context on that surface for rendering. This is where the `GstPipeline` will be set to `Playing` so that data starts flowing. The inverse should happen in `Event::Suspended` where the `Surface` has to be given up again after un-currenting, before giving control back to the OS to free the rest of the resources. This will however be implemented when Android is brought online for these examples. Finally, now that the `gst-gl-egl` and `gst-gl-x11` features turn on the relevant features in `glutin` and `winit`, it is now possible to easily test `x11` on Wayland (over XWayland) without even unsetting `WAYLAND_DISPLAY`, by simply compiling the whole stack without EGL/ Wayland support (on the previous example `winit` would always default to a Wayland handle, while `glupload` could only create `GstGLDisplayX11`). Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1336>
2023-10-27 17:03:22 +00:00
]
Reference in a new issue Copy permalink