diff --git a/BUILD.gn b/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..f2453a7c7454800c18abfd1e172fb87a8a434fae --- /dev/null +++ b/BUILD.gn @@ -0,0 +1,541 @@ +import("//build/ohos.gni") +import("//third_party/wayland_standard/wayland_protocol.gni") + + +this is test for ljqc 2021-07-21 + + +## Generate Wayland Protocols {{{ +wayland_protocol("text_cursor_position_protocol") { + sources = [ "protocol/text-cursor-position.xml" ] +} +wayland_protocol("weston_content_protection_protocol") { + sources = [ "protocol/weston-content-protection.xml" ] +} +wayland_protocol("weston_touch_calibration_protocol") { + sources = [ "protocol/weston-touch-calibration.xml" ] +} +wayland_protocol("weston_direct_display_protocol") { + sources = [ "protocol/weston-direct-display.xml" ] +} +wayland_protocol("weston_screenshooter_protocol") { + sources = [ "protocol/weston-screenshooter.xml" ] +} +wayland_protocol("ivi_application_protocol") { + sources = [ "protocol/ivi-application.xml" ] +} +wayland_protocol("drm_auth_protocol") { + sources = [ "protocol/drm-auth.xml" ] +} + +## Generate Wayland Protocols }}} + +## Build libshared.a {{{ +config("libshared_config") { + visibility = [ ":*" ] + + include_dirs = [ + "include", + "//third_party/wayland_standard/src", + "//third_party/wayland-ivi-extension_standard/include", + ] + + cflags = [ + "-Wall", + "-Werror", + "-Wno-unused-parameter", + ] +} + +config("libshared_public_config") { + include_dirs = [ "shared" ] + + cflags = [] +} + +ohos_static_library("libshared") { + sources = [ + "shared/config-parser.c", + "shared/file-util.c", + "shared/matrix.c", + "shared/option-parser.c", + "shared/os-compatibility.c", + ] + + configs = [ ":libshared_config" ] + + public_configs = [ ":libshared_public_config" ] + + deps = [] + + public_deps = [ "//third_party/wayland_standard:libwayland_server" ] +} + +## Build libshared.a }}} + +## Build libweston.so {{{ +config("libweston_config") { + visibility = [ ":*" ] + + include_dirs = [ + "//third_party/weston/include", + "libweston", + "//third_party/wayland_standard/src", + "//third_party/wayland-ivi-extension_standard/include", + "//third_party/weston", + ] + + cflags = [ + "-Wall", + "-Werror", + "-Wno-unused-parameter", + "-Wno-unused-function", + "-Wno-missing-field-initializers", + "-Wno-unused-variable", + "-Wno-implicit-function-declaration", + ] +} + +config("libweston_public_config") { + include_dirs = [ + "include", + "libweston/backend-drm", + "//third_party/bounds_checking_function/include", + ] + + cflags = [] +} + +ohos_shared_library("libweston") { + sources = [ + "libweston/animation.c", + "libweston/bindings.c", + "libweston/clipboard.c", + "libweston/compositor.c", + "libweston/content-protection.c", + "libweston/data-device.c", + "libweston/input.c", + "libweston/launcher-direct.c", + "libweston/launcher-util.c", + "libweston/launcher-weston-launch.c", + "libweston/linux-dmabuf.c", + "libweston/linux-explicit-synchronization.c", + "libweston/linux-sync-file.c", + "libweston/pixel-formats.c", + "libweston/pixman-renderer.c", + "libweston/plugin-registry.c", + "libweston/screenshooter.c", + "libweston/tde-render-part.c", + "libweston/touch-calibration.c", + "libweston/vertex-clipping.c", + "libweston/weston-direct-display.c", + "libweston/zoom.c", + ] + + configs = [ + ":libweston_config", + ":display_gfx_public_config", + ] + + public_configs = [ + ":libweston_public_config", + ":drm-backend_public_config", + ] + + deps = [ + ":libdisplay_gfx", + "//foundation/graphic/standard/prebuilts/librarys/display_gralloc:libdisplay_gralloc", + "//third_party/libdrm:libdrm", + "//third_party/libinput:libinput-third", + "//utils/native/base:utils", + ] + + public_deps = [ + ":libshared", + ":text_cursor_position_protocol", + ":weston_content_protection_protocol", + ":weston_direct_display_protocol", + ":weston_touch_calibration_protocol", + "//base/hiviewdfx/hilog/interfaces/native/innerkits:libhilog", + "//third_party/libxkbcommon:libxkbcommon", + "//third_party/pixman:libpixman", + "//third_party/wayland-protocols_standard:input_timestamps_unstable_v1_protocol", + "//third_party/wayland-protocols_standard:linux_dmabuf_unstable_v1_protocol", + "//third_party/wayland-protocols_standard:linux_explicit_synchronization_unstable_v1_protocol", + "//third_party/wayland-protocols_standard:pointer_constraints_unstable_v1_protocol", + "//third_party/wayland-protocols_standard:presentation_time_protocol", + "//third_party/wayland-protocols_standard:relative_pointer_unstable_v1_protocol", + "//third_party/wayland-protocols_standard:viewporter_protocol", + "//third_party/wayland-protocols_standard:xdg_output_unstable_v1_protocol", + ] + + part_name = "graphic_standard" + subsystem_name = "graphic" +} + +## Build libweston.so }}} + +## Build libexec_weston.a {{{ +config("libexec_weston_config") { + visibility = [ ":*" ] + + include_dirs = [ + "libweston", + ".", + ] + + cflags = [ + "-Wall", + "-Werror", + "-Wno-unused-parameter", + "-Wno-missing-field-initializers", + "-Wno-unused-variable", + ] +} + +config("libexec_weston_public_config") { + include_dirs = [] + + cflags = [] +} + +ohos_static_library("libexec_weston") { + sources = [ + "compositor/main.c", + "compositor/text-backend.c", + "compositor/weston-screenshooter.c", + ] + + configs = [ ":libexec_weston_config" ] + + public_configs = [ ":libexec_weston_public_config" ] + + deps = [ + ":weston_screenshooter_protocol", + "//third_party/libinput:libinput-third", + "//third_party/wayland-protocols_standard:input_method_unstable_v1_protocol", + "//third_party/wayland-protocols_standard:text_input_unstable_v1_protocol", + ] + + public_deps = [ + ":libweston", + "//third_party/wayland_standard:wayland_core_protocol", + ] +} + +## Build libexec_weston.a }}} + +## Build weston {{{ +config("weston_config") { + visibility = [ ":*" ] + + include_dirs = [] + + cflags = [ + "-Wall", + "-Werror", + ] +} + +config("weston_public_config") { + include_dirs = [] + + cflags = [] +} + +ohos_executable("weston") { + install_enable = true + + sources = [ "compositor/executable.c" ] + + configs = [ ":weston_config" ] + + public_configs = [ ":weston_public_config" ] + + deps = [ ":libexec_weston" ] + + public_deps = [] + + subsystem_name = "graphic" + part_name = "graphic_standard" +} + +## Build weston }}} + +## Build libweston-desktop.so {{{ +config("libweston-desktop_config") { + visibility = [ ":*" ] + + include_dirs = [ "." ] + + cflags = [ + "-Wall", + "-Werror", + "-Wno-unused-function", + ] +} + +config("libweston-desktop_public_config") { + include_dirs = [ "include/libweston-desktop" ] + + cflags = [] +} + +ohos_shared_library("libweston-desktop") { + sources = [ + "libweston-desktop/client.c", + "libweston-desktop/libweston-desktop.c", + "libweston-desktop/seat.c", + "libweston-desktop/surface.c", + "libweston-desktop/wl-shell.c", + "libweston-desktop/xdg-shell-v6.c", + "libweston-desktop/xdg-shell.c", + ] + + configs = [ ":libweston-desktop_config" ] + + public_configs = [ ":libweston-desktop_public_config" ] + + deps = [] + + public_deps = [ + ":libexec_weston", + "//third_party/wayland-protocols_standard:xdg_shell_protocol", + "//third_party/wayland-protocols_standard:xdg_shell_unstable_v6_protocol", + ] + + part_name = "graphic_standard" + subsystem_name = "graphic" +} + +## Build libweston-desktop.so }}} + +## Build ivi-shell.so {{{ +config("ivi-shell_config") { + visibility = [ ":*" ] + + include_dirs = [ "." ] + + cflags = [ + "-Wall", + "-Werror", + "-Wno-unused-function", + ] +} + +config("ivi-shell_public_config") { + include_dirs = [] + + cflags = [] +} + +ohos_shared_library("ivi-shell") { + sources = [ + "ivi-shell/ivi-layout-transition.c", + "ivi-shell/ivi-layout.c", + "ivi-shell/ivi-shell.c", + ] + + configs = [ ":ivi-shell_config" ] + + public_configs = [ ":ivi-shell_public_config" ] + + deps = [ + ":ivi_application_protocol", + ":libweston-desktop", + "//third_party/wayland_standard:wayland_core_protocol", + ] + + public_deps = [] + + subsystem_name = "graphic" + part_name = "graphic_standard" +} + +## Build ivi-shell.so }}} + +## Build drm-backend.so {{{ +config("drm-backend_config") { + visibility = [ ":*" ] + + include_dirs = [ + "include", + "libweston", + "libweston/backend-drm/auth", + ".", + ] + + cflags = [ + "-Wall", + "-Wno-error", + "-Wno-unused-parameter", + "-Wno-missing-field-initializers", + "-Wno-implicit-function-declaration", + "-Wno-unused-variable", + "-Wno-unused-function", + "-Wno-sometimes-uninitialized", + ] +} + +config("drm-backend_public_config") { + include_dirs = [] + + cflags = [] +} + +ohos_executable("simple-preasenation") { + sources = [ + "clients/presentation-shm.c", + # "libweston/backend-drm/drm-gbm.c", + ] + + configs = [ ":drm-backend_config" ] + + public_configs = [ ":drm-backend_public_config" ] + + deps = [ + "//third_party/wayland-protocols_standard:presentation_time_protocol", + "//third_party/wayland_standard:libwayland_client", + "//third_party/wayland_standard:libwayland_cursor", + "//third_party/wayland_standard:wayland_core_protocol", + "//third_party/weston:ivi_application_protocol", + ] + + part_name = "graphic_standard" + subsystem_name = "graphic" +} + +ohos_shared_library("drm-backend") { + sources = [ + "libweston/backend-drm/auth/wayland_drm_auth_server.c", + "libweston/backend-drm/drm.c", + "libweston/backend-drm/fb.c", + "libweston/backend-drm/kms.c", + "libweston/backend-drm/libbacklight.c", + "libweston/backend-drm/modes.c", + "libweston/backend-drm/state-helpers.c", + "libweston/backend-drm/state-propose.c", + "libweston/libinput-device.c", + "libweston/libinput-seat.c", + + # "libweston/backend-drm/drm-gbm.c", + ] + + configs = [ ":drm-backend_config" ] + + public_configs = [ ":drm-backend_public_config" ] + + deps = [ + ":drm_auth_protocol", + ":libweston", + "//third_party/libdrm:libdrm", + "//third_party/libinput:libinput-third", + "//third_party/wayland-protocols_standard:linux_dmabuf_unstable_v1_protocol", + "//third_party/wayland-protocols_standard:presentation_time_protocol", + "//third_party/wayland-protocols_standard:relative_pointer_unstable_v1_protocol", + "//third_party/wayland_standard:wayland_core_protocol", + ] + + public_deps = [] + + part_name = "graphic_standard" + subsystem_name = "graphic" +} + +## Build drm-backend.so }}} + +## Install weston.ini to /system/etc/weston.ini {{{ +ohos_prebuilt_etc("weston.ini") { + source = "weston.ini" + part_name = "graphic_standard" + subsystem_name = "graphic" +} + +## Install weston.ini to /system/etc/weston.ini }}} + +## Install weston.rc to /system/etc/init/weston.rc {{{ +ohos_prebuilt_etc("weston.rc") { + source = "weston.rc" + relative_install_dir = "init" + part_name = "graphic_standard" + subsystem_name = "graphic" +} + +## Install weston.rc to /system/etc/init/weston.rc }}} + +# gl-renderer.so waiting for libEGL & libGLESv2 +### Build gl-renderer.so {{{ +#config("gl-renderer_config") { +# visibility = [ ":*" ] +# +# include_dirs = [ +# "//third_party/weston", +# "//third_party/wayland_standard/egl", +# "//third_party/weston/libweston", +# "//third_party/wayland-ivi-extension_standard/include", +# ] +# +# cflags = [ +# "-Wno-return-type", +# "-Wno-visibility", +# "-Wno-unused-function", +# ] +#} +# +#config("gl-renderer_public_config") { +# include_dirs = [ +# ] +# +# cflags = [ +# ] +#} +# +#ohos_shared_library("gl-renderer") { +# sources = [ +# "libweston/renderer-gl/egl-glue.c", +# "libweston/renderer-gl/gl-renderer.c", +# "libweston/vertex-clipping.c", +# ] +# +# configs = [ +# ":gl-renderer_config", +# ] +# +# public_configs = [ +# ":gl-renderer_public_config", +# ] +# +# deps = [ +# ":libweston", +# "//third_party/wayland-protocols_standard:linux_dmabuf_unstable_v1_protocol", +# ] +# +# asdk_deps = [ +# "shared_library:libEGL", +# "shared_library:libGLESv2", +# ] +# +# public_deps = [ +# ] +# +# subsystem_name = "graphic" +# part_name = "graphic_standard" +#} +### Build gl-renderer.so }}} + +## Prebuilt libdisplay_gfx.so {{{ +config("display_gfx_public_config") { + include_dirs = [ "//drivers/peripheral/display/interfaces/include" ] + + libs = [ "//device/hisilicon/hardware/display/libs/hispark_taurus/ext/libdisplay_gfx.z.so" ] +} + +ohos_prebuilt_shared_library("libdisplay_gfx") { + source = "//device/hisilicon/hardware/display/libs/hispark_taurus/ext/libdisplay_gfx.z.so" + + public_configs = [ ":display_gfx_public_config" ] + + part_name = "graphic_standard" + subsystem_name = "graphic" +} +## Prebuilt libdisplay_gfx.so }}} diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000000000000000000000000000000000000..98fa565d439b44ad21815b3fa9317563aafde906 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,372 @@ +Contributing to Weston +======================= + +Finding something to work on +---------------------------- + +Weston's development is [tracked on GitLab](https://gitlab.freedesktop.org/wayland/weston). +In addition to reviewing code submissions (see below), we use the issue tracker +to discuss both bugfixes and development of new features. + +The '[good for new contributors](https://gitlab.freedesktop.org/wayland/weston/issues?label_name%5B%5D=Good+for+new+contributors)' +label is used for issues the development team thinks are a good place to begin +working on Weston. These issues cover features or bugfixes which are small, +self-contained, don't require much specific background knowledge, and aren't +blocked by more complex work. + +If you have picked an issue you would like to work on, you may want to mention +in the issue tracker that you would like to pick it up. You can also discuss +it with the developers in the issue tracker, or on the +[mailing list](https://lists.freedesktop.org/mailman/listinfo/wayland-devel). +Many developers also use IRC through [Freenode](https://freenode.net)'s +`#wayland` channel; however you may need to wait some time for a response on +IRC, which requires keeping your client connected. If you cannot stay for a +long time (potentially some hours due to timezone differences), then you +may want to send your question to the list or issue tracker instead. + + +Sending patches +--------------- + +Patches should be sent via +[GitLab merge requests](https://docs.gitlab.com/ce/gitlab-basics/add-merge-request.html). +Weston is +[hosted on freedesktop.org's GitLab](https://gitlab.freedesktop.org/wayland/weston/): +in order to submit code, you should create an account on this GitLab instance, +fork the core Weston repository, push your changes to a branch in your new +repository, and then submit these patches for review through a merge request. + +Weston formerly accepted patches via `git-send-email`, sent to +**wayland-devel\@lists.freedesktop.org**; these were +[tracked using Patchwork](https://patchwork.freedesktop.org/projects/wayland/). +Some old patches continue to be sent this way, and we may accept small new +patches sent to the list, but please send all new patches through GitLab merge +requests. + +Formatting and separating commits +--------------------------------- + +Unlike many projects using GitHub and GitLab, Weston has a +[linear, 'recipe' style history](http://www.bitsnbites.eu/git-history-work-log-vs-recipe/). +This means that every commit should be small, digestible, stand-alone, and +functional. Rather than a purely chronological commit history like this: + + doc: final docs for view transforms + fix tests when disabled, redo broken doc formatting + better transformed-view iteration (thanks Hannah!) + try to catch more cases in tests + tests: add new spline test + fix compilation on splines + doc: notes on reticulating splines + compositor: add spline reticulation for view transforms + +we aim to have a clean history which only reflects the final state, broken up +into functional groupings: + + compositor: add spline reticulation for view transforms + compositor: new iterator for view transforms + tests: add view-transform correctness tests + doc: fix Doxygen formatting for view transforms + +This ensures that the final patch series only contains the final state, +without the changes and missteps taken along the development process. + +The first line of a commit message should contain a prefix indicating +what part is affected by the patch followed by one sentence that +describes the change. For examples: + + compositor-drm: Support modifiers for drm_fb + +and + + input: do not forward unmatched touch-ups + +If in doubt what prefix to use, look at other commits that change the +same file(s) as the patch being sent. + +The body of the commit message should describe what the patch changes +and why, and also note any particular side effects. This shouldn't be +empty on most of the cases. It shouldn't take a lot of effort to write +a commit message for an obvious change, so an empty commit message +body is only acceptable if the questions "What?" and "Why?" are already +answered on the one-line summary. + +The lines of the commit message should have at most 76 characters, to +cope with the way git log presents them. + +See [notes on commit messages] for a recommended reading on writing commit +messages. + +Your patches should also include a Signed-off-by line with your name and +email address which indicates that you agree to the +[Developer's Certificate of Origin 1.1](DCO-1.1.txt). +If you're not the patch's original author, you should +also gather S-o-b's by them (and/or whomever gave the patch to you.) The +significance of this is that it certifies that you created the patch, +that it was created under an appropriate open source license, or +provided to you under those terms. This lets us indicate a chain of +responsibility for the copyright status of the code. + +We won't reject patches that lack S-o-b, but it is strongly recommended. + +When you re-send patches, revised or not, it would be very good to document the +changes compared to the previous revision in the commit message and/or the +merge request. If you have already received Reviewed-by or Acked-by tags, you +should evaluate whether they still apply and include them in the respective +commit messages. Otherwise the tags may be lost, reviewers miss the credit they +deserve, and the patches may cause redundant review effort. + + +Tracking patches and following up +--------------------------------- + +Once submitted to GitLab, your patches will be reviewed by the Weston +development team on GitLab. Review may be entirely positive and result in your +code landing instantly, in which case, great! You're done. However, we may ask +you to make some revisions: fixing some bugs we've noticed, working to a +slightly different design, or adding documentation and tests. + +If you do get asked to revise the patches, please bear in mind the notes above. +You should use `git rebase -i` to make revisions, so that your patches follow +the clear linear split documented above. Following that split makes it easier +for reviewers to understand your work, and to verify that the code you're +submitting is correct. + +A common request is to split single large patch into multiple patches. This can +happen, for example, if when adding a new feature you notice a bug in Weston's +core which you need to fix to progress. Separating these changes into separate +commits will allow us to verify and land the bugfix quickly, pushing part of +your work for the good of everyone, whilst revision and discussion continues on +the larger feature part. It also allows us to direct you towards reviewers who +best understand the different areas you are working on. + +When you have made any requested changes, please rebase the commits, verify +that they still individually look good, then force-push your new branch to +GitLab. This will update the merge request and notify everyone subscribed to +your merge request, so they can review it again. + +There are also +[many GitLab CLI clients](https://about.gitlab.com/applications/#cli-clients), +if you prefer to avoid the web interface. It may be difficult to follow review +comments without using the web interface though, so we do recommend using this +to go through the review process, even if you use other clients to track the +list of available patches. + + +Coding style +------------ + +You should follow the style of the file you're editing. In general, we +try to follow the rules below. + +**Note: this file uses spaces due to markdown rendering issues for tabs. + Code must be indented using tabs.** + +- indent with tabs, and a tab is always 8 characters wide +- opening braces are on the same line as the if statement; +- no braces in an if-body with just one statement; +- if one of the branches of an if-else condition has braces, then the + other branch should also have braces; +- there is always an empty line between variable declarations and the + code; + +```c +static int +my_function(void) +{ + int a = 0; + + if (a) + b(); + else + c(); + + if (a) { + b(); + c(); + } else { + d(); + } +} +``` + +- lines should be less than 80 characters wide; +- when breaking lines with functions calls, the parameters are aligned + with the opening parentheses; +- when assigning a variable with the result of a function call, if the + line would be longer we break it around the equal '=' sign if it makes + sense; + +```c + long_variable_name = + function_with_a_really_long_name(parameter1, parameter2, + parameter3, parameter4); + + x = function_with_a_really_long_name(parameter1, parameter2, + parameter3, parameter4); +``` + +Conduct +======= + +As a freedesktop.org project, Wayland follows the Contributor Covenant, +found at: +https://www.freedesktop.org/wiki/CodeOfConduct + +Please conduct yourself in a respectful and civilised manner when +interacting with community members on mailing lists, IRC, or bug +trackers. The community represents the project as a whole, and abusive +or bullying behaviour is not tolerated by the project. + + +Licensing +========= + +Weston is licensed with the intention to be usable anywhere X.org is. +Originally, X.org was covered under the MIT X11 license, but changed to +the MIT Expat license. Similarly, Weston was covered initially as MIT +X11 licensed, but changed to the MIT Expat license, following in X.org's +footsteps. Other than wording, the two licenses are substantially the +same, with the exception of a no-advertising clause in X11 not included +in Expat. + +New source code files should specify the MIT Expat license in their +boilerplate, as part of the copyright statement. + + +Review +====== + +All patches, even trivial ones, require at least one positive review +(Reviewed-by). Additionally, if no Reviewed-by's have been given by +people with commit access, there needs to be at least one Acked-by from +someone with commit access. A person with commit access is expected to be +able to evaluate the patch with respect to the project scope and architecture. + +The below review guidelines are intended to be interpreted in spirit, not by +the letter. There may be circumstances where some guidelines are better +ignored. We rely very much on the judgement of reviewers and commit rights +holders. + +During review, the following matters should be checked: + +- The commit message explains why the change is being made. + +- The code fits the project's scope. + +- The code license is the same MIT licence the project generally uses. + +- Stable ABI or API is not broken. + +- Stable ABI or API additions must be justified by actual use cases, not only +by speculation. They must also be documented, and it is strongly recommended to +include tests exercising the additions in the test suite. + +- The code fits the existing software architecture, e.g. no layering +violations. + +- The code is correct and does not introduce new failures for existing users, +does not add new corner-case bugs, and does not introduce new compiler +warnings. + +- The patch does what it says in the commit message and changes nothing else. + +- The patch is a single logical change. If the commit message addresses +multiple points, it is a hint that the commit might need splitting up. + +- A bug fix should target the underlying root cause instead of hiding symptoms. +If a complete fix is not practical, partial fixes are acceptable if they come +with code comments and filed Gitlab issues for the remaining bugs. + +- The bug root cause rule applies to external software components as well, e.g. +do not work around kernel driver issues in userspace. + +- The test suite passes. + +- The code does not depend on API or ABI which has no working free open source +implementation. + +- The code is not dead or untestable. E.g. if there are no free open source +software users for it then it is effectively dead code. + +- The code is written to be easy to understand, or if code cannot be clear +enough on its own there are code comments to explain it. + +- The code is minimal, i.e. prefer refactor and re-use when possible unless +clarity suffers. + +- The code adheres to the style guidelines. + +- In a patch series, every intermediate step adheres to the above guidelines. + + +Commit rights +============= + +Commit rights will be granted to anyone who requests them and fulfills the +below criteria: + +- Submitted some (10 as a rule of thumb) non-trivial (not just simple + spelling fixes and whitespace adjustment) patches that have been merged + already. + +- Are actively participating in public discussions about their work (on the + mailing list or IRC). This should not be interpreted as a requirement to + review other peoples patches but just make sure that patch submission isn't + one-way communication. Cross-review is still highly encouraged. + +- Will be regularly contributing further patches. This includes regular + contributors to other parts of the open source graphics stack who only + do the occasional development in this project. + +- Agrees to use their commit rights in accordance with the documented merge + criteria, tools, and processes. + +To apply for commit rights, create a new issue in gitlab for the respective +project and give it the "accounts" label. + +Committers are encouraged to request their commit rights get removed when they +no longer contribute to the project. Commit rights will be reinstated when they +come back to the project. + +Maintainers and committers should encourage contributors to request commit +rights, especially junior contributors tend to underestimate their skills. + + +Stabilising for releases +======================== + +A release cycle ends with a stable release which also starts a new cycle and +lifts any code freezes. Gradual code freezing towards a stable release starts +with an alpha release. The release stages of a cycle are: + +- **Alpha release**: + Signified by version number #.#.91. + Major features must have landed before this. Major features include + invasive code motion and refactoring, high risk changes, and new stable + library ABI. + +- **Beta release**: + Signified by version number #.#.92. + Minor features must have landed before this. Minor features include all + new features that are not major, low risk changes, clean-ups, and + documentation. Stable ABI that was new in the alpha release can be removed + before a beta release if necessary. + +- **Release candidates (RC)**: + Signified by version number #.#.93 and up to #.#.99. + Bug fixes that are not release critical must have landed before this. + Release critical bug fixes can still be landed after this, but they may + call for another RC. + +- **Stable release**: + Signified by version number #.#.0. + Ideally no changes since the last RC. + +Mind that version #.#.90 is never released. It is used during development when +no code freeze is in effect. Stable branches and point releases are not covered +by the above. + + +[git documentation]: http://git-scm.com/documentation +[notes on commit messages]: http://who-t.blogspot.de/2009/12/on-commit-messages.html diff --git a/COPYING b/COPYING new file mode 100644 index 0000000000000000000000000000000000000000..fa4a8c48e13fbeccb02a740bff2ee11df553773d --- /dev/null +++ b/COPYING @@ -0,0 +1,26 @@ + + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice (including the next +paragraph) shall be included in all copies or substantial portions of the +Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. + +--- + +The above is the version of the MIT "Expat" License used by X.org: + + http://cgit.freedesktop.org/xorg/xserver/tree/COPYING diff --git a/DCO-1.1.txt b/DCO-1.1.txt new file mode 100644 index 0000000000000000000000000000000000000000..1ffe05c3e20022e9aa7dca0499567b2d5aaecfb0 --- /dev/null +++ b/DCO-1.1.txt @@ -0,0 +1,38 @@ +test +Developer Certificate of Origin +Version 1.1 + +Copyright (C) 2004, 2006 The Linux Foundation and its contributors. +1 Letterman Drive +Suite D4700 +San Francisco, CA, 94129 + +Everyone is permitted to copy and distribute verbatim copies of this +license document, but changing it is not allowed. + + +Developer's Certificate of Origin 1.1 + +By making a contribution to this project, I certify that: + +(a) The contribution was created in whole or in part by me and I + have the right to submit it under the open source license + indicated in the file; or + +(b) The contribution is based upon previous work that, to the best + of my knowledge, is covered under an appropriate open source + license and I have the right under that license to submit that + work with modifications, whether created in whole or in part + by me, under the same open source license (unless I am + permitted to submit under a different license), as indicated + in the file; or + +(c) The contribution was provided directly to me by some other + person who certified (a), (b) or (c) and I have not modified + it. + +(d) I understand and agree that this project and the contribution + are public and that a record of the contribution (including all + personal information I submit with it, including my sign-off) is + maintained indefinitely and may be redistributed consistent with + this project or the open source license(s) involved. diff --git a/OAT.xml b/OAT.xml new file mode 100644 index 0000000000000000000000000000000000000000..90cd95bd7bf389554b50bd03e71b5a3c5f32ff5e --- /dev/null +++ b/OAT.xml @@ -0,0 +1,72 @@ + + + + + + COPYING + + + + + + + + + + + + + diff --git a/README.OpenSource b/README.OpenSource new file mode 100644 index 0000000000000000000000000000000000000000..9d1c806e7a8b8b47b9555b361be02b769111952f --- /dev/null +++ b/README.OpenSource @@ -0,0 +1,11 @@ +[ + { + "Name": "weston", + "License": "MIT license", + "License File": "COPYING", + "Version Number": "9.0.0", + "Owner": "lizheng2@huawei.com", + "Upstream URL": "https://wayland.freedesktop.org/releases/weston-9.0.0.tar.xz", + "Description": "Weston is the reference implementation of a Wayland compositor, as well as a useful environment in and of itself." + } +] diff --git a/README.md b/README.md index 25dc9639cb9d50c73819a7faa7993d45dbb6882a..30da9afa413d6161774f3b154f5c1b87f0e4e821 100644 --- a/README.md +++ b/README.md @@ -1,53 +1,361 @@ -# python +测试 +Weston +====== -# Python for OHOS +![screenshot of skeletal Weston desktop](doc/wayland-screenshot.jpg) -#### 介绍 -这个仓库是为了能够在OpenHarmony设备上使用 Python 进行应用程序开发而创建。 -[1. 使用Python开发OpenHarmony设备程序（0-初体验）](https://harmonyos.51cto.com/posts/1887) +Weston is the reference implementation of a Wayland compositor, as well as a +useful environment in and of itself. +Out of the box, Weston provides a very basic desktop, or a full-featured +environment for non-desktop uses such as automotive, embedded, in-flight, +industrial, kiosks, set-top boxes and TVs. It also provides a library allowing +other projects to build their own full-featured environments on top of Weston's +core. -## 以下说明针对lite-python文件夹下的代码 -#### 软件架构 -这个仓库下的 Baseline 是 [MicroPython v1.13](https://github.com/micropython/micropython/tree/v1.13)，在 MicroPython 的基础上进行了必要的剪裁以满足 OHOS 上的应用开发需求。 +The core focus of Weston is correctness and reliability. Weston aims to be lean +and fast, but more importantly, to be predictable. Whilst Weston does have known +bugs and shortcomings, we avoid unknown or variable behaviour as much as +possible, including variable performance such as occasional spikes in frame +display time. -#### 编译说明 -1. 编译环境： - 1）OS - Ubuntu 16+ - 2）Make - 3.81+ - 3）Python - 3.8+ -2. 配置交叉编译器： - 1）打开源码根目录中的 Makefile - 2）对变量 CROSS_COMPILE 进行赋值，如：CROSS_COMPILE ?= /home/harmony/gcc_riscv32/bin/riscv32-unknown-elf- -3. 在源码根目录中执行 make +A small suite of example or demo clients are also provided: though they can be +useful in themselves, their main purpose is to be an example or test case for +others building compositors or clients. -#### 使用说明 -1. 将编译得到的库文件 //build/libdtpython.a 拷贝到 //vendor/hisi/hi3861/hi3861/build/libs 目录下，如图： -![输入图片说明](https://images.gitee.com/uploads/images/2020/1130/102742_bea41b9a_8048968.png "82c43e952c89d664c1513719385ef6b12ba1a7.png") -2. 在设备应用中加载 Python 并执行代码 +If you are after a more mainline desktop experience, the +[GNOME](https://www.gnome.org) and [KDE](https://www.kde.org) projects provide +full-featured desktop environments built on the Wayland protocol. Many other +projects also exist providing Wayland clients and desktop environments: you are +not limited to just what you can find in Weston. -``` -#include "dtpython.h" +Reporting issues and contributing +================================= -extern const char* c_test_py; // test.py -extern const char* c_another_py; // another.py +Weston's development is +[hosted on freedesktop.org GitLab](https://gitlab.freedesktop.org/wayland/weston/). +Please also see [the contributing document](CONTRIBUTING.md), which details how +to make code or non-technical contributions to Weston. -static void DTPython_Demo_Entry(void) -{ - printf("[DTPython_Demo] DTPython_Demo_Entry()\n"); +Building Weston +=============== - DTPython_Init(); // 初始化Python环境 +Weston is built using [Meson](https://mesonbuild.com/). Weston often depends +on the current release versions of +[Wayland](https://gitlab.freedesktop.org/wayland/wayland) and +[wayland-protocols](https://cgit.freedesktop.org/wayland/wayland-protocols). - DTPython_RunCode("print(\'Python Code Begin\')"); // 执行Python语句：print('Python Code Begin') - - DTPython_RunCode("s = \'HOS Device Development\'"); // 执行Python语句：s = 'HOS Device Development' - DTPython_RunCode("print(s)"); // 执行Python语句：print(s) +If necessary, the latest Meson can be installed as a user with: - DTPython_RunCode(c_test_py); // 模拟执行Python文件：DTPython_RunFile("test.py"); - DTPython_RunCode(c_another_py); // 模拟执行Python文件：DTPython_RunFile("another.py"); + $ pip3 install --user meson - DTPython_RunCode("print(\'Python Code End\')"); // 执行Python语句：print('Python Code End') +Weston's Meson build does not do autodetection and it defaults to all +features enabled, which means you likely hit missing dependencies on the first +try. If a dependency is avoidable through a build option, the error message +should tell you what option can be used to avoid it. You may need to disable +several features if you want to avoid certain dependencies. - DTPython_Deinit(); // 清理Python环境 -} -``` + $ git clone https://gitlab.freedesktop.org/wayland/weston.git + $ cd weston + $ meson build/ --prefix=... + $ ninja -C build/ install + $ cd .. + +The `meson` command populates the build directory. This step can +fail due to missing dependencies. Any build options you want can be added on +that line, e.g. `meson build/ --prefix=... -Ddemo-clients=false`. All the build +options can be found in the file [meson_options.txt](meson_options.txt). + +Once the build directory has been successfully populated, you can inspect the +configuration with `meson configure build/`. If you need to change an +option, you can do e.g. `meson configure build/ -Ddemo-clients=false`. + +Every push to the Weston master repository and its forks is built using GitLab +CI. [Reading the configuration](.gitlab-ci.yml) may provide a useful example of +how to build and install Weston. + +More [detailed documentation on building Weston](https://wayland.freedesktop.org/building.html) +is available on the Wayland site. There are also more details on +[how to run and write tests](https://wayland.freedesktop.org/testing.html). + +For building the documentation see [weston-doc](#weston-doc). + +Running Weston +============== + +Once Weston is installed, most users can simply run it by typing `weston`. This +will launch Weston inside whatever environment you launch it from: when launched +from a text console, it will take over that console. When launched from inside +an existing Wayland or X11 session, it will start a 'nested' instance of Weston +inside a window in that session. + +Help is available by running `weston --help`, or `man weston`, which will list +the available configuration options and display backends. It can also be +configured through a file on disk; more information on this can be found through +`man weston.ini`. + +In some special cases, such as when running remotely or without logind's session +control, Weston may not be able to run directly from a text console. In these +situations, you can instead execute the `weston-launch` helper, which will gain +privileged access to input and output devices by running as root, then granting +access to the main Weston binary running as your user. Running Weston this way +is not recommended unless necessary. + +Weston-doc +========== + +For documenting weston we use [sphinx](http://www.sphinx-doc.org/en/master/) +together with [breathe](https://breathe.readthedocs.io/en/latest/) that +understands XMLs databases generated by doxygen. So far, this is a compromise +until better tools are available in order to remove the doxygen +dependency. You should be able to install both sphinx and breathe extension +using pip3 command, or your package manager. +Doxygen should be available using your distribution package manager. + +Once those are set-up, run `meson` with `-Ddoc=true` option in order to enable +building the documentation. Installation will place the documentation in the +prefix's path under datadir (i.e., `share/doc`). + +Adding and improving documentation +---------------------------------- + +For re-generating the documentation a special `docs` target has been added. +Although first time you build (and subsequently install) weston, you'll see the +documentation being built, updates to the spinx documentation files or to the +source files will only be updated when using `docs` target! + +Example: + +~~~~ +$ ninja install # generates and installs the documentation +# time passes, hack hack, add doc in sources or rST files +$ ninja install # not sufficient, docs will not be updated +$ ninja docs && ninja install # run 'docs' then install +~~~~ + +Improving/adding documentation can be done by modifying rST files under +`doc/sphinx/` directory or by modifying the source code using doxygen +directives. + +Libweston +========= + +Libweston is an effort to separate the re-usable parts of Weston into +a library. Libweston provides most of the boring and tedious bits of +correctly implementing core Wayland protocols and interfacing with +input and output systems, so that people who just want to write a new +"Wayland window manager" (WM) or a small desktop environment (DE) can +focus on the WM part. + +Libweston was first introduced in Weston 1.12, and is expected to +continue evolving through many Weston releases before it achieves a +stable API and feature completeness. + +Libweston's primary purpose is exporting an API for creating Wayland +compositors. Libweston's secondary purpose is to export the weston_config API +so that third party plugins and helper programs can read `weston.ini` if they +want to. However, these two scopes are orthogonal and independent. At no point +will the compositor functionality use or depend on the weston_config +functionality. + + +API/ABI (in)stability and parallel installability +------------------------------------------------- + +As libweston's API surface is huge, it is impossible to get it right +in one go. Therefore developers reserve the right to break the API/ABI and bump +the major version to signify that. For git snapshots of the master branch, the +API/ABI can break any time without warning. + +Libweston major can be bumped only once during a development cycle. This should +happen on the first patch that breaks the API or ABI. Further breaks before the +next Weston major.0.0 release do not cause a bump. This means that libweston +API and ABI are allowed to break also after an alpha release, up to the final +release. However, breaks after alpha should be judged by the usual practices +for allowing minor features, fixes only, or critical fixes only. + +To make things tolerable for libweston users despite API/ABI breakages, +different libweston major versions are designed to be perfectly +parallel-installable. This way external projects can easily depend on a +particular API/ABI-version. Thus they do not have to fight over which +ABI-version is installed in a user's system. This allows a user to install many +different compositors each requiring a different libweston ABI-version without +tricks or conflicts. + +Note, that versions of Weston itself will not be parallel-installable, +only libweston is. + +For more information about parallel installability, see +http://ometer.com/parallel.html + + +Versioning scheme +----------------- + +In order to provide consistent, easy to use versioning, libweston +follows the rules in the Apache Portable Runtime Project +http://apr.apache.org/versioning.html. + +The document provides the full details, with the gist summed below: + - Major - backward incompatible changes. + - Minor - new backward compatible features. + - Patch - internal (implementation specific) fixes. + +Weston and libweston have separate version numbers in meson.build. All +releases are made by the Weston version number. Libweston version number +matches the Weston version number in all releases except maybe pre-releases. +Pre-releases have the Weston micro version 91 or greater. + +A pre-release is allowed to install a libweston version greater than the Weston +version in case libweston major was bumped. In that case, the libweston version +must be Weston major + 1. + +Pkg-config files are named after libweston major, but carry the Weston version +number. This means that Weston pre-release 2.1.91 may install libweston-3.pc +for the future libweston 3.0.0, but the .pc file says the version is still +2.1.91. When a libweston user wants to depend on the fully stable API and ABI +of a libweston major, he should use (e.g. for major 3): + + PKG_CHECK_MODULES(LIBWESTON, [libweston-3 >= 3.0.0]) + +Depending only on libweston-3 without a specific version number still allows +pre-releases which might have different API or ABI. + + +Forward compatibility +--------------------- + +Inspired by ATK, Qt and KDE programs/libraries, libjpeg-turbo, GDK, +NetworkManager, js17, lz4 and many others, libweston uses a macro to restrict +the API visible to the developer - REQUIRE_LIBWESTON_API_VERSION. + +Note that different projects focus on different aspects - upper and/or lower +version check, default to visible/hidden old/new symbols and so on. + +libweston aims to guard all newly introduced API, in order to prevent subtle +breaks that a simple recompile (against a newer version) might cause. + +The macro is of the format 0x$MAJOR$MINOR and does not include PATCH version. +As mentioned in the Versioning scheme section, the latter does not reflect any +user visible API changes, thus should be not considered part of the API version. + +All new symbols should be guarded by the macro like the example given below: + +~~~~ +#if REQUIRE_LIBWESTON_API_VERSION >= 0x0101 + +bool +weston_ham_sandwich(void); + +#endif +~~~~ + +In order to use the said symbol, the one will have a similar code in their +configure.ac: + +~~~~ +PKG_CHECK_MODULES(LIBWESTON, [libweston-1 >= 1.1]) +AC_DEFINE(REQUIRE_LIBWESTON_API_VERSION, [0x0101]) +~~~~ + +If the user is _not_ interested in forward compatibility, they can use 0xffff +or similar high value. Yet doing so is not recommended. + + +Libweston design goals +---------------------- + +The high-level goal of libweston is to decouple the compositor from +the shell implementation (what used to be shell plugins). + +Thus, instead of launching 'weston' with various arguments to choose the +shell, one would launch the shell itself, e.g. 'weston-desktop', +'weston-ivi', 'orbital', etc. The main executable (the hosting program) +will implement the shell, while libweston will be used for a fundamental +compositor implementation. + +Libweston is also intended for use by other project developers who want +to create new "Wayland WMs". + +Details: + +- All configuration and user interfaces will be outside of libweston. + This includes command line parsing, configuration files, and runtime + (graphical) UI. + +- The hosting program (main executable) will be in full control of all + libweston options. Libweston should not have user settable options + that would work behind the hosting program's back, except perhaps + debugging features and such. + +- Signal handling will be outside of libweston. + +- Child process execution and management will be outside of libweston. + +- The different backends (drm, fbdev, x11, etc) will be an internal + detail of libweston. Libweston will not support third party + backends. However, hosting programs need to handle + backend-specific configuration due to differences in behaviour and + available features. + +- Renderers will be libweston internal details too, though again the + hosting program may affect the choice of renderer if the backend + allows, and maybe set renderer-specific options. + +- plugin design ??? + +- xwayland ??? + +- weston-launch is still with libweston even though it can only launch + Weston and nothing else. We would like to allow it to launch any compositor, + but since it gives by design root access to input devices and DRM, how can + we restrict it to intended programs? + +There are still many more details to be decided. + + +For packagers +------------- + +Always build Weston with --with-cairo=image. + +The Weston project is (will be) intended to be split into several +binary packages, each with its own dependencies. The maximal split +would be roughly like this: + +- libweston (minimal dependencies): + + headless backend + + wayland backend + +- gl-renderer (depends on GL libs etc.) + +- drm-backend (depends on libdrm, libgbm, libudev, libinput, ...) + +- x11-backend (depends of X11/xcb libs) + +- xwayland (depends on X11/xcb libs) + +- fbdev-backend (depends on libudev...) + +- rdp-backend (depends on freerdp) + +- weston (the executable, not parallel-installable): + + desktop shell + + ivi-shell + + fullscreen shell + + weston-info (deprecated), weston-terminal, etc. we install by default + + screen-share + +- weston demos (not parallel-installable) + + weston-simple-* programs + + possibly all the programs we build but do not install by + default + +- and possibly more... + +Everything should be parallel-installable across libweston major +ABI-versions (libweston-1.so, libweston-2.so, etc.), except those +explicitly mentioned. + +Weston's build may not sanely allow this yet, but this is the +intention. diff --git a/notes.txt b/notes.txt new file mode 100644 index 0000000000000000000000000000000000000000..7a755f5ece8a617115b4edae98d95e963cd2c852 --- /dev/null +++ b/notes.txt @@ -0,0 +1,87 @@ +This file is a collection of informal notes, with references to where +they were originally written. Each note should have a source and date +mentioned. Let's keep these in date order, newest first. + + + +----------------------------------------------------------------------- +2015-04-14; Pekka Paalanen +http://lists.freedesktop.org/archives/wayland-devel/2015-April/021309.html + +Never destroy weston_views or weston_surfaces from animation hooks. +Never destroy weston_views from weston_view signals. + +Basically, never manipulate a list while transversing it. + + +----------------------------------------------------------------------- +2012-10-23; Pekka Paalanen +http://lists.freedesktop.org/archives/wayland-devel/2012-October/005969.html + +For anyone wanting to port or write their own window manager to Wayland: + +Most likely you have a desktop window manager. A quick way to get +started, is to fork Weston's desktop-shell plugin and start hacking it. +Qt could be another good choice, but I am not familiar with it. + +You also need to understand some concepts. I'm repeating things I wrote +to the wayland-devel list earlier, a little rephrased. + +We need to distinguish three different things here (towards Wayland +clients): + +- compositors (servers) + All Wayland compositors are indistinguishable by definition, + since they are Wayland compositors. They only differ in the + global interfaces they advertise, and for general purpose + compositors, we should aim to support the same minimum set of + globals everywhere. For instance, all desktop compositors + should implement wl_shell. In X, this component corresponds to + the X server with a built-in compositing manager. + +- shells + This is a new concept compared to an X stack. A shell defines + how a user and applications interact. The most familiar is a + desktop (environment). If KDE, Gnome, and XFCE are desktop + environments, they all fall under the *same* shell: the desktop + shell. You can have applications in windows, several visible at + the same time, you have keyboards and mice, etc. + + An example of something that is not a desktop shell + could be a TV user interface. TV is profoundly different: + usually no mouse, no keyboard, but you have a remote control + with some buttons. Freely floating windows probably do not make + sense. You may have picture-in-picture, but usually not several + applications showing at once. Most importantly, trying to run + desktop applications here does not work due to the + incompatible application and user interface paradigms. + + On protocol level, a shell is the public shell interface(s), + currently for desktop it is the wl_shell. + +- "window managers" + The X Window Managers correspond to different wl_shell + implementations, not different shells, since they practically + all deal with a desktop environment. You also want all desktop + applications to work with all window managers, so you need to + implement wl_shell anyway. + +I understand there could be special purpose X Window Managers, that +would better correspond to their own shells. These window managers +might not implement e.g. EWMH by the spec. + +When you implement your own window manager, you want to keep the public +desktop shell interface (wl_shell). You can offer new public +interfaces, too, but keep in mind, that someone needs to make +applications use them. + +In Weston, a shell implementation has two parts: a weston plugin, and a +special client. For desktop shell (wl_shell) these are src/shell.c and +clients/desktop-shell.c. The is also a private protocol extension that +these two can explicitly communicate with. + +The plugin does window management, and the client does most of user +interaction: draw backgrounds, panels, buttons, lock screen dialog, +basically everything that is on screen. + +----------------------------------------------------------------------- diff --git a/releasing.md b/releasing.md new file mode 100644 index 0000000000000000000000000000000000000000..1864dc3346ddda8dac45387da3f18abff355a091 --- /dev/null +++ b/releasing.md @@ -0,0 +1,72 @@ +# Releasing + +To make a release of Weston, follow these steps. + +0. Verify the test suites and codebase checks pass. All of the tests should + either pass or skip. + + ninja -C build/ test + +1. Verify that the wayland and wayland-protocols version dependencies are + correct, and that wayland-protocols has had a release with any needed + protocol updates. + +2. Update the first stanza of `meson.build` to the intended version. + + If the ABI has been broken, make sure `libweston_major` has been bumped since + the last release. + + Then commit your changes: + + RELEASE_NUMBER="x.y.z" + RELEASE_NAME="[alpha|beta|RC1|RC2|official|point]" + git status + git commit meson.build -m "build: bump to version $RELEASE_NUMBER for the $RELEASE_NAME release" + git push + +3. Run the `release.sh` script to generate the tarballs, sign and upload them, + and generate a release announcement template. This script can be obtained + from X.org's modular package: + + https://gitlab.freedesktop.org/xorg/util/modular/blob/master/release.sh + + The script supports a `--dry-run` option to test it without actually doing a + release. If the script fails on the distcheck step due to a test suite error + that can't be fixed for some reason, you can skip testsuite by specifying + the `--dist` argument. Pass `--help` to see other supported options. + + release.sh . + +5. Compose the release announcements. The script will generate *.x.y.z.announce + files with a list of changes and tags. Prepend these with a human-readable + listing of the most notable changes. For x.y.0 releases, indicate the + schedule for the x.y+1.0 release. + +6. PGP sign the release announcement and send it to + . + +7. Update `releases.html` in wayland.freedesktop.org with links to tarballs and + the release email URL. Copy tarballs produced by `release.sh` to `releases/`. + + Once satisfied: + + git commit -am "releases: add ${RELEASE_NUMBER} release" + git push + +For x.y.0 releases, also create the release series x.y branch. The x.y branch +is for bug fixes and conservative changes to the x.y.0 release, and is where we +create x.y.z releases from. Creating the x.y branch opens up master for new +development and lets new development move on. We've done this both after the +x.y.0 release (to focus development on bug fixing for the x.y.1 release for a +little longer) or before the x.y.0 release (like we did with the 1.5.0 release, +to unblock master development early). + + git branch x.y [sha] + git push origin x.y + +The master branch's `meson.build` version should always be (at least) x.y.90, +with x.y being the most recent stable branch. The stable branch's `meson.build` +version is just whatever was most recently released from that branch. + +For stable branches, we commit fixes to master first, then `git cherry-pick -x` +them back to the stable branch. diff --git a/wcap/README b/wcap/README new file mode 100644 index 0000000000000000000000000000000000000000..0c0d0f0ced8c17ccbaad60464db105076e10b5b6 --- /dev/null +++ b/wcap/README @@ -0,0 +1,99 @@ +WCAP Tools + +WCAP is the video capture format used by Weston (Weston CAPture). +It's a simple, lossless format, that encodes the difference between +frames as run-length encoded rectangles. It's a variable framerate +format, that only records new frames along with a timestamp when +something actually changes. + +Recording in Weston is started by pressing MOD+R and stopped by +pressing MOD+R again. Currently this leaves a capture.wcap file in +the cwd of the weston process. The file format is documented below +and Weston comes with the wcap-decode tool to convert the wcap file +into something more usable: + + - Extract single or all frames as individual png files. This will + produce a lossless screenshot, which is useful if you're trying to + screenshot a brief glitch or something like that that's hard to + capture with the screenshot tool. + + wcap-decode takes a number of options and a wcap file as its + arguments. Without anything else, it will show the screen size and + number of frames in the file. Pass --frame= to extract a + single frame or pass --all to extract all frames as png files: + + [krh@minato weston]$ wcap-snapshot capture.wcap + wcap file: size 1024x640, 176 frames + [krh@minato weston]$ wcap-snapshot capture.wcap 20 + wrote wcap-frame-20.png + wcap file: size 1024x640, 176 frames + + - Decode and the wcap file and dump it as a YUV4MPEG2 stream on + stdout. This format is compatible with most video encoders and can + be piped directly into a command line encoder such as vpxenc (part + of libvpx, encodes to a webm file) or theora_encode (part of + libtheora, encodes to a ogg theora file). + + Using vpxenc to encode a webm file would look something like this: + + [krh@minato weston]$ wcap-decode --yuv4mpeg2 ../capture.wcap | + vpxenc --target-bitrate=1024 --best -t 4 -o foo.webm - + + where we select target bitrate, pass -t 4 to let vpxenc use + multiple threads. To encode to Ogg Theora a command line like this + works: + + [krh@minato weston]$ wcap-decode ../capture.wcap --yuv4mpeg2 | + theora_encode - -o cap.ogv + + +WCAP File format + +The file format has a small header and then just consists of the +individual frames. The header is + + uint32_t magic + uint32_t format + uint32_t width + uint32_t height + +all CPU endian 32 bit words. The magic number is + + #define WCAP_HEADER_MAGIC 0x57434150 + +and makes it easy to recognize a wcap file and verify that it's the +right endian. There are four supported pixel formats: + + #define WCAP_FORMAT_XRGB8888 0x34325258 + #define WCAP_FORMAT_XBGR8888 0x34324258 + #define WCAP_FORMAT_RGBX8888 0x34325852 + #define WCAP_FORMAT_BGRX8888 0x34325842 + +Each frame has a header: + + uint32_t msecs + uint32_t nrects + +which specifies a timestamp in ms and the number of rectangles that +changed since previous frame. The timestamps are typically just a raw +system timestamp and the first frame doesn't start from 0ms. + +A frame consists of a list of rectangles, each of which represents the +component-wise difference between the previous frame and the current +using a run-length encoding. The initial frame is decoded against a +previous frame of all 0x00000000 pixels. Each rectangle starts out +with + + int32_t x1 + int32_t y1 + int32_t x2 + int32_t y2 + +followed by (x2 - x1) * (y2 - y1) pixels, run-length encoded. The +run-length encoding uses the 'X' channel in the pixel format to encode +the length of the run. That is for WCAP_FORMAT_XRGB8888, for example, +the length of the run is in the upper 8 bits. For X values 0-0xdf, +the length is X + 1, for X above or equal to 0xe0, the run length is 1 +<< (X - 0xe0 + 7). That is, a pixel value of 0xe3000100, means that +the next 1024 pixels differ by RGB(0x00, 0x01, 0x00) from the previous +pixels. diff --git a/wcap/main.c b/wcap/main.c new file mode 100644 index 0000000000000000000000000000000000000000..7eba6d6539ec061958df1a4b34dd18c4e1225deb --- /dev/null +++ b/wcap/main.c @@ -0,0 +1,331 @@ +2021-222222 + MIT License + +Copyright (c) 2021 Jianhui Zhao + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + + +/* + * Copyright © 2012 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice (including the + * next paragraph) shall be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "config.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "wcap-decode.h" + +static void +write_png(struct wcap_decoder *decoder, const char *filename) +{ + cairo_surface_t *surface; + + surface = cairo_image_surface_create_for_data((unsigned char *) decoder->frame, + CAIRO_FORMAT_ARGB32, + decoder->width, + decoder->height, + decoder->width * 4); + cairo_surface_write_to_png(surface, filename); + cairo_surface_destroy(surface); +} + +static inline int +rgb_to_yuv(uint32_t format, uint32_t p, int *u, int *v) +{ + int r, g, b, y; + + switch (format) { + case WCAP_FORMAT_XRGB8888: + r = (p >> 16) & 0xff; + g = (p >> 8) & 0xff; + b = (p >> 0) & 0xff; + break; + case WCAP_FORMAT_XBGR8888: + r = (p >> 0) & 0xff; + g = (p >> 8) & 0xff; + b = (p >> 16) & 0xff; + break; + default: + assert(0); + } + + y = (19595 * r + 38469 * g + 7472 * b) >> 16; + if (y > 255) + y = 255; + + *u += 46727 * (r - y); + *v += 36962 * (b - y); + + return y; +} + +static inline +int clamp_uv(int u) +{ + int clamp = (u >> 18) + 128; + + if (clamp < 0) + return 0; + else if (clamp > 255) + return 255; + else + return clamp; +} + +static void +convert_to_yv12(struct wcap_decoder *decoder, unsigned char *out) +{ + unsigned char *y1, *y2, *u, *v; + uint32_t *p1, *p2, *end; + int i, u_accum, v_accum, stride0, stride1; + uint32_t format = decoder->format; + + stride0 = decoder->width; + stride1 = decoder->width / 2; + for (i = 0; i < decoder->height; i += 2) { + y1 = out + stride0 * i; + y2 = y1 + stride0; + v = out + stride0 * decoder->height + stride1 * i / 2; + u = v + stride1 * decoder->height / 2; + p1 = decoder->frame + decoder->width * i; + p2 = p1 + decoder->width; + end = p1 + decoder->width; + + while (p1 < end) { + u_accum = 0; + v_accum = 0; + y1[0] = rgb_to_yuv(format, p1[0], &u_accum, &v_accum); + y1[1] = rgb_to_yuv(format, p1[1], &u_accum, &v_accum); + y2[0] = rgb_to_yuv(format, p2[0], &u_accum, &v_accum); + y2[1] = rgb_to_yuv(format, p2[1], &u_accum, &v_accum); + u[0] = clamp_uv(u_accum); + v[0] = clamp_uv(v_accum); + + y1 += 2; + p1 += 2; + y2 += 2; + p2 += 2; + u++; + v++; + } + } +} + +static void +convert_to_yuv444(struct wcap_decoder *decoder, unsigned char *out) +{ + + unsigned char *yp, *up, *vp; + uint32_t *rp, *end; + int u, v; + int i, stride, psize; + uint32_t format = decoder->format; + + stride = decoder->width; + psize = stride * decoder->height; + for (i = 0; i < decoder->height; i++) { + yp = out + stride * i; + up = yp + (psize * 2); + vp = yp + (psize * 1); + rp = decoder->frame + decoder->width * i; + end = rp + decoder->width; + while (rp < end) { + u = 0; + v = 0; + yp[0] = rgb_to_yuv(format, rp[0], &u, &v); + up[0] = clamp_uv(u/.3); + vp[0] = clamp_uv(v/.3); + up++; + vp++; + yp++; + rp++; + } + } +} + +static void +output_yuv_frame(struct wcap_decoder *decoder, int depth) +{ + static unsigned char *out; + int size; + + if (depth == 444) { + size = decoder->width * decoder->height * 3; + } else { + size = decoder->width * decoder->height * 3 / 2; + } + if (out == NULL) + out = malloc(size); + + if (depth == 444) { + convert_to_yuv444(decoder, out); + } else { + convert_to_yv12(decoder, out); + } + + printf("FRAME\n"); + fwrite(out, 1, size, stdout); +} + +static void +usage(int exit_code) +{ + fprintf(stderr, "usage: wcap-decode " + "[--help] [--yuv4mpeg2] [--frame=] [--all] \n" + "\t[--rate=] \n\n" + "\t--help\t\t\tthis help text\n" + "\t--yuv4mpeg2\t\tdump wcap file to stdout in yuv4mpeg2 format\n" + "\t--yuv4mpeg2-444\t\tdump wcap file to stdout in yuv4mpeg2 444 format\n" + "\t--frame=\t\twrite out the given frame number as png\n" + "\t--all\t\t\twrite all frames as pngs\n" + "\t--rate=\treplay frame rate for yuv4mpeg2,\n" + "\t\t\t\tspecified as an integer fraction\n\n"); + + exit(exit_code); +} + +int main(int argc, char *argv[]) +{ + struct wcap_decoder *decoder; + int i, j, output_frame = -1, yuv4mpeg2 = 0, all = 0, has_frame; + int num = 30, denom = 1; + char filename[200]; + char *mode; + uint32_t msecs, frame_time; + + for (i = 1, j = 1; i < argc; i++) { + if (strcmp(argv[i], "--yuv4mpeg2-444") == 0) { + yuv4mpeg2 = 444; + } else if (strcmp(argv[i], "--yuv4mpeg2") == 0) { + yuv4mpeg2 = 420; + } else if (strcmp(argv[i], "--help") == 0) { + usage(EXIT_SUCCESS); + } else if (strcmp(argv[i], "--all") == 0) { + all = 1; + } else if (sscanf(argv[i], "--frame=%d", &output_frame) == 1) { + ; + } else if (sscanf(argv[i], "--rate=%d", &num) == 1) { + ; + } else if (sscanf(argv[i], "--rate=%d:%d", &num, &denom) == 2) { + ; + } else if (strcmp(argv[i], "--") == 0) { + break; + } else if (argv[i][0] == '-') { + fprintf(stderr, + "unknown option or invalid argument: %s\n", argv[i]); + usage(EXIT_FAILURE); + } else { + argv[j++] = argv[i]; + } + } + argc = j; + + if (argc != 2) + usage(EXIT_FAILURE); + if (denom == 0) { + fprintf(stderr, "invalid rate, denom can not be 0\n"); + exit(EXIT_FAILURE); + } + + decoder = wcap_decoder_create(argv[1]); + if (decoder == NULL) { + fprintf(stderr, "Creating wcap decoder failed\n"); + exit(EXIT_FAILURE); + } + + if (yuv4mpeg2 && isatty(1)) { + fprintf(stderr, "Not dumping yuv4mpeg2 data to terminal. Pipe output to a file or a process.\n"); + fprintf(stderr, "For example, to encode to webm, use something like\n\n"); + fprintf(stderr, "\t$ wcap-decode --yuv4mpeg2 ../capture.wcap |\n" + "\t\tvpxenc --target-bitrate=1024 --best -t 4 -o foo.webm -\n\n"); + + exit(EXIT_FAILURE); + } + + if (yuv4mpeg2) { + if (yuv4mpeg2 == 444) { + mode = "C444"; + } else { + mode = "C420jpeg"; + } + printf("YUV4MPEG2 %s W%d H%d F%d:%d Ip A0:0\n", + mode, decoder->width, decoder->height, num, denom); + fflush(stdout); + } + + i = 0; + has_frame = wcap_decoder_get_frame(decoder); + msecs = decoder->msecs; + frame_time = 1000 * denom / num; + while (has_frame) { + if (all || i == output_frame) { + snprintf(filename, sizeof filename, + "wcap-frame-%d.png", i); + write_png(decoder, filename); + fprintf(stderr, "wrote %s\n", filename); + } + if (yuv4mpeg2) + output_yuv_frame(decoder, yuv4mpeg2); + i++; + msecs += frame_time; + while (decoder->msecs < msecs && has_frame) + has_frame = wcap_decoder_get_frame(decoder); + } + + fprintf(stderr, "wcap file: size %dx%d, %d frames\n", + decoder->width, decoder->height, i); + + wcap_decoder_destroy(decoder); + + return EXIT_SUCCESS; +} diff --git a/wcap/meson.build b/wcap/meson.build new file mode 100644 index 0000000000000000000000000000000000000000..04f2d1e9ddc4e825f7e0b0e6defcd14e1b5a3ef9 --- /dev/null +++ b/wcap/meson.build @@ -0,0 +1,21 @@ +if not get_option('wcap-decode') + subdir_done() +endif + +srcs_wcap = [ + 'main.c', + 'wcap-decode.c', +] + +wcap_dep_cairo = dependency('cairo', required: false) +if not wcap_dep_cairo.found() + error('wcap requires cairo which was not found. Or, you can use \'-Dwcap-decode=false\'.') +endif + +executable( + 'wcap-decode', + srcs_wcap, + include_directories: common_inc, + dependencies: [ dep_libm, wcap_dep_cairo ], + install: true +) diff --git a/wcap/wcap-decode.c b/wcap/wcap-decode.c new file mode 100644 index 0000000000000000000000000000000000000000..111f1b1d4de3aaa80410e81f4372d289c3118faf --- /dev/null +++ b/wcap/wcap-decode.c @@ -0,0 +1,847 @@ +GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. + + + + + + + +/* + * Copyright © 2012 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice (including the + * next paragraph) shall be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "config.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "wcap-decode.h" + +static void +wcap_decoder_decode_rectangle(struct wcap_decoder *decoder, + struct wcap_rectangle *rect) +{ + uint32_t v, *p = decoder->p, *d; + int width = rect->x2 - rect->x1, height = rect->y2 - rect->y1; + int x, i, j, k, l, count = width * height; + unsigned char r, g, b, dr, dg, db; + + d = decoder->frame + (rect->y2 - 1) * decoder->width; + x = rect->x1; + i = 0; + while (i < count) { + v = *p++; + l = v >> 24; + if (l < 0xe0) { + j = l + 1; + } else { + j = 1 << (l - 0xe0 + 7); + } + + dr = (v >> 16); + dg = (v >> 8); + db = (v >> 0); + for (k = 0; k < j; k++) { + r = (d[x] >> 16) + dr; + g = (d[x] >> 8) + dg; + b = (d[x] >> 0) + db; + d[x] = 0xff000000 | (r << 16) | (g << 8) | b; + x++; + if (x == rect->x2) { + x = rect->x1; + d -= decoder->width; + } + } + i += j; + } + + if (i != count) + printf("rle encoding longer than expected (%d expected %d)\n", + i, count); + + decoder->p = p; +} + +int +wcap_decoder_get_frame(struct wcap_decoder *decoder) +{ + struct wcap_rectangle *rects; + struct wcap_frame_header *header; + uint32_t i; + + if (decoder->p == decoder->end) + return 0; + + header = decoder->p; + decoder->msecs = header->msecs; + decoder->count++; + + rects = (void *) (header + 1); + decoder->p = (uint32_t *) (rects + header->nrects); + for (i = 0; i < header->nrects; i++) + wcap_decoder_decode_rectangle(decoder, &rects[i]); + + return 1; +} + +struct wcap_decoder * +wcap_decoder_create(const char *filename) +{ + struct wcap_decoder *decoder; + struct wcap_header *header; + int frame_size; + struct stat buf; + + decoder = malloc(sizeof *decoder); + if (decoder == NULL) + return NULL; + + decoder->fd = open(filename, O_RDONLY); + if (decoder->fd == -1) { + free(decoder); + return NULL; + } + + fstat(decoder->fd, &buf); + decoder->size = buf.st_size; + decoder->map = mmap(NULL, decoder->size, + PROT_READ, MAP_PRIVATE, decoder->fd, 0); + if (decoder->map == MAP_FAILED) { + fprintf(stderr, "mmap failed\n"); + close(decoder->fd); + free(decoder); + return NULL; + } + + header = decoder->map; + decoder->format = header->format; + decoder->count = 0; + decoder->width = header->width; + decoder->height = header->height; + decoder->p = header + 1; + decoder->end = decoder->map + decoder->size; + + frame_size = header->width * header->height * 4; + decoder->frame = malloc(frame_size); + if (decoder->frame == NULL) { + close(decoder->fd); + free(decoder); + return NULL; + } + memset(decoder->frame, 0, frame_size); + + return decoder; +} + +void +wcap_decoder_destroy(struct wcap_decoder *decoder) +{ + munmap(decoder->map, decoder->size); + close(decoder->fd); + free(decoder->frame); + free(decoder); +} diff --git a/wcap/wcap-decode.h b/wcap/wcap-decode.h new file mode 100644 index 0000000000000000000000000000000000000000..00b757feb078d89619164ca6019c2062feaa4d44 --- /dev/null +++ b/wcap/wcap-decode.h @@ -0,0 +1,68 @@ +/* + * Copyright © 2012 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice (including the + * next paragraph) shall be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#ifndef _WCAP_DECODE_ +#define _WCAP_DECODE_ + +#include + +#define WCAP_HEADER_MAGIC 0x57434150 + +#define WCAP_FORMAT_XRGB8888 0x34325258 +#define WCAP_FORMAT_XBGR8888 0x34324258 +#define WCAP_FORMAT_RGBX8888 0x34325852 +#define WCAP_FORMAT_BGRX8888 0x34325842 + +struct wcap_header { + uint32_t magic; + uint32_t format; + uint32_t width, height; +}; + +struct wcap_frame_header { + uint32_t msecs; + uint32_t nrects; +}; + +struct wcap_rectangle { + int32_t x1, y1, x2, y2; +}; + +struct wcap_decoder { + int fd; + size_t size; + void *map, *p, *end; + uint32_t *frame; + uint32_t format; + uint32_t msecs; + uint32_t count; + int width, height; +}; + +int wcap_decoder_get_frame(struct wcap_decoder *decoder); +struct wcap_decoder *wcap_decoder_create(const char *filename); +void wcap_decoder_destroy(struct wcap_decoder *decoder); + +#endif diff --git a/weston.ini b/weston.ini new file mode 100644 index 0000000000000000000000000000000000000000..fc2bfc85b31538ef35eeb3d851af598bb3ff9bf0 --- /dev/null +++ b/weston.ini @@ -0,0 +1,16 @@ +[core] +shell=libivi-shell.z.so +modules=libivi-controller.z.so + +[ivi-shell] +ivi-input-module=libivi-input-controller.z.so +ivi-id-agent-module=libivi-id-agent.z.so +screen-info-module=libscreen-info-module.z.so +transition-duration=30 +cursor-theme=default + +[keyboard] +keymap_layout=de + +[input-method] +path= diff --git a/weston.ini.in b/weston.ini.in new file mode 100644 index 0000000000000000000000000000000000000000..74bcb51203eb977e43b041308f7c8468d892c07f --- /dev/null +++ b/weston.ini.in @@ -0,0 +1,87 @@ +[core] +#modules=cms-colord.so +#xwayland=true +#shell=desktop-shell.so +#gbm-format=xrgb2101010 +#require-input=true + +[shell] +background-image=/usr/share/backgrounds/gnome/Aqua.jpg +background-color=0xff002244 +background-type=tile +clock-format=minutes +panel-color=0x90ff0000 +locking=true +animation=zoom +startup-animation=fade +#binding-modifier=ctrl +#num-workspaces=6 +#cursor-theme=whiteglass +#cursor-size=24 + +#lockscreen-icon=/usr/share/icons/gnome/256x256/actions/lock.png +#lockscreen=/usr/share/backgrounds/gnome/Garden.jpg +#homescreen=/usr/share/backgrounds/gnome/Blinds.jpg +#animation=fade + +[launcher] +icon=/usr/share/icons/gnome/24x24/apps/utilities-terminal.png +path=/usr/bin/gnome-terminal + +[launcher] +icon=/usr/share/icons/gnome/24x24/apps/utilities-terminal.png +path=@bindir@/weston-terminal + +[launcher] +icon=/usr/share/icons/hicolor/24x24/apps/google-chrome.png +path=/usr/bin/google-chrome + +[launcher] +icon=/usr/share/icons/gnome/24x24/apps/arts.png +path=@bindir@/weston-flower + +[input-method] +path=@libexecdir@/weston-keyboard + +#[output] +#name=LVDS1 +#mode=1680x1050 +#transform=90 +#icc_profile=/usr/share/color/icc/colord/Bluish.icc + +#[output] +#name=VGA1 +#mode=173.00 1920 2048 2248 2576 1080 1083 1088 1120 -hsync +vsync +#transform=flipped + +#[output] +#name=X1 +#mode=1024x768@60 +#transform=flipped-90 + +#[libinput] +#enable-tap=true +#tap-and-drag=true +#tap-and-drag-lock=true +#disable-while-typing=false +#middle-button-emulation=true +#left-handed=true +#rotation=90 +#accel-profile=flat +#accel-speed=.9 +#natural-scroll=true +#scroll-method=edge +# For button-triggered scrolling: +#scroll-method=button +#scroll-button=BTN_RIGHT + +#[touchpad] +#constant_accel_factor = 50 +#min_accel_factor = 0.16 +#max_accel_factor = 1.0 + +[screen-share] +command=@bindir@/weston --backend=rdp-backend.so --shell=fullscreen-shell.so --no-clients-resize + +#[xwayland] +#path=@bindir@/Xwayland diff --git a/weston.rc b/weston.rc new file mode 100644 index 0000000000000000000000000000000000000000..1dcdf37739c931af8b31c8ef51b614362cdaebb2 --- /dev/null +++ b/weston.rc @@ -0,0 +1,15 @@ +service weston /system/bin/logwrapper /system/bin/weston -c /system/etc/weston.ini -B drm-backend.so --tty=1 --use-pixman + class weston + disabled + seclabel u:r:ueventd:s0 + +on boot + export WESTON_MODULE_MAP "drm-backend.so=libdrm-backend.z.so" + export XDG_RUNTIME_DIR /data/weston + mkdir /data/weston + start weston + exec /system/bin/sleep 2 + exec /system/bin/killall weston + exec /system/bin/sleep 2 + + trigger weston_start