Document not found (404)
+This URL is invalid, sorry. Please use the navigation bar or search to continue.
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/crates.js b/crates.js
new file mode 100644
index 0000000..1615775
--- /dev/null
+++ b/crates.js
@@ -0,0 +1,2 @@
+window.ALL_CRATES = ["vidformer"];
+//{"start":21,"fragment_lengths":[11]}
\ No newline at end of file
diff --git a/css/chrome.css b/css/chrome.css
new file mode 100644
index 0000000..4cd7308
--- /dev/null
+++ b/css/chrome.css
@@ -0,0 +1,640 @@
+/* CSS for UI elements (a.k.a. chrome) */
+
+html {
+ scrollbar-color: var(--scrollbar) var(--bg);
+}
+#searchresults a,
+.content a:link,
+a:visited,
+a > .hljs {
+ color: var(--links);
+}
+
+/*
+ body-container is necessary because mobile browsers don't seem to like
+ overflow-x on the body tag when there is a tag.
+*/
+#body-container {
+ /*
+ This is used when the sidebar pushes the body content off the side of
+ the screen on small screens. Without it, dragging on mobile Safari
+ will want to reposition the viewport in a weird way.
+ */
+ overflow-x: clip;
+}
+
+/* Menu Bar */
+
+#menu-bar,
+#menu-bar-hover-placeholder {
+ z-index: 101;
+ margin: auto calc(0px - var(--page-padding));
+}
+#menu-bar {
+ position: relative;
+ display: flex;
+ flex-wrap: wrap;
+ background-color: var(--bg);
+ border-block-end-color: var(--bg);
+ border-block-end-width: 1px;
+ border-block-end-style: solid;
+}
+#menu-bar.sticky,
+#menu-bar-hover-placeholder:hover + #menu-bar,
+#menu-bar:hover,
+html.sidebar-visible #menu-bar {
+ position: -webkit-sticky;
+ position: sticky;
+ top: 0 !important;
+}
+#menu-bar-hover-placeholder {
+ position: sticky;
+ position: -webkit-sticky;
+ top: 0;
+ height: var(--menu-bar-height);
+}
+#menu-bar.bordered {
+ border-block-end-color: var(--table-border-color);
+}
+#menu-bar i, #menu-bar .icon-button {
+ position: relative;
+ padding: 0 8px;
+ z-index: 10;
+ line-height: var(--menu-bar-height);
+ cursor: pointer;
+ transition: color 0.5s;
+}
+@media only screen and (max-width: 420px) {
+ #menu-bar i, #menu-bar .icon-button {
+ padding: 0 5px;
+ }
+}
+
+.icon-button {
+ border: none;
+ background: none;
+ padding: 0;
+ color: inherit;
+}
+.icon-button i {
+ margin: 0;
+}
+
+.right-buttons {
+ margin: 0 15px;
+}
+.right-buttons a {
+ text-decoration: none;
+}
+
+.left-buttons {
+ display: flex;
+ margin: 0 5px;
+}
+html:not(.js) .left-buttons button {
+ display: none;
+}
+
+.menu-title {
+ display: inline-block;
+ font-weight: 200;
+ font-size: 2.4rem;
+ line-height: var(--menu-bar-height);
+ text-align: center;
+ margin: 0;
+ flex: 1;
+ white-space: nowrap;
+ overflow: hidden;
+ text-overflow: ellipsis;
+}
+.menu-title {
+ cursor: pointer;
+}
+
+.menu-bar,
+.menu-bar:visited,
+.nav-chapters,
+.nav-chapters:visited,
+.mobile-nav-chapters,
+.mobile-nav-chapters:visited,
+.menu-bar .icon-button,
+.menu-bar a i {
+ color: var(--icons);
+}
+
+.menu-bar i:hover,
+.menu-bar .icon-button:hover,
+.nav-chapters:hover,
+.mobile-nav-chapters i:hover {
+ color: var(--icons-hover);
+}
+
+/* Nav Icons */
+
+.nav-chapters {
+ font-size: 2.5em;
+ text-align: center;
+ text-decoration: none;
+
+ position: fixed;
+ top: 0;
+ bottom: 0;
+ margin: 0;
+ max-width: 150px;
+ min-width: 90px;
+
+ display: flex;
+ justify-content: center;
+ align-content: center;
+ flex-direction: column;
+
+ transition: color 0.5s, background-color 0.5s;
+}
+
+.nav-chapters:hover {
+ text-decoration: none;
+ background-color: var(--theme-hover);
+ transition: background-color 0.15s, color 0.15s;
+}
+
+.nav-wrapper {
+ margin-block-start: 50px;
+ display: none;
+}
+
+.mobile-nav-chapters {
+ font-size: 2.5em;
+ text-align: center;
+ text-decoration: none;
+ width: 90px;
+ border-radius: 5px;
+ background-color: var(--sidebar-bg);
+}
+
+/* Only Firefox supports flow-relative values */
+.previous { float: left; }
+[dir=rtl] .previous { float: right; }
+
+/* Only Firefox supports flow-relative values */
+.next {
+ float: right;
+ right: var(--page-padding);
+}
+[dir=rtl] .next {
+ float: left;
+ right: unset;
+ left: var(--page-padding);
+}
+
+/* Use the correct buttons for RTL layouts*/
+[dir=rtl] .previous i.fa-angle-left:before {content:"\f105";}
+[dir=rtl] .next i.fa-angle-right:before { content:"\f104"; }
+
+@media only screen and (max-width: 1080px) {
+ .nav-wide-wrapper { display: none; }
+ .nav-wrapper { display: block; }
+}
+
+/* sidebar-visible */
+@media only screen and (max-width: 1380px) {
+ #sidebar-toggle-anchor:checked ~ .page-wrapper .nav-wide-wrapper { display: none; }
+ #sidebar-toggle-anchor:checked ~ .page-wrapper .nav-wrapper { display: block; }
+}
+
+/* Inline code */
+
+:not(pre) > .hljs {
+ display: inline;
+ padding: 0.1em 0.3em;
+ border-radius: 3px;
+}
+
+:not(pre):not(a) > .hljs {
+ color: var(--inline-code-color);
+ overflow-x: initial;
+}
+
+a:hover > .hljs {
+ text-decoration: underline;
+}
+
+pre {
+ position: relative;
+}
+pre > .buttons {
+ position: absolute;
+ z-index: 100;
+ right: 0px;
+ top: 2px;
+ margin: 0px;
+ padding: 2px 0px;
+
+ color: var(--sidebar-fg);
+ cursor: pointer;
+ visibility: hidden;
+ opacity: 0;
+ transition: visibility 0.1s linear, opacity 0.1s linear;
+}
+pre:hover > .buttons {
+ visibility: visible;
+ opacity: 1
+}
+pre > .buttons :hover {
+ color: var(--sidebar-active);
+ border-color: var(--icons-hover);
+ background-color: var(--theme-hover);
+}
+pre > .buttons i {
+ margin-inline-start: 8px;
+}
+pre > .buttons button {
+ cursor: inherit;
+ margin: 0px 5px;
+ padding: 4px 4px 3px 5px;
+ font-size: 23px;
+
+ border-style: solid;
+ border-width: 1px;
+ border-radius: 4px;
+ border-color: var(--icons);
+ background-color: var(--theme-popup-bg);
+ transition: 100ms;
+ transition-property: color,border-color,background-color;
+ color: var(--icons);
+}
+
+pre > .buttons button.clip-button {
+ padding: 2px 4px 0px 6px;
+}
+pre > .buttons button.clip-button::before {
+ /* clipboard image from octicons (https://github.com/primer/octicons/tree/v2.0.0) MIT license
+ */
+ content: url('data:image/svg+xml,');
+ filter: var(--copy-button-filter);
+}
+pre > .buttons button.clip-button:hover::before {
+ filter: var(--copy-button-filter-hover);
+}
+
+@media (pointer: coarse) {
+ pre > .buttons button {
+ /* On mobile, make it easier to tap buttons. */
+ padding: 0.3rem 1rem;
+ }
+
+ .sidebar-resize-indicator {
+ /* Hide resize indicator on devices with limited accuracy */
+ display: none;
+ }
+}
+pre > code {
+ display: block;
+ padding: 1rem;
+}
+
+/* FIXME: ACE editors overlap their buttons because ACE does absolute
+ positioning within the code block which breaks padding. The only solution I
+ can think of is to move the padding to the outer pre tag (or insert a div
+ wrapper), but that would require fixing a whole bunch of CSS rules.
+*/
+.hljs.ace_editor {
+ padding: 0rem 0rem;
+}
+
+pre > .result {
+ margin-block-start: 10px;
+}
+
+/* Search */
+
+#searchresults a {
+ text-decoration: none;
+}
+
+mark {
+ border-radius: 2px;
+ padding-block-start: 0;
+ padding-block-end: 1px;
+ padding-inline-start: 3px;
+ padding-inline-end: 3px;
+ margin-block-start: 0;
+ margin-block-end: -1px;
+ margin-inline-start: -3px;
+ margin-inline-end: -3px;
+ background-color: var(--search-mark-bg);
+ transition: background-color 300ms linear;
+ cursor: pointer;
+}
+
+mark.fade-out {
+ background-color: rgba(0,0,0,0) !important;
+ cursor: auto;
+}
+
+.searchbar-outer {
+ margin-inline-start: auto;
+ margin-inline-end: auto;
+ max-width: var(--content-max-width);
+}
+
+#searchbar {
+ width: 100%;
+ margin-block-start: 5px;
+ margin-block-end: 0;
+ margin-inline-start: auto;
+ margin-inline-end: auto;
+ padding: 10px 16px;
+ transition: box-shadow 300ms ease-in-out;
+ border: 1px solid var(--searchbar-border-color);
+ border-radius: 3px;
+ background-color: var(--searchbar-bg);
+ color: var(--searchbar-fg);
+}
+#searchbar:focus,
+#searchbar.active {
+ box-shadow: 0 0 3px var(--searchbar-shadow-color);
+}
+
+.searchresults-header {
+ font-weight: bold;
+ font-size: 1em;
+ padding-block-start: 18px;
+ padding-block-end: 0;
+ padding-inline-start: 5px;
+ padding-inline-end: 0;
+ color: var(--searchresults-header-fg);
+}
+
+.searchresults-outer {
+ margin-inline-start: auto;
+ margin-inline-end: auto;
+ max-width: var(--content-max-width);
+ border-block-end: 1px dashed var(--searchresults-border-color);
+}
+
+ul#searchresults {
+ list-style: none;
+ padding-inline-start: 20px;
+}
+ul#searchresults li {
+ margin: 10px 0px;
+ padding: 2px;
+ border-radius: 2px;
+}
+ul#searchresults li.focus {
+ background-color: var(--searchresults-li-bg);
+}
+ul#searchresults span.teaser {
+ display: block;
+ clear: both;
+ margin-block-start: 5px;
+ margin-block-end: 0;
+ margin-inline-start: 20px;
+ margin-inline-end: 0;
+ font-size: 0.8em;
+}
+ul#searchresults span.teaser em {
+ font-weight: bold;
+ font-style: normal;
+}
+
+/* Sidebar */
+
+.sidebar {
+ position: fixed;
+ left: 0;
+ top: 0;
+ bottom: 0;
+ width: var(--sidebar-width);
+ font-size: 0.875em;
+ box-sizing: border-box;
+ -webkit-overflow-scrolling: touch;
+ overscroll-behavior-y: contain;
+ background-color: var(--sidebar-bg);
+ color: var(--sidebar-fg);
+}
+.sidebar-iframe-inner {
+ background-color: var(--sidebar-bg);
+ color: var(--sidebar-fg);
+ padding: 10px 10px;
+ margin: 0;
+ font-size: 1.4rem;
+}
+.sidebar-iframe-outer {
+ border: none;
+ height: 100%;
+ position: absolute;
+ top: 0;
+ bottom: 0;
+ left: 0;
+ right: 0;
+}
+[dir=rtl] .sidebar { left: unset; right: 0; }
+.sidebar-resizing {
+ -moz-user-select: none;
+ -webkit-user-select: none;
+ -ms-user-select: none;
+ user-select: none;
+}
+html:not(.sidebar-resizing) .sidebar {
+ transition: transform 0.3s; /* Animation: slide away */
+}
+.sidebar code {
+ line-height: 2em;
+}
+.sidebar .sidebar-scrollbox {
+ overflow-y: auto;
+ position: absolute;
+ top: 0;
+ bottom: 0;
+ left: 0;
+ right: 0;
+ padding: 10px 10px;
+}
+.sidebar .sidebar-resize-handle {
+ position: absolute;
+ cursor: col-resize;
+ width: 0;
+ right: calc(var(--sidebar-resize-indicator-width) * -1);
+ top: 0;
+ bottom: 0;
+ display: flex;
+ align-items: center;
+}
+
+.sidebar-resize-handle .sidebar-resize-indicator {
+ width: 100%;
+ height: 12px;
+ background-color: var(--icons);
+ margin-inline-start: var(--sidebar-resize-indicator-space);
+}
+
+[dir=rtl] .sidebar .sidebar-resize-handle {
+ left: calc(var(--sidebar-resize-indicator-width) * -1);
+ right: unset;
+}
+.js .sidebar .sidebar-resize-handle {
+ cursor: col-resize;
+ width: calc(var(--sidebar-resize-indicator-width) - var(--sidebar-resize-indicator-space));
+}
+/* sidebar-hidden */
+#sidebar-toggle-anchor:not(:checked) ~ .sidebar {
+ transform: translateX(calc(0px - var(--sidebar-width) - var(--sidebar-resize-indicator-width)));
+ z-index: -1;
+}
+[dir=rtl] #sidebar-toggle-anchor:not(:checked) ~ .sidebar {
+ transform: translateX(calc(var(--sidebar-width) + var(--sidebar-resize-indicator-width)));
+}
+.sidebar::-webkit-scrollbar {
+ background: var(--sidebar-bg);
+}
+.sidebar::-webkit-scrollbar-thumb {
+ background: var(--scrollbar);
+}
+
+/* sidebar-visible */
+#sidebar-toggle-anchor:checked ~ .page-wrapper {
+ transform: translateX(calc(var(--sidebar-width) + var(--sidebar-resize-indicator-width)));
+}
+[dir=rtl] #sidebar-toggle-anchor:checked ~ .page-wrapper {
+ transform: translateX(calc(0px - var(--sidebar-width) - var(--sidebar-resize-indicator-width)));
+}
+@media only screen and (min-width: 620px) {
+ #sidebar-toggle-anchor:checked ~ .page-wrapper {
+ transform: none;
+ margin-inline-start: calc(var(--sidebar-width) + var(--sidebar-resize-indicator-width));
+ }
+ [dir=rtl] #sidebar-toggle-anchor:checked ~ .page-wrapper {
+ transform: none;
+ }
+}
+
+.chapter {
+ list-style: none outside none;
+ padding-inline-start: 0;
+ line-height: 2.2em;
+}
+
+.chapter ol {
+ width: 100%;
+}
+
+.chapter li {
+ display: flex;
+ color: var(--sidebar-non-existant);
+}
+.chapter li a {
+ display: block;
+ padding: 0;
+ text-decoration: none;
+ color: var(--sidebar-fg);
+}
+
+.chapter li a:hover {
+ color: var(--sidebar-active);
+}
+
+.chapter li a.active {
+ color: var(--sidebar-active);
+}
+
+.chapter li > a.toggle {
+ cursor: pointer;
+ display: block;
+ margin-inline-start: auto;
+ padding: 0 10px;
+ user-select: none;
+ opacity: 0.68;
+}
+
+.chapter li > a.toggle div {
+ transition: transform 0.5s;
+}
+
+/* collapse the section */
+.chapter li:not(.expanded) + li > ol {
+ display: none;
+}
+
+.chapter li.chapter-item {
+ line-height: 1.5em;
+ margin-block-start: 0.6em;
+}
+
+.chapter li.expanded > a.toggle div {
+ transform: rotate(90deg);
+}
+
+.spacer {
+ width: 100%;
+ height: 3px;
+ margin: 5px 0px;
+}
+.chapter .spacer {
+ background-color: var(--sidebar-spacer);
+}
+
+@media (-moz-touch-enabled: 1), (pointer: coarse) {
+ .chapter li a { padding: 5px 0; }
+ .spacer { margin: 10px 0; }
+}
+
+.section {
+ list-style: none outside none;
+ padding-inline-start: 20px;
+ line-height: 1.9em;
+}
+
+/* Theme Menu Popup */
+
+.theme-popup {
+ position: absolute;
+ left: 10px;
+ top: var(--menu-bar-height);
+ z-index: 1000;
+ border-radius: 4px;
+ font-size: 0.7em;
+ color: var(--fg);
+ background: var(--theme-popup-bg);
+ border: 1px solid var(--theme-popup-border);
+ margin: 0;
+ padding: 0;
+ list-style: none;
+ display: none;
+ /* Don't let the children's background extend past the rounded corners. */
+ overflow: hidden;
+}
+[dir=rtl] .theme-popup { left: unset; right: 10px; }
+.theme-popup .default {
+ color: var(--icons);
+}
+.theme-popup .theme {
+ width: 100%;
+ border: 0;
+ margin: 0;
+ padding: 2px 20px;
+ line-height: 25px;
+ white-space: nowrap;
+ text-align: start;
+ cursor: pointer;
+ color: inherit;
+ background: inherit;
+ font-size: inherit;
+}
+.theme-popup .theme:hover {
+ background-color: var(--theme-hover);
+}
+
+.theme-selected::before {
+ display: inline-block;
+ content: "✓";
+ margin-inline-start: -14px;
+ width: 14px;
+}
diff --git a/css/general.css b/css/general.css
new file mode 100644
index 0000000..0862b51
--- /dev/null
+++ b/css/general.css
@@ -0,0 +1,242 @@
+/* Base styles and content styles */
+
+:root {
+ /* Browser default font-size is 16px, this way 1 rem = 10px */
+ font-size: 62.5%;
+ color-scheme: var(--color-scheme);
+}
+
+html {
+ font-family: "Open Sans", sans-serif;
+ color: var(--fg);
+ background-color: var(--bg);
+ text-size-adjust: none;
+ -webkit-text-size-adjust: none;
+}
+
+body {
+ margin: 0;
+ font-size: 1.6rem;
+ overflow-x: hidden;
+}
+
+code {
+ font-family: var(--mono-font) !important;
+ font-size: var(--code-font-size);
+ direction: ltr !important;
+}
+
+/* make long words/inline code not x overflow */
+main {
+ overflow-wrap: break-word;
+}
+
+/* make wide tables scroll if they overflow */
+.table-wrapper {
+ overflow-x: auto;
+}
+
+/* Don't change font size in headers. */
+h1 code, h2 code, h3 code, h4 code, h5 code, h6 code {
+ font-size: unset;
+}
+
+.left { float: left; }
+.right { float: right; }
+.boring { opacity: 0.6; }
+.hide-boring .boring { display: none; }
+.hidden { display: none !important; }
+
+h2, h3 { margin-block-start: 2.5em; }
+h4, h5 { margin-block-start: 2em; }
+
+.header + .header h3,
+.header + .header h4,
+.header + .header h5 {
+ margin-block-start: 1em;
+}
+
+h1:target::before,
+h2:target::before,
+h3:target::before,
+h4:target::before,
+h5:target::before,
+h6:target::before {
+ display: inline-block;
+ content: "»";
+ margin-inline-start: -30px;
+ width: 30px;
+}
+
+/* This is broken on Safari as of version 14, but is fixed
+ in Safari Technology Preview 117 which I think will be Safari 14.2.
+ https://bugs.webkit.org/show_bug.cgi?id=218076
+*/
+:target {
+ /* Safari does not support logical properties */
+ scroll-margin-top: calc(var(--menu-bar-height) + 0.5em);
+}
+
+.page {
+ outline: 0;
+ padding: 0 var(--page-padding);
+ margin-block-start: calc(0px - var(--menu-bar-height)); /* Compensate for the #menu-bar-hover-placeholder */
+}
+.page-wrapper {
+ box-sizing: border-box;
+ background-color: var(--bg);
+}
+.no-js .page-wrapper,
+.js:not(.sidebar-resizing) .page-wrapper {
+ transition: margin-left 0.3s ease, transform 0.3s ease; /* Animation: slide away */
+}
+[dir=rtl] .js:not(.sidebar-resizing) .page-wrapper {
+ transition: margin-right 0.3s ease, transform 0.3s ease; /* Animation: slide away */
+}
+
+.content {
+ overflow-y: auto;
+ padding: 0 5px 50px 5px;
+}
+.content main {
+ margin-inline-start: auto;
+ margin-inline-end: auto;
+ max-width: var(--content-max-width);
+}
+.content p { line-height: 1.45em; }
+.content ol { line-height: 1.45em; }
+.content ul { line-height: 1.45em; }
+.content a { text-decoration: none; }
+.content a:hover { text-decoration: underline; }
+.content img, .content video { max-width: 100%; }
+.content .header:link,
+.content .header:visited {
+ color: var(--fg);
+}
+.content .header:link,
+.content .header:visited:hover {
+ text-decoration: none;
+}
+
+table {
+ margin: 0 auto;
+ border-collapse: collapse;
+}
+table td {
+ padding: 3px 20px;
+ border: 1px var(--table-border-color) solid;
+}
+table thead {
+ background: var(--table-header-bg);
+}
+table thead td {
+ font-weight: 700;
+ border: none;
+}
+table thead th {
+ padding: 3px 20px;
+}
+table thead tr {
+ border: 1px var(--table-header-bg) solid;
+}
+/* Alternate background colors for rows */
+table tbody tr:nth-child(2n) {
+ background: var(--table-alternate-bg);
+}
+
+
+blockquote {
+ margin: 20px 0;
+ padding: 0 20px;
+ color: var(--fg);
+ background-color: var(--quote-bg);
+ border-block-start: .1em solid var(--quote-border);
+ border-block-end: .1em solid var(--quote-border);
+}
+
+.warning {
+ margin: 20px;
+ padding: 0 20px;
+ border-inline-start: 2px solid var(--warning-border);
+}
+
+.warning:before {
+ position: absolute;
+ width: 3rem;
+ height: 3rem;
+ margin-inline-start: calc(-1.5rem - 21px);
+ content: "ⓘ";
+ text-align: center;
+ background-color: var(--bg);
+ color: var(--warning-border);
+ font-weight: bold;
+ font-size: 2rem;
+}
+
+blockquote .warning:before {
+ background-color: var(--quote-bg);
+}
+
+kbd {
+ background-color: var(--table-border-color);
+ border-radius: 4px;
+ border: solid 1px var(--theme-popup-border);
+ box-shadow: inset 0 -1px 0 var(--theme-hover);
+ display: inline-block;
+ font-size: var(--code-font-size);
+ font-family: var(--mono-font);
+ line-height: 10px;
+ padding: 4px 5px;
+ vertical-align: middle;
+}
+
+sup {
+ /* Set the line-height for superscript and footnote references so that there
+ isn't an awkward space appearing above lines that contain the footnote.
+
+ See https://github.com/rust-lang/mdBook/pull/2443#discussion_r1813773583
+ for an explanation.
+ */
+ line-height: 0;
+}
+
+:not(.footnote-definition) + .footnote-definition,
+.footnote-definition + :not(.footnote-definition) {
+ margin-block-start: 2em;
+}
+.footnote-definition {
+ font-size: 0.9em;
+ margin: 0.5em 0;
+}
+.footnote-definition p {
+ display: inline;
+}
+
+.tooltiptext {
+ position: absolute;
+ visibility: hidden;
+ color: #fff;
+ background-color: #333;
+ transform: translateX(-50%); /* Center by moving tooltip 50% of its width left */
+ left: -8px; /* Half of the width of the icon */
+ top: -35px;
+ font-size: 0.8em;
+ text-align: center;
+ border-radius: 6px;
+ padding: 5px 8px;
+ margin: 5px;
+ z-index: 1000;
+}
+.tooltipped .tooltiptext {
+ visibility: visible;
+}
+
+.chapter li.part-title {
+ color: var(--sidebar-fg);
+ margin: 5px 0px;
+ font-weight: bold;
+}
+
+.result-no-output {
+ font-style: italic;
+}
diff --git a/css/print.css b/css/print.css
new file mode 100644
index 0000000..80ec3a5
--- /dev/null
+++ b/css/print.css
@@ -0,0 +1,50 @@
+
+#sidebar,
+#menu-bar,
+.nav-chapters,
+.mobile-nav-chapters {
+ display: none;
+}
+
+#page-wrapper.page-wrapper {
+ transform: none !important;
+ margin-inline-start: 0px;
+ overflow-y: initial;
+}
+
+#content {
+ max-width: none;
+ margin: 0;
+ padding: 0;
+}
+
+.page {
+ overflow-y: initial;
+}
+
+code {
+ direction: ltr !important;
+}
+
+pre > .buttons {
+ z-index: 2;
+}
+
+a, a:visited, a:active, a:hover {
+ color: #4183c4;
+ text-decoration: none;
+}
+
+h1, h2, h3, h4, h5, h6 {
+ page-break-inside: avoid;
+ page-break-after: avoid;
+}
+
+pre, code {
+ page-break-inside: avoid;
+ white-space: pre-wrap;
+}
+
+.fa {
+ display: none !important;
+}
diff --git a/css/variables.css b/css/variables.css
new file mode 100644
index 0000000..12d1db7
--- /dev/null
+++ b/css/variables.css
@@ -0,0 +1,309 @@
+
+/* Globals */
+
+:root {
+ --sidebar-width: 300px;
+ --sidebar-resize-indicator-width: 8px;
+ --sidebar-resize-indicator-space: 2px;
+ --page-padding: 15px;
+ --content-max-width: 750px;
+ --menu-bar-height: 50px;
+ --mono-font: "Source Code Pro", Consolas, "Ubuntu Mono", Menlo, "DejaVu Sans Mono", monospace, monospace;
+ --code-font-size: 0.875em /* please adjust the ace font size accordingly in editor.js */
+}
+
+/* Themes */
+
+.ayu {
+ --bg: hsl(210, 25%, 8%);
+ --fg: #c5c5c5;
+
+ --sidebar-bg: #14191f;
+ --sidebar-fg: #c8c9db;
+ --sidebar-non-existant: #5c6773;
+ --sidebar-active: #ffb454;
+ --sidebar-spacer: #2d334f;
+
+ --scrollbar: var(--sidebar-fg);
+
+ --icons: #737480;
+ --icons-hover: #b7b9cc;
+
+ --links: #0096cf;
+
+ --inline-code-color: #ffb454;
+
+ --theme-popup-bg: #14191f;
+ --theme-popup-border: #5c6773;
+ --theme-hover: #191f26;
+
+ --quote-bg: hsl(226, 15%, 17%);
+ --quote-border: hsl(226, 15%, 22%);
+
+ --warning-border: #ff8e00;
+
+ --table-border-color: hsl(210, 25%, 13%);
+ --table-header-bg: hsl(210, 25%, 28%);
+ --table-alternate-bg: hsl(210, 25%, 11%);
+
+ --searchbar-border-color: #848484;
+ --searchbar-bg: #424242;
+ --searchbar-fg: #fff;
+ --searchbar-shadow-color: #d4c89f;
+ --searchresults-header-fg: #666;
+ --searchresults-border-color: #888;
+ --searchresults-li-bg: #252932;
+ --search-mark-bg: #e3b171;
+
+ --color-scheme: dark;
+
+ /* Same as `--icons` */
+ --copy-button-filter: invert(45%) sepia(6%) saturate(621%) hue-rotate(198deg) brightness(99%) contrast(85%);
+ /* Same as `--sidebar-active` */
+ --copy-button-filter-hover: invert(68%) sepia(55%) saturate(531%) hue-rotate(341deg) brightness(104%) contrast(101%);
+}
+
+.coal {
+ --bg: hsl(200, 7%, 8%);
+ --fg: #98a3ad;
+
+ --sidebar-bg: #292c2f;
+ --sidebar-fg: #a1adb8;
+ --sidebar-non-existant: #505254;
+ --sidebar-active: #3473ad;
+ --sidebar-spacer: #393939;
+
+ --scrollbar: var(--sidebar-fg);
+
+ --icons: #43484d;
+ --icons-hover: #b3c0cc;
+
+ --links: #2b79a2;
+
+ --inline-code-color: #c5c8c6;
+
+ --theme-popup-bg: #141617;
+ --theme-popup-border: #43484d;
+ --theme-hover: #1f2124;
+
+ --quote-bg: hsl(234, 21%, 18%);
+ --quote-border: hsl(234, 21%, 23%);
+
+ --warning-border: #ff8e00;
+
+ --table-border-color: hsl(200, 7%, 13%);
+ --table-header-bg: hsl(200, 7%, 28%);
+ --table-alternate-bg: hsl(200, 7%, 11%);
+
+ --searchbar-border-color: #aaa;
+ --searchbar-bg: #b7b7b7;
+ --searchbar-fg: #000;
+ --searchbar-shadow-color: #aaa;
+ --searchresults-header-fg: #666;
+ --searchresults-border-color: #98a3ad;
+ --searchresults-li-bg: #2b2b2f;
+ --search-mark-bg: #355c7d;
+
+ --color-scheme: dark;
+
+ /* Same as `--icons` */
+ --copy-button-filter: invert(26%) sepia(8%) saturate(575%) hue-rotate(169deg) brightness(87%) contrast(82%);
+ /* Same as `--sidebar-active` */
+ --copy-button-filter-hover: invert(36%) sepia(70%) saturate(503%) hue-rotate(167deg) brightness(98%) contrast(89%);
+}
+
+.light, html:not(.js) {
+ --bg: hsl(0, 0%, 100%);
+ --fg: hsl(0, 0%, 0%);
+
+ --sidebar-bg: #fafafa;
+ --sidebar-fg: hsl(0, 0%, 0%);
+ --sidebar-non-existant: #aaaaaa;
+ --sidebar-active: #1f1fff;
+ --sidebar-spacer: #f4f4f4;
+
+ --scrollbar: #8F8F8F;
+
+ --icons: #747474;
+ --icons-hover: #000000;
+
+ --links: #20609f;
+
+ --inline-code-color: #301900;
+
+ --theme-popup-bg: #fafafa;
+ --theme-popup-border: #cccccc;
+ --theme-hover: #e6e6e6;
+
+ --quote-bg: hsl(197, 37%, 96%);
+ --quote-border: hsl(197, 37%, 91%);
+
+ --warning-border: #ff8e00;
+
+ --table-border-color: hsl(0, 0%, 95%);
+ --table-header-bg: hsl(0, 0%, 80%);
+ --table-alternate-bg: hsl(0, 0%, 97%);
+
+ --searchbar-border-color: #aaa;
+ --searchbar-bg: #fafafa;
+ --searchbar-fg: #000;
+ --searchbar-shadow-color: #aaa;
+ --searchresults-header-fg: #666;
+ --searchresults-border-color: #888;
+ --searchresults-li-bg: #e4f2fe;
+ --search-mark-bg: #a2cff5;
+
+ --color-scheme: light;
+
+ /* Same as `--icons` */
+ --copy-button-filter: invert(45.49%);
+ /* Same as `--sidebar-active` */
+ --copy-button-filter-hover: invert(14%) sepia(93%) saturate(4250%) hue-rotate(243deg) brightness(99%) contrast(130%);
+}
+
+.navy {
+ --bg: hsl(226, 23%, 11%);
+ --fg: #bcbdd0;
+
+ --sidebar-bg: #282d3f;
+ --sidebar-fg: #c8c9db;
+ --sidebar-non-existant: #505274;
+ --sidebar-active: #2b79a2;
+ --sidebar-spacer: #2d334f;
+
+ --scrollbar: var(--sidebar-fg);
+
+ --icons: #737480;
+ --icons-hover: #b7b9cc;
+
+ --links: #2b79a2;
+
+ --inline-code-color: #c5c8c6;
+
+ --theme-popup-bg: #161923;
+ --theme-popup-border: #737480;
+ --theme-hover: #282e40;
+
+ --quote-bg: hsl(226, 15%, 17%);
+ --quote-border: hsl(226, 15%, 22%);
+
+ --warning-border: #ff8e00;
+
+ --table-border-color: hsl(226, 23%, 16%);
+ --table-header-bg: hsl(226, 23%, 31%);
+ --table-alternate-bg: hsl(226, 23%, 14%);
+
+ --searchbar-border-color: #aaa;
+ --searchbar-bg: #aeaec6;
+ --searchbar-fg: #000;
+ --searchbar-shadow-color: #aaa;
+ --searchresults-header-fg: #5f5f71;
+ --searchresults-border-color: #5c5c68;
+ --searchresults-li-bg: #242430;
+ --search-mark-bg: #a2cff5;
+
+ --color-scheme: dark;
+
+ /* Same as `--icons` */
+ --copy-button-filter: invert(51%) sepia(10%) saturate(393%) hue-rotate(198deg) brightness(86%) contrast(87%);
+ /* Same as `--sidebar-active` */
+ --copy-button-filter-hover: invert(46%) sepia(20%) saturate(1537%) hue-rotate(156deg) brightness(85%) contrast(90%);
+}
+
+.rust {
+ --bg: hsl(60, 9%, 87%);
+ --fg: #262625;
+
+ --sidebar-bg: #3b2e2a;
+ --sidebar-fg: #c8c9db;
+ --sidebar-non-existant: #505254;
+ --sidebar-active: #e69f67;
+ --sidebar-spacer: #45373a;
+
+ --scrollbar: var(--sidebar-fg);
+
+ --icons: #737480;
+ --icons-hover: #262625;
+
+ --links: #2b79a2;
+
+ --inline-code-color: #6e6b5e;
+
+ --theme-popup-bg: #e1e1db;
+ --theme-popup-border: #b38f6b;
+ --theme-hover: #99908a;
+
+ --quote-bg: hsl(60, 5%, 75%);
+ --quote-border: hsl(60, 5%, 70%);
+
+ --warning-border: #ff8e00;
+
+ --table-border-color: hsl(60, 9%, 82%);
+ --table-header-bg: #b3a497;
+ --table-alternate-bg: hsl(60, 9%, 84%);
+
+ --searchbar-border-color: #aaa;
+ --searchbar-bg: #fafafa;
+ --searchbar-fg: #000;
+ --searchbar-shadow-color: #aaa;
+ --searchresults-header-fg: #666;
+ --searchresults-border-color: #888;
+ --searchresults-li-bg: #dec2a2;
+ --search-mark-bg: #e69f67;
+
+ /* Same as `--icons` */
+ --copy-button-filter: invert(51%) sepia(10%) saturate(393%) hue-rotate(198deg) brightness(86%) contrast(87%);
+ /* Same as `--sidebar-active` */
+ --copy-button-filter-hover: invert(77%) sepia(16%) saturate(1798%) hue-rotate(328deg) brightness(98%) contrast(83%);
+}
+
+@media (prefers-color-scheme: dark) {
+ html:not(.js) {
+ --bg: hsl(200, 7%, 8%);
+ --fg: #98a3ad;
+
+ --sidebar-bg: #292c2f;
+ --sidebar-fg: #a1adb8;
+ --sidebar-non-existant: #505254;
+ --sidebar-active: #3473ad;
+ --sidebar-spacer: #393939;
+
+ --scrollbar: var(--sidebar-fg);
+
+ --icons: #43484d;
+ --icons-hover: #b3c0cc;
+
+ --links: #2b79a2;
+
+ --inline-code-color: #c5c8c6;
+
+ --theme-popup-bg: #141617;
+ --theme-popup-border: #43484d;
+ --theme-hover: #1f2124;
+
+ --quote-bg: hsl(234, 21%, 18%);
+ --quote-border: hsl(234, 21%, 23%);
+
+ --warning-border: #ff8e00;
+
+ --table-border-color: hsl(200, 7%, 13%);
+ --table-header-bg: hsl(200, 7%, 28%);
+ --table-alternate-bg: hsl(200, 7%, 11%);
+
+ --searchbar-border-color: #aaa;
+ --searchbar-bg: #b7b7b7;
+ --searchbar-fg: #000;
+ --searchbar-shadow-color: #aaa;
+ --searchresults-header-fg: #666;
+ --searchresults-border-color: #98a3ad;
+ --searchresults-li-bg: #2b2b2f;
+ --search-mark-bg: #355c7d;
+
+ --color-scheme: dark;
+
+ /* Same as `--icons` */
+ --copy-button-filter: invert(26%) sepia(8%) saturate(575%) hue-rotate(169deg) brightness(87%) contrast(82%);
+ /* Same as `--sidebar-active` */
+ --copy-button-filter-hover: invert(36%) sepia(70%) saturate(503%) hue-rotate(167deg) brightness(98%) contrast(89%);
+ }
+}
diff --git a/elasticlunr.min.js b/elasticlunr.min.js
new file mode 100644
index 0000000..94b20dd
--- /dev/null
+++ b/elasticlunr.min.js
@@ -0,0 +1,10 @@
+/**
+ * elasticlunr - http://weixsong.github.io
+ * Lightweight full-text search engine in Javascript for browser search and offline search. - 0.9.5
+ *
+ * Copyright (C) 2017 Oliver Nightingale
+ * Copyright (C) 2017 Wei Song
+ * MIT Licensed
+ * @license
+ */
+!function(){function e(e){if(null===e||"object"!=typeof e)return e;var t=e.constructor();for(var n in e)e.hasOwnProperty(n)&&(t[n]=e[n]);return t}var t=function(e){var n=new t.Index;return n.pipeline.add(t.trimmer,t.stopWordFilter,t.stemmer),e&&e.call(n,n),n};t.version="0.9.5",lunr=t,t.utils={},t.utils.warn=function(e){return function(t){e.console&&console.warn&&console.warn(t)}}(this),t.utils.toString=function(e){return void 0===e||null===e?"":e.toString()},t.EventEmitter=function(){this.events={}},t.EventEmitter.prototype.addListener=function(){var e=Array.prototype.slice.call(arguments),t=e.pop(),n=e;if("function"!=typeof t)throw new TypeError("last argument must be a function");n.forEach(function(e){this.hasHandler(e)||(this.events[e]=[]),this.events[e].push(t)},this)},t.EventEmitter.prototype.removeListener=function(e,t){if(this.hasHandler(e)){var n=this.events[e].indexOf(t);-1!==n&&(this.events[e].splice(n,1),0==this.events[e].length&&delete this.events[e])}},t.EventEmitter.prototype.emit=function(e){if(this.hasHandler(e)){var t=Array.prototype.slice.call(arguments,1);this.events[e].forEach(function(e){e.apply(void 0,t)},this)}},t.EventEmitter.prototype.hasHandler=function(e){return e in this.events},t.tokenizer=function(e){if(!arguments.length||null===e||void 0===e)return[];if(Array.isArray(e)){var n=e.filter(function(e){return null===e||void 0===e?!1:!0});n=n.map(function(e){return t.utils.toString(e).toLowerCase()});var i=[];return n.forEach(function(e){var n=e.split(t.tokenizer.seperator);i=i.concat(n)},this),i}return e.toString().trim().toLowerCase().split(t.tokenizer.seperator)},t.tokenizer.defaultSeperator=/[\s\-]+/,t.tokenizer.seperator=t.tokenizer.defaultSeperator,t.tokenizer.setSeperator=function(e){null!==e&&void 0!==e&&"object"==typeof e&&(t.tokenizer.seperator=e)},t.tokenizer.resetSeperator=function(){t.tokenizer.seperator=t.tokenizer.defaultSeperator},t.tokenizer.getSeperator=function(){return t.tokenizer.seperator},t.Pipeline=function(){this._queue=[]},t.Pipeline.registeredFunctions={},t.Pipeline.registerFunction=function(e,n){n in t.Pipeline.registeredFunctions&&t.utils.warn("Overwriting existing registered function: "+n),e.label=n,t.Pipeline.registeredFunctions[n]=e},t.Pipeline.getRegisteredFunction=function(e){return e in t.Pipeline.registeredFunctions!=!0?null:t.Pipeline.registeredFunctions[e]},t.Pipeline.warnIfFunctionNotRegistered=function(e){var n=e.label&&e.label in this.registeredFunctions;n||t.utils.warn("Function is not registered with pipeline. This may cause problems when serialising the index.\n",e)},t.Pipeline.load=function(e){var n=new t.Pipeline;return e.forEach(function(e){var i=t.Pipeline.getRegisteredFunction(e);if(!i)throw new Error("Cannot load un-registered function: "+e);n.add(i)}),n},t.Pipeline.prototype.add=function(){var e=Array.prototype.slice.call(arguments);e.forEach(function(e){t.Pipeline.warnIfFunctionNotRegistered(e),this._queue.push(e)},this)},t.Pipeline.prototype.after=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i+1,0,n)},t.Pipeline.prototype.before=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i,0,n)},t.Pipeline.prototype.remove=function(e){var t=this._queue.indexOf(e);-1!==t&&this._queue.splice(t,1)},t.Pipeline.prototype.run=function(e){for(var t=[],n=e.length,i=this._queue.length,o=0;n>o;o++){for(var r=e[o],s=0;i>s&&(r=this._queue[s](r,o,e),void 0!==r&&null!==r);s++);void 0!==r&&null!==r&&t.push(r)}return t},t.Pipeline.prototype.reset=function(){this._queue=[]},t.Pipeline.prototype.get=function(){return this._queue},t.Pipeline.prototype.toJSON=function(){return this._queue.map(function(e){return t.Pipeline.warnIfFunctionNotRegistered(e),e.label})},t.Index=function(){this._fields=[],this._ref="id",this.pipeline=new t.Pipeline,this.documentStore=new t.DocumentStore,this.index={},this.eventEmitter=new t.EventEmitter,this._idfCache={},this.on("add","remove","update",function(){this._idfCache={}}.bind(this))},t.Index.prototype.on=function(){var e=Array.prototype.slice.call(arguments);return this.eventEmitter.addListener.apply(this.eventEmitter,e)},t.Index.prototype.off=function(e,t){return this.eventEmitter.removeListener(e,t)},t.Index.load=function(e){e.version!==t.version&&t.utils.warn("version mismatch: current "+t.version+" importing "+e.version);var n=new this;n._fields=e.fields,n._ref=e.ref,n.documentStore=t.DocumentStore.load(e.documentStore),n.pipeline=t.Pipeline.load(e.pipeline),n.index={};for(var i in e.index)n.index[i]=t.InvertedIndex.load(e.index[i]);return n},t.Index.prototype.addField=function(e){return this._fields.push(e),this.index[e]=new t.InvertedIndex,this},t.Index.prototype.setRef=function(e){return this._ref=e,this},t.Index.prototype.saveDocument=function(e){return this.documentStore=new t.DocumentStore(e),this},t.Index.prototype.addDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.addDoc(i,e),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));this.documentStore.addFieldLength(i,n,o.length);var r={};o.forEach(function(e){e in r?r[e]+=1:r[e]=1},this);for(var s in r){var u=r[s];u=Math.sqrt(u),this.index[n].addToken(s,{ref:i,tf:u})}},this),n&&this.eventEmitter.emit("add",e,this)}},t.Index.prototype.removeDocByRef=function(e){if(e&&this.documentStore.isDocStored()!==!1&&this.documentStore.hasDoc(e)){var t=this.documentStore.getDoc(e);this.removeDoc(t,!1)}},t.Index.prototype.removeDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.hasDoc(i)&&(this.documentStore.removeDoc(i),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));o.forEach(function(e){this.index[n].removeToken(e,i)},this)},this),n&&this.eventEmitter.emit("remove",e,this))}},t.Index.prototype.updateDoc=function(e,t){var t=void 0===t?!0:t;this.removeDocByRef(e[this._ref],!1),this.addDoc(e,!1),t&&this.eventEmitter.emit("update",e,this)},t.Index.prototype.idf=function(e,t){var n="@"+t+"/"+e;if(Object.prototype.hasOwnProperty.call(this._idfCache,n))return this._idfCache[n];var i=this.index[t].getDocFreq(e),o=1+Math.log(this.documentStore.length/(i+1));return this._idfCache[n]=o,o},t.Index.prototype.getFields=function(){return this._fields.slice()},t.Index.prototype.search=function(e,n){if(!e)return[];e="string"==typeof e?{any:e}:JSON.parse(JSON.stringify(e));var i=null;null!=n&&(i=JSON.stringify(n));for(var o=new t.Configuration(i,this.getFields()).get(),r={},s=Object.keys(e),u=0;u
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Concepts & Data Model
+vidformer builds on the data model introduced in the V2V paper.
+-
+
-
+
Frames are a single image. +Frames are represented as their resolution and pixel format (the type and layout of pixels in memory, such as
+rgb24,gray8, oryuv420p).
+ -
+
Videos are sequences of frames represented as an array. +We index these arrays by rational numbers corresponding to their timestamp.
+
+ -
+
Filters are functions which construct a frame. +Filters can take inputs, such as frames or data. +For example,
+DrawTextmay draw some text on a frame.
+ -
+
Specs declarativly represent a video synthesis task. +They represent the construction of a result videos, which is itself modeled as an array.
+-
+
- Specs primairly contan
domainandrenderfunctions. +-
+
- A spec's domain function returns the timestamps of the output frames. +
- A spec's render function returns a composition of filters used to construct a frame at a spesific timestamp. +
+
+ - Specs primairly contan
-
+
Data Arrays allow using data in specs symbolically, as opposed to inserting constants directly into the spec. +These allow for deduplication and loading large data blobs efficiently.
+-
+
- Data Arrays can be backed by external data sources, such as SQL databases. +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/favicon.png b/favicon.png
new file mode 100644
index 0000000..a5b1aa1
Binary files /dev/null and b/favicon.png differ
diff --git a/favicon.svg b/favicon.svg
new file mode 100644
index 0000000..90e0ea5
--- /dev/null
+++ b/favicon.svg
@@ -0,0 +1,22 @@
+
+
diff --git a/filters.html b/filters.html
new file mode 100644
index 0000000..a15b41b
--- /dev/null
+++ b/filters.html
@@ -0,0 +1,215 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ FAQ
+What video formats does vidformer support?
+In short, essentially everything. +vidformer uses the FFmpeg/libav* libraries internally, so any media FFmpeg works with should work in vidformer as well. +We support many container formats (e.g., mp4, mov) and codecs (e.g., H.264, VP8).
+A full list of supported codecs enabled in a vidformer build can be found by running:
+vidformer-cli codecs
+Can I access remote videos on the internet?
+Yes, vidformer uses Apache OpenDAL for I/O, so most common data/storage access protocols are supported. +However, not all storage services are enabled in distributed binaries. +We guarantee that HTTP, S3, and the local filesystem always work.
+How does vidformer compare to FFmpeg?
+vidformer is far more expressive than the FFmpeg filter interface. +Mainly, vidformer is designed for work around data, so edits are created programatically and edits can reference data. +Also, vidformer enables serving resut videos on demand.
+vidformer uses the FFmpeg/libav* libraries internally, so any media FFmpeg works with should also work in vidformer.
+How does vidformer compare to OpenCV/cv2?
+vidformer orchestrates data movment in video synthesis tasks, but does not implement image processing directly. +Most use cases will still use OpenCV for this.
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/fonts/OPEN-SANS-LICENSE.txt b/fonts/OPEN-SANS-LICENSE.txt
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/fonts/OPEN-SANS-LICENSE.txt
@@ -0,0 +1,202 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
diff --git a/fonts/SOURCE-CODE-PRO-LICENSE.txt b/fonts/SOURCE-CODE-PRO-LICENSE.txt
new file mode 100644
index 0000000..366206f
--- /dev/null
+++ b/fonts/SOURCE-CODE-PRO-LICENSE.txt
@@ -0,0 +1,93 @@
+Copyright 2010, 2012 Adobe Systems Incorporated (http://www.adobe.com/), with Reserved Font Name 'Source'. All Rights Reserved. Source is a trademark of Adobe Systems Incorporated in the United States and/or other countries.
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
diff --git a/fonts/fonts.css b/fonts/fonts.css
new file mode 100644
index 0000000..858efa5
--- /dev/null
+++ b/fonts/fonts.css
@@ -0,0 +1,100 @@
+/* Open Sans is licensed under the Apache License, Version 2.0. See http://www.apache.org/licenses/LICENSE-2.0 */
+/* Source Code Pro is under the Open Font License. See https://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&id=OFL */
+
+/* open-sans-300 - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: normal;
+ font-weight: 300;
+ src: local('Open Sans Light'), local('OpenSans-Light'),
+ url('open-sans-v17-all-charsets-300.woff2') format('woff2');
+}
+
+/* open-sans-300italic - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: italic;
+ font-weight: 300;
+ src: local('Open Sans Light Italic'), local('OpenSans-LightItalic'),
+ url('open-sans-v17-all-charsets-300italic.woff2') format('woff2');
+}
+
+/* open-sans-regular - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: normal;
+ font-weight: 400;
+ src: local('Open Sans Regular'), local('OpenSans-Regular'),
+ url('open-sans-v17-all-charsets-regular.woff2') format('woff2');
+}
+
+/* open-sans-italic - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: italic;
+ font-weight: 400;
+ src: local('Open Sans Italic'), local('OpenSans-Italic'),
+ url('open-sans-v17-all-charsets-italic.woff2') format('woff2');
+}
+
+/* open-sans-600 - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: normal;
+ font-weight: 600;
+ src: local('Open Sans SemiBold'), local('OpenSans-SemiBold'),
+ url('open-sans-v17-all-charsets-600.woff2') format('woff2');
+}
+
+/* open-sans-600italic - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: italic;
+ font-weight: 600;
+ src: local('Open Sans SemiBold Italic'), local('OpenSans-SemiBoldItalic'),
+ url('open-sans-v17-all-charsets-600italic.woff2') format('woff2');
+}
+
+/* open-sans-700 - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: normal;
+ font-weight: 700;
+ src: local('Open Sans Bold'), local('OpenSans-Bold'),
+ url('open-sans-v17-all-charsets-700.woff2') format('woff2');
+}
+
+/* open-sans-700italic - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: italic;
+ font-weight: 700;
+ src: local('Open Sans Bold Italic'), local('OpenSans-BoldItalic'),
+ url('open-sans-v17-all-charsets-700italic.woff2') format('woff2');
+}
+
+/* open-sans-800 - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: normal;
+ font-weight: 800;
+ src: local('Open Sans ExtraBold'), local('OpenSans-ExtraBold'),
+ url('open-sans-v17-all-charsets-800.woff2') format('woff2');
+}
+
+/* open-sans-800italic - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: italic;
+ font-weight: 800;
+ src: local('Open Sans ExtraBold Italic'), local('OpenSans-ExtraBoldItalic'),
+ url('open-sans-v17-all-charsets-800italic.woff2') format('woff2');
+}
+
+/* source-code-pro-500 - latin_vietnamese_latin-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Source Code Pro';
+ font-style: normal;
+ font-weight: 500;
+ src: url('source-code-pro-v11-all-charsets-500.woff2') format('woff2');
+}
diff --git a/fonts/open-sans-v17-all-charsets-300.woff2 b/fonts/open-sans-v17-all-charsets-300.woff2
new file mode 100644
index 0000000..9f51be3
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-300.woff2 differ
diff --git a/fonts/open-sans-v17-all-charsets-300italic.woff2 b/fonts/open-sans-v17-all-charsets-300italic.woff2
new file mode 100644
index 0000000..2f54544
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-300italic.woff2 differ
diff --git a/fonts/open-sans-v17-all-charsets-600.woff2 b/fonts/open-sans-v17-all-charsets-600.woff2
new file mode 100644
index 0000000..f503d55
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-600.woff2 differ
diff --git a/fonts/open-sans-v17-all-charsets-600italic.woff2 b/fonts/open-sans-v17-all-charsets-600italic.woff2
new file mode 100644
index 0000000..c99aabe
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-600italic.woff2 differ
diff --git a/fonts/open-sans-v17-all-charsets-700.woff2 b/fonts/open-sans-v17-all-charsets-700.woff2
new file mode 100644
index 0000000..421a1ab
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-700.woff2 differ
diff --git a/fonts/open-sans-v17-all-charsets-700italic.woff2 b/fonts/open-sans-v17-all-charsets-700italic.woff2
new file mode 100644
index 0000000..12ce3d2
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-700italic.woff2 differ
diff --git a/fonts/open-sans-v17-all-charsets-800.woff2 b/fonts/open-sans-v17-all-charsets-800.woff2
new file mode 100644
index 0000000..c94a223
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-800.woff2 differ
diff --git a/fonts/open-sans-v17-all-charsets-800italic.woff2 b/fonts/open-sans-v17-all-charsets-800italic.woff2
new file mode 100644
index 0000000..eed7d3c
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-800italic.woff2 differ
diff --git a/fonts/open-sans-v17-all-charsets-italic.woff2 b/fonts/open-sans-v17-all-charsets-italic.woff2
new file mode 100644
index 0000000..398b68a
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-italic.woff2 differ
diff --git a/fonts/open-sans-v17-all-charsets-regular.woff2 b/fonts/open-sans-v17-all-charsets-regular.woff2
new file mode 100644
index 0000000..8383e94
Binary files /dev/null and b/fonts/open-sans-v17-all-charsets-regular.woff2 differ
diff --git a/fonts/source-code-pro-v11-all-charsets-500.woff2 b/fonts/source-code-pro-v11-all-charsets-500.woff2
new file mode 100644
index 0000000..7222456
Binary files /dev/null and b/fonts/source-code-pro-v11-all-charsets-500.woff2 differ
diff --git a/getting-started-cv2.html b/getting-started-cv2.html
new file mode 100644
index 0000000..38e316b
--- /dev/null
+++ b/getting-started-cv2.html
@@ -0,0 +1,278 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/getting-started-dsl.html b/getting-started-dsl.html
new file mode 100644
index 0000000..a2611b5
--- /dev/null
+++ b/getting-started-dsl.html
@@ -0,0 +1,340 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Getting Started - cv2
+This is a walkthrough of getting started with vidformer OpenCV cv2 compatability layer.
++⚠️ Adding
+cv2functions is a work in progress. See the cv2 filters page for which functions have been implemented.
Installation
+ +Or you can 
.
++⚠️ Due to how Colab networking works, vidformer can't stream/play results in Colab, only save them to disk.
+cv2.vidplay()will not work!
Hello, world!
+Copy in your video, or use ours:
+curl -O https://f.dominik.win/data/dve2/tos_720p.mp4
+Then just replace import cv2 with import vidformer.cv2 as cv2.
+Here's our example script:
import vidformer.cv2 as cv2
+
+cap = cv2.VideoCapture("tos_720p.mp4")
+fps = cap.get(cv2.CAP_PROP_FPS)
+width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+
+out = cv2.VideoWriter("output.mp4", cv2.VideoWriter_fourcc(*"mp4v"),
+ fps, (width, height))
+while True:
+ ret, frame = cap.read()
+ if not ret:
+ break
+
+ cv2.putText(frame, "Hello, World!", (100, 100), cv2.FONT_HERSHEY_SIMPLEX,
+ 1, (255, 0, 0), 1)
+ out.write(frame)
+
+cap.release()
+out.release()
+Stream the Results
+Saving videos to disk works, but we can also display them in the notebook. +Since we stream the results and only render them on demand this can start practically instantly!
+First, replace "output.mp4" with None to skip writing the video to disk.
+Then you can use cv2.vidplay() to play the video!
import vidformer.cv2 as cv2
+
+cap = cv2.VideoCapture("tos_720p.mp4")
+fps = cap.get(cv2.CAP_PROP_FPS)
+width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+
+out = cv2.VideoWriter(None, cv2.VideoWriter_fourcc(*"mp4v"),
+ fps, (width, height))
+while True:
+ ret, frame = cap.read()
+ if not ret:
+ break
+
+ cv2.putText(frame, "Hello, World!", (100, 100), cv2.FONT_HERSHEY_SIMPLEX,
+ 1, (255, 0, 0), 1)
+ out.write(frame)
+
+cap.release()
+out.release()
+
+cv2.vidplay(out)
+++ +⚠️ By default
+cv2.vidplay()will return a video which plays in a Jupyter Notebook. If running outside a jupyter notebook you can passmethod="link"to return a link instead.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/getting-started.html b/getting-started.html
new file mode 100644
index 0000000..20de8d9
--- /dev/null
+++ b/getting-started.html
@@ -0,0 +1,215 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Getting Started - DSL
+This is a walkthrough of getting started with vidformer-py core DSL.
Installation
+ +Hello, world!
+++⚠️ We assume this is in a Jupyter notebook. If not then
+.play()won't work and you have to use.save()instead.
We start by connecting to a server and registering a source:
+import vidformer as vf
+from fractions import Fraction
+
+server = vf.YrdenServer(domain='localhost', port=8000)
+
+tos = vf.Source(
+ server,
+ "tos_720p", # name (for pretty printing)
+ "https://f.dominik.win/data/dve2/tos_720p.mp4",
+ stream=0, # index of the video stream we want to use
+)
+
+print(tos.ts())
+print(tos.fmt())
+This will print the timestamps of all the frames in the video, and then format information: +This may take a few seconds the first time, but frame times are cached afterwords.
+> [Fraction(0, 1), Fraction(1, 24), Fraction(1, 12), Fraction(1, 8), ...]
+> {'width': 1280, 'height': 720, 'pix_fmt': 'yuv420p'}
+Now lets create a 30 second clip starting at the 5 minute mark. +The source video is at at a constant 24 FPS, so lets create a 24 FPS output as well:
+domain = [Fraction(i, 24) for i in range(24 * 30)]
+Now we need to render each of these frames, so we define a render function.
+def render(t: Fraction, i: int):
+ clip_start_point = Fraction(5 * 60, 1) # start at 5 * 60 seconds
+ return tos[t + clip_start_point]
+We used timestamp-based indexing here, but you can also use integer indexing (tos.iloc[i + 5 * 60 * 24]).
Now we can create a spec and play it in the browser.
+We create a spec from the resulting video's frame timestamps (domain), a function to construct each output frame (render), and the output videos format (matching tos.fmt()).
spec = vf.Spec(domain, render, tos.fmt())
+spec.play(server)
+This plays this result: +
+++Some Jupyter environments are weird (i.e., VS Code), so
+.play()might not work. Using.play(..., method="iframe")may help.
It's worth noting that we are playing frames in order here and outputing video at the same framerate we recieved, but that doesn't need to be the case. +Here are some things other things you can now try:
+-
+
- Reversing the video +
- Double the speed of the video
+
-
+
- Either double the framerate or sample every other frame +
+ - Shuffle the frames into a random order +
- Combining frames from multiple videos +
- Create a variable frame rate video
+
-
+
- Note:
.play()will not work with VFR, but.save()will.
+
+ - Note:
Bounding Boxes
+Now let's overlay some bouding boxes over the entire clip:
+# Load some data
+import urllib.request, json
+with urllib.request.urlopen("https://f.dominik.win/data/dve2/tos_720p-objects.json") as r:
+ detections_per_frame = json.load(r)
+
+bbox = vf.Filter("BoundingBox") # load the built-in BoundingBox filter
+
+domain = tos.ts() # output should have same frame timestamps as our example clip
+
+def render(t, i):
+ return bbox(
+ tos[t],
+ bounds=detections_per_frame[i])
+
+spec = vf.Spec(domain, render, tos.fmt())
+spec.play(server)
+This plays this result (video is just a sample clip): +
+Composition
+We can place frames next to each other with the HStack and VStack filters.
+For example, HStack(left_frame, middle_frame, right_frame, width=1280, height=720, format="yuv420p") will place three frames side-by-side.
As a larger example, we can view a window function over frames as a 5x5 grid:
+hstack = vf.Filter("HStack")
+vstack = vf.Filter("VStack")
+
+w, h = 1920, 1080
+
+def create_grid(tos, i, N, width, height, fmt="yuv420p"):
+ grid = []
+ for row in range(N):
+ columns = []
+ for col in range(N):
+ index = row * N + col
+ columns.append(tos.iloc[i + index])
+ grid.append(hstack(*columns, width=width, height=height//N, format=fmt))
+ final_grid = vstack(*grid, width=width, height=height, format=fmt)
+ return final_grid
+
+domain = [Fraction(i, 24) for i in range(0, 5000)]
+
+def render(t, i):
+ return create_grid(tos, i, 5, w, h)
+
+fmt = {'width': w, 'height': h, 'pix_fmt': 'yuv420p'}
+
+spec = vf.Spec(domain, render, fmt)
+spec.play(server)
+This plays this result (video is just a sample clip): +
+Viewing Telemetry (and User-Defined Filters)
+This notebook shows how to build custom filters to overlay data.
+This plays this result (video is just a sample clip): +
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/help.html b/help.html
new file mode 100644
index 0000000..7a071e7
--- /dev/null
+++ b/help.html
@@ -0,0 +1 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Rustdoc help
Back":e:f.tabReplace?e.replace(/\t/g,f.tabReplace):e):e}function E(e){let n=null;const t=function(e){var n=e.className+" ";n+=e.parentNode?e.parentNode.className:"";const t=f.languageDetectRe.exec(n);if(t){var r=T(t[1]);return r||(console.warn(g.replace("{}",t[1])),console.warn("Falling back to no-highlight mode for this block.",e)),r?t[1]:"no-highlight"}return n.split(/\s+/).find(e=>p(e)||T(e))}(e);if(p(t))return;S("before:highlightBlock",{block:e,language:t}),f.useBR?(n=document.createElement("div")).innerHTML=e.innerHTML.replace(/\n/g,"").replace(/
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/install.html b/install.html
new file mode 100644
index 0000000..878ee6f
--- /dev/null
+++ b/install.html
@@ -0,0 +1,251 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ vidformer - Video Data Transformation
+
+
+
+
A research project providing infrastructure for video interfaces and pipelines. +Developed by the OSU Interactive Data Systems Lab.
+🎯 Why vidformer
+Vidformer efficiently transforms video data, enabling faster annotation, editing, and processing of video data—without having to focus on performance.
+It uses a declarative specification format to represent transformations. This enables:
+-
+
-
+
⚡ Transparent Optimization: Vidformer optimizes the execution of declarative specifications just like a relational database optimizes relational queries.
+
+ -
+
⏳ Lazy/Deferred Execution: Video results can be retrieved on-demand, allowing for practically instantaneous playback of video results.
+
+ -
+
🔄 Transpilation: Vidformer specifications can be created from existing code (like
+cv2).
+
🚀 Quick Start
+
The easiest way to get started is using vidformer's cv2 frontend, which allows most Python OpenCV visualization scripts to replace import cv2 with import vidformer.cv2 as cv2:
import vidformer.cv2 as cv2
+
+cap = cv2.VideoCapture("my_input.mp4")
+fps = cap.get(cv2.CAP_PROP_FPS)
+width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+
+out = cv2.VideoWriter("my_output.mp4", cv2.VideoWriter_fourcc(*"mp4v"),
+ fps, (width, height))
+while True:
+ ret, frame = cap.read()
+ if not ret:
+ break
+
+ cv2.putText(frame, "Hello, World!", (100, 100), cv2.FONT_HERSHEY_SIMPLEX,
+ 1, (255, 0, 0), 1)
+ out.write(frame)
+
+cap.release()
+out.release()
+You can find details on this in our Getting Started Guide.
+📘 Documentation
+ +🔍 About the project
+Vidformer is a highly modular suite of tools that work together; these are detailed here.
+❌ vidformer is NOT:
+-
+
- A conventional video editor (like Premiere Pro or Final Cut) +
- A video database/VDBMS +
- A natural language query interface for video +
- A computer vision library (like OpenCV) +
- A computer vision AI model (like CLIP or Yolo) +
However, vidformer is highly complementary to each of these. +If you're working on any of the later four, vidformer may be for you.
+File Layout:
+-
+
- ./vidformer: The core transformation library +
- ./vidformer-py: A Python video editing client +
- ./vidformer-cli: A command-line interface for vidformer servers +
- ./snake-pit: The main vidformer test suite +
- ./docs: The vidformer website +
License: Vidformer is open source under Apache-2.0. +Contributions welcome.
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/introduction.html b/introduction.html
new file mode 100644
index 0000000..0e44879
--- /dev/null
+++ b/introduction.html
@@ -0,0 +1,279 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Install
+Using vidformer requires the Python client library, vidformer-py, and a yrden server which is distributed through vidformer-cli.
vidformer-py
+pip install vidformer
+vidformer-cli
+🐳 Docker:
+docker pull dominikwinecki/vidformer:latest
+docker run --rm -it -p 8000:8000 dominikwinecki/vidformer:latest yrden --print-url
+This launches a vidformer yrden server, which is our reference server implementation for local usage, on port 8000.
+If you want to read or save video files locally add -v /my/local/dir:/data and then reference them as /data in the code.
To use:
+import vidformer as vf
+server = vf.YrdenServer(domain="localhost", port=8000)
+
+# or for cv2
+import vidformer.cv2 as cv2
+cv2.set_cv2_server(server)
+Precompiled binary:
+Precompiled binaries are available for vidformer releases.
+For example:
+wget https://github.com/ixlab/vidformer/releases/download/<version>/vidformer-cli-ubuntu22.04-amd64
+sudo mv vidformer-cli-ubuntu22.04-amd64 /usr/local/bin/vidformer-cli
+sudo chmod +x /usr/local/bin/vidformer-cli
+sudo apt install -y libopencv-dev libfdk-aac-dev
+To use:
+import vidformer as vf
+server = vf.YrdenServer(bin="vidformer-cli")
+or
+export VIDFORMER_BIN='vidformer-cli'
+import vidformer as vf
+server = vf.YrdenServer()
+Build from Sources
+vidformer-cli can be compiled from our git repo with a standard cargo build.
This depends on the core vidformer library which itself requires linking to FFmpeg and OpenCV.
+Details are available here.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/libvidformer.html b/libvidformer.html
new file mode 100644
index 0000000..435eea4
--- /dev/null
+++ b/libvidformer.html
@@ -0,0 +1,242 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ vidformer - Video Data Transformation
+
+
+
+
A research project providing infrastructure for video interfaces and pipelines. +Developed by the OSU Interactive Data Systems Lab.
+🎯 Why vidformer
+Vidformer efficiently transforms video data, enabling faster annotation, editing, and processing of video data—without having to focus on performance.
+It uses a declarative specification format to represent transformations. This enables:
+-
+
-
+
⚡ Transparent Optimization: Vidformer optimizes the execution of declarative specifications just like a relational database optimizes relational queries.
+
+ -
+
⏳ Lazy/Deferred Execution: Video results can be retrieved on-demand, allowing for practically instantaneous playback of video results.
+
+ -
+
🔄 Transpilation: Vidformer specifications can be created from existing code (like
+cv2).
+
🚀 Quick Start
+
The easiest way to get started is using vidformer's cv2 frontend, which allows most Python OpenCV visualization scripts to replace import cv2 with import vidformer.cv2 as cv2:
import vidformer.cv2 as cv2
+
+cap = cv2.VideoCapture("my_input.mp4")
+fps = cap.get(cv2.CAP_PROP_FPS)
+width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+
+out = cv2.VideoWriter("my_output.mp4", cv2.VideoWriter_fourcc(*"mp4v"),
+ fps, (width, height))
+while True:
+ ret, frame = cap.read()
+ if not ret:
+ break
+
+ cv2.putText(frame, "Hello, World!", (100, 100), cv2.FONT_HERSHEY_SIMPLEX,
+ 1, (255, 0, 0), 1)
+ out.write(frame)
+
+cap.release()
+out.release()
+You can find details on this in our Getting Started Guide.
+📘 Documentation
+ +🔍 About the project
+Vidformer is a highly modular suite of tools that work together; these are detailed here.
+❌ vidformer is NOT:
+-
+
- A conventional video editor (like Premiere Pro or Final Cut) +
- A video database/VDBMS +
- A natural language query interface for video +
- A computer vision library (like OpenCV) +
- A computer vision AI model (like CLIP or Yolo) +
However, vidformer is highly complementary to each of these. +If you're working on any of the later four, vidformer may be for you.
+File Layout:
+-
+
- ./vidformer: The core transformation library +
- ./vidformer-py: A Python video editing client +
- ./vidformer-cli: A command-line interface for vidformer servers +
- ./snake-pit: The main vidformer test suite +
- ./docs: The vidformer website +
License: Vidformer is open source under Apache-2.0. +Contributions welcome.
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/mark.min.js b/mark.min.js
new file mode 100644
index 0000000..1636231
--- /dev/null
+++ b/mark.min.js
@@ -0,0 +1,7 @@
+/*!***************************************************
+* mark.js v8.11.1
+* https://markjs.io/
+* Copyright (c) 2014–2018, Julian Kühnel
+* Released under the MIT license https://git.io/vwTVl
+*****************************************************/
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):e.Mark=t()}(this,function(){"use strict";var e="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},t=function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")},n=function(){function e(e,t){for(var n=0;n
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ vidformer - Video Data Transformation Library
+
(lib)vidformer is a core video synthesis/transformation library. +It handles the movement, control flow, and processing of video and conventional (non-video) data.
+Quick links:
+ +About
+-
+
- It's written in Rust 🦀
+
-
+
- So it does some fancy parallel processing and does so safely +
+ - Uses the FFmpeg libav libraries for multimedia stuff
+
-
+
- So it should work with nearly every video file ever made +
+ - Uses Apache OpenDAL for I/O
+
-
+
- So it can access videos in a bunch of storage services +
+ - Implements filters using OpenCV +
Building
+This crate requires linking with FFmpeg, as detailed in the rusty_ffmpeg crate.
+We currently target FFmpeg 7.0.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/print.html b/print.html
new file mode 100644
index 0000000..f6f6fb0
--- /dev/null
+++ b/print.html
@@ -0,0 +1,871 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ OpenCV/cv2 Functions
+ +++⚠️ The
+cv2module is a work in progress. If you find a bug or need a missing feature implemented feel free to file an issue or contribute yourself!
Legend:
+-
+
- ✅ - Support +
- 🔸 - Support via OpenCV cv2 +
- ❌ - Not yet implemented +
Vidformer-specific Functions
+-
+
cv2.vidplay(video2)- Play a VideoWriter, Spec, or Source
+VideoWriter.spec()- Return the Spec of an output video
+Frame.numpy()- Return the frame as a numpy array
+cv2.setTo- The OpenCVMat.setTofunction (not in cv2)
+
opencv
+| Class | Status |
|---|---|
| VideoCapture | ✅ |
| VideoWriter | ✅ |
| VideoWriter_fourcc | ✅ |
| Function | Status |
|---|---|
| imread | ✅ |
| imwrite | ✅ |
opencv.imgproc
+Drawing Functions:
+| Function | Status |
|---|---|
| arrowedLine | ✅ |
| circle | ✅ |
| clipLine | ❌ |
| drawContours | ❌ |
| drawMarker | ❌ |
| ellipse | ❌ |
| ellipse2Poly | ❌ |
| fillConvexPoly | ❌ |
| fillPoly | ❌ |
| getFontScaleFromHeight | 🔸 |
| getTextSize | 🔸 |
| line | ✅ |
| polylines | ❌ |
| putText | ✅ |
| rectangle | ✅ |
opencv.core
+| Function | Status |
|---|---|
| addWeighted | ✅ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/roadmap.html b/roadmap.html
new file mode 100644
index 0000000..bc0b975
--- /dev/null
+++ b/roadmap.html
@@ -0,0 +1,228 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ vidformer - Video Data Transformation
+
+
+
+
A research project providing infrastructure for video interfaces and pipelines. +Developed by the OSU Interactive Data Systems Lab.
+🎯 Why vidformer
+Vidformer efficiently transforms video data, enabling faster annotation, editing, and processing of video data—without having to focus on performance.
+It uses a declarative specification format to represent transformations. This enables:
+-
+
-
+
⚡ Transparent Optimization: Vidformer optimizes the execution of declarative specifications just like a relational database optimizes relational queries.
+
+ -
+
⏳ Lazy/Deferred Execution: Video results can be retrieved on-demand, allowing for practically instantaneous playback of video results.
+
+ -
+
🔄 Transpilation: Vidformer specifications can be created from existing code (like
+cv2).
+
🚀 Quick Start
+
The easiest way to get started is using vidformer's cv2 frontend, which allows most Python OpenCV visualization scripts to replace import cv2 with import vidformer.cv2 as cv2:
import vidformer.cv2 as cv2
+
+cap = cv2.VideoCapture("my_input.mp4")
+fps = cap.get(cv2.CAP_PROP_FPS)
+width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+
+out = cv2.VideoWriter("my_output.mp4", cv2.VideoWriter_fourcc(*"mp4v"),
+ fps, (width, height))
+while True:
+ ret, frame = cap.read()
+ if not ret:
+ break
+
+ cv2.putText(frame, "Hello, World!", (100, 100), cv2.FONT_HERSHEY_SIMPLEX,
+ 1, (255, 0, 0), 1)
+ out.write(frame)
+
+cap.release()
+out.release()
+You can find details on this in our Getting Started Guide.
+📘 Documentation
+ +🔍 About the project
+Vidformer is a highly modular suite of tools that work together; these are detailed here.
+❌ vidformer is NOT:
+-
+
- A conventional video editor (like Premiere Pro or Final Cut) +
- A video database/VDBMS +
- A natural language query interface for video +
- A computer vision library (like OpenCV) +
- A computer vision AI model (like CLIP or Yolo) +
However, vidformer is highly complementary to each of these. +If you're working on any of the later four, vidformer may be for you.
+File Layout:
+-
+
- ./vidformer: The core transformation library +
- ./vidformer-py: A Python video editing client +
- ./vidformer-cli: A command-line interface for vidformer servers +
- ./snake-pit: The main vidformer test suite +
- ./docs: The vidformer website +
License: Vidformer is open source under Apache-2.0. +Contributions welcome.
+Getting Started
+-
+
- Installation +
- Getting started with the
cv2compatability layer
+ - Getting started with the core vidformer-py DSL +
Install
+Using vidformer requires the Python client library, vidformer-py, and a yrden server which is distributed through vidformer-cli.
vidformer-py
+pip install vidformer
+vidformer-cli
+🐳 Docker:
+docker pull dominikwinecki/vidformer:latest
+docker run --rm -it -p 8000:8000 dominikwinecki/vidformer:latest yrden --print-url
+This launches a vidformer yrden server, which is our reference server implementation for local usage, on port 8000.
+If you want to read or save video files locally add -v /my/local/dir:/data and then reference them as /data in the code.
To use:
+import vidformer as vf
+server = vf.YrdenServer(domain="localhost", port=8000)
+
+# or for cv2
+import vidformer.cv2 as cv2
+cv2.set_cv2_server(server)
+Precompiled binary:
+Precompiled binaries are available for vidformer releases.
+For example:
+wget https://github.com/ixlab/vidformer/releases/download/<version>/vidformer-cli-ubuntu22.04-amd64
+sudo mv vidformer-cli-ubuntu22.04-amd64 /usr/local/bin/vidformer-cli
+sudo chmod +x /usr/local/bin/vidformer-cli
+sudo apt install -y libopencv-dev libfdk-aac-dev
+To use:
+import vidformer as vf
+server = vf.YrdenServer(bin="vidformer-cli")
+or
+export VIDFORMER_BIN='vidformer-cli'
+import vidformer as vf
+server = vf.YrdenServer()
+Build from Sources
+vidformer-cli can be compiled from our git repo with a standard cargo build.
This depends on the core vidformer library which itself requires linking to FFmpeg and OpenCV.
+Details are available here.
Getting Started - cv2
+This is a walkthrough of getting started with vidformer OpenCV cv2 compatability layer.
++⚠️ Adding
+cv2functions is a work in progress. See the cv2 filters page for which functions have been implemented.
Installation
+ +Or you can .
++⚠️ Due to how Colab networking works, vidformer can't stream/play results in Colab, only save them to disk.
+cv2.vidplay()will not work!
Hello, world!
+Copy in your video, or use ours:
+curl -O https://f.dominik.win/data/dve2/tos_720p.mp4
+Then just replace import cv2 with import vidformer.cv2 as cv2.
+Here's our example script:
import vidformer.cv2 as cv2
+
+cap = cv2.VideoCapture("tos_720p.mp4")
+fps = cap.get(cv2.CAP_PROP_FPS)
+width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+
+out = cv2.VideoWriter("output.mp4", cv2.VideoWriter_fourcc(*"mp4v"),
+ fps, (width, height))
+while True:
+ ret, frame = cap.read()
+ if not ret:
+ break
+
+ cv2.putText(frame, "Hello, World!", (100, 100), cv2.FONT_HERSHEY_SIMPLEX,
+ 1, (255, 0, 0), 1)
+ out.write(frame)
+
+cap.release()
+out.release()
+Stream the Results
+Saving videos to disk works, but we can also display them in the notebook. +Since we stream the results and only render them on demand this can start practically instantly!
+First, replace "output.mp4" with None to skip writing the video to disk.
+Then you can use cv2.vidplay() to play the video!
import vidformer.cv2 as cv2
+
+cap = cv2.VideoCapture("tos_720p.mp4")
+fps = cap.get(cv2.CAP_PROP_FPS)
+width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+
+out = cv2.VideoWriter(None, cv2.VideoWriter_fourcc(*"mp4v"),
+ fps, (width, height))
+while True:
+ ret, frame = cap.read()
+ if not ret:
+ break
+
+ cv2.putText(frame, "Hello, World!", (100, 100), cv2.FONT_HERSHEY_SIMPLEX,
+ 1, (255, 0, 0), 1)
+ out.write(frame)
+
+cap.release()
+out.release()
+
+cv2.vidplay(out)
+++⚠️ By default
+cv2.vidplay()will return a video which plays in a Jupyter Notebook. If running outside a jupyter notebook you can passmethod="link"to return a link instead.
Getting Started - DSL
+This is a walkthrough of getting started with vidformer-py core DSL.
Installation
+ +Hello, world!
+++⚠️ We assume this is in a Jupyter notebook. If not then
+.play()won't work and you have to use.save()instead.
We start by connecting to a server and registering a source:
+import vidformer as vf
+from fractions import Fraction
+
+server = vf.YrdenServer(domain='localhost', port=8000)
+
+tos = vf.Source(
+ server,
+ "tos_720p", # name (for pretty printing)
+ "https://f.dominik.win/data/dve2/tos_720p.mp4",
+ stream=0, # index of the video stream we want to use
+)
+
+print(tos.ts())
+print(tos.fmt())
+This will print the timestamps of all the frames in the video, and then format information: +This may take a few seconds the first time, but frame times are cached afterwords.
+> [Fraction(0, 1), Fraction(1, 24), Fraction(1, 12), Fraction(1, 8), ...]
+> {'width': 1280, 'height': 720, 'pix_fmt': 'yuv420p'}
+Now lets create a 30 second clip starting at the 5 minute mark. +The source video is at at a constant 24 FPS, so lets create a 24 FPS output as well:
+domain = [Fraction(i, 24) for i in range(24 * 30)]
+Now we need to render each of these frames, so we define a render function.
+def render(t: Fraction, i: int):
+ clip_start_point = Fraction(5 * 60, 1) # start at 5 * 60 seconds
+ return tos[t + clip_start_point]
+We used timestamp-based indexing here, but you can also use integer indexing (tos.iloc[i + 5 * 60 * 24]).
Now we can create a spec and play it in the browser.
+We create a spec from the resulting video's frame timestamps (domain), a function to construct each output frame (render), and the output videos format (matching tos.fmt()).
spec = vf.Spec(domain, render, tos.fmt())
+spec.play(server)
+This plays this result: +
+++Some Jupyter environments are weird (i.e., VS Code), so
+.play()might not work. Using.play(..., method="iframe")may help.
It's worth noting that we are playing frames in order here and outputing video at the same framerate we recieved, but that doesn't need to be the case. +Here are some things other things you can now try:
+-
+
- Reversing the video +
- Double the speed of the video
+
-
+
- Either double the framerate or sample every other frame +
+ - Shuffle the frames into a random order +
- Combining frames from multiple videos +
- Create a variable frame rate video
+
-
+
- Note:
.play()will not work with VFR, but.save()will.
+
+ - Note:
Bounding Boxes
+Now let's overlay some bouding boxes over the entire clip:
+# Load some data
+import urllib.request, json
+with urllib.request.urlopen("https://f.dominik.win/data/dve2/tos_720p-objects.json") as r:
+ detections_per_frame = json.load(r)
+
+bbox = vf.Filter("BoundingBox") # load the built-in BoundingBox filter
+
+domain = tos.ts() # output should have same frame timestamps as our example clip
+
+def render(t, i):
+ return bbox(
+ tos[t],
+ bounds=detections_per_frame[i])
+
+spec = vf.Spec(domain, render, tos.fmt())
+spec.play(server)
+This plays this result (video is just a sample clip): +
+Composition
+We can place frames next to each other with the HStack and VStack filters.
+For example, HStack(left_frame, middle_frame, right_frame, width=1280, height=720, format="yuv420p") will place three frames side-by-side.
As a larger example, we can view a window function over frames as a 5x5 grid:
+hstack = vf.Filter("HStack")
+vstack = vf.Filter("VStack")
+
+w, h = 1920, 1080
+
+def create_grid(tos, i, N, width, height, fmt="yuv420p"):
+ grid = []
+ for row in range(N):
+ columns = []
+ for col in range(N):
+ index = row * N + col
+ columns.append(tos.iloc[i + index])
+ grid.append(hstack(*columns, width=width, height=height//N, format=fmt))
+ final_grid = vstack(*grid, width=width, height=height, format=fmt)
+ return final_grid
+
+domain = [Fraction(i, 24) for i in range(0, 5000)]
+
+def render(t, i):
+ return create_grid(tos, i, 5, w, h)
+
+fmt = {'width': w, 'height': h, 'pix_fmt': 'yuv420p'}
+
+spec = vf.Spec(domain, render, fmt)
+spec.play(server)
+This plays this result (video is just a sample clip): +
+Viewing Telemetry (and User-Defined Filters)
+This notebook shows how to build custom filters to overlay data.
+This plays this result (video is just a sample clip): +
+Concepts & Data Model
+vidformer builds on the data model introduced in the V2V paper.
+-
+
-
+
Frames are a single image. +Frames are represented as their resolution and pixel format (the type and layout of pixels in memory, such as
+rgb24,gray8, oryuv420p).
+ -
+
Videos are sequences of frames represented as an array. +We index these arrays by rational numbers corresponding to their timestamp.
+
+ -
+
Filters are functions which construct a frame. +Filters can take inputs, such as frames or data. +For example,
+DrawTextmay draw some text on a frame.
+ -
+
Specs declarativly represent a video synthesis task. +They represent the construction of a result videos, which is itself modeled as an array.
+-
+
- Specs primairly contan
domainandrenderfunctions. +-
+
- A spec's domain function returns the timestamps of the output frames. +
- A spec's render function returns a composition of filters used to construct a frame at a spesific timestamp. +
+
+ - Specs primairly contan
-
+
Data Arrays allow using data in specs symbolically, as opposed to inserting constants directly into the spec. +These allow for deduplication and loading large data blobs efficiently.
+-
+
- Data Arrays can be backed by external data sources, such as SQL databases. +
+
The vidformer Tools
+vidformer is a highly modular suite of tools that work together:
+-
+
-
+
vidformer-py: A Python 🐍 client for declarative video synthesis
+-
+
- Provides an easy-to-use library for symbolically representing transformed videos +
- Acts as a client for a VoD server (i.e., for yrden) +
- Using vidformer-py is the best place to get started +
+ -
+
libvidformer: The core data-oriented declarative video editing library
+-
+
- An embedded video processing execution engine with low-level interfaces +
- Systems code, written in Rust 🦀 +
- You should use if: You are building a VDBMS or other multimodal data-system infrastructure. +
- You should not use if: You just want to use vidformer in your workflows or projects. +
+ -
+
yrden: A vidformer Video-on-Demand server
+-
+
- Provides vidformer services over a REST-style API +
- Allows for client libraries to be written in any language +
- Serves video results via HLS streams +
- Designed for local single-tenant use +
- You should use if: You want to create faster video results in your workflows or projects. +
- Note that yrden servers may be spun up transparently by client libraries, so you might use yrden without realizing it. +
+ -
+
igni: A planned scale-out Video-on-Demand server
+-
+
- Will allow for scalable and secure public-facing VOD endpoints +
+
Client libraries in other languages: +Writing a vidformer client library for other languages is simple. +It's a few hundred lines of code, and you just have to construct some JSON. +Contributions or suggestions for other languages are welcome.
+Other VoD servers: +We provide yrden as a simple reference VoD server implementation. +If you want to scale-out deployments, multi-tenant deployments, or deep integration with a specific system, writing another VoD server is needed. (In progress work)
+vidformer-py
+
+
vidformer-py is a Python 🐍 interface for vidformer. +Our getting started guide explains how to use it.
+Quick links:
+ +Publish:
+ export FLIT_USERNAME='__token__' FLIT_PASSWORD='<token>'
+flit publish
+vidformer - Video Data Transformation Library
+
(lib)vidformer is a core video synthesis/transformation library. +It handles the movement, control flow, and processing of video and conventional (non-video) data.
+Quick links:
+ +About
+-
+
- It's written in Rust 🦀
+
-
+
- So it does some fancy parallel processing and does so safely +
+ - Uses the FFmpeg libav libraries for multimedia stuff
+
-
+
- So it should work with nearly every video file ever made +
+ - Uses Apache OpenDAL for I/O
+
-
+
- So it can access videos in a bunch of storage services +
+ - Implements filters using OpenCV +
Building
+This crate requires linking with FFmpeg, as detailed in the rusty_ffmpeg crate.
+We currently target FFmpeg 7.0.
Filters
+-
+
- For the vidformer builtin filters +
- For the OpenCV/cv2 filters +
- For using User Defined Filters (UDFs) +
Built-in Filters
+While most applications will use user-defined filters, vidformer ships with a handful of built-in filters to get you started:
+DrawText
+DrawText does exactly what it sounds like: draw text on a frame.
For example:
+DrawText(frame, text="Hello, world!", x=100, y=100, size=48, color="white")
+BoundingBox
+BoundingBox draws bounding boxes on a frame.
For example:
+BoundingBox(frame, bounds=obj)
+Where obj is JSON with this schema:
[
+ {
+ "class": "person",
+ "confidence": 0.916827917098999,
+ "x1": 683.0721842447916,
+ "y1": 100.92174338626751,
+ "x2": 1006.863525390625,
+ "y2": 720
+ },
+ {
+ "class": "dog",
+ "confidence": 0.902531921863556,
+ "x1": 360.8750813802083,
+ "y1": 47.983140622720974,
+ "x2": 606.76171875,
+ "y2": 717.9591837897462
+ }
+]
+Scale
+The Scale filter transforms one frame type to another.
+It changes both resolution and pixel format.
+This is the most important filter and is essential for building with vidformer.
Arguments:
+Scale(
+ frame: Frame,
+ width: int = None,
+ height: int = None,
+ pix_fmt: str = None)
+By default missing width, height and format values are set to match frame.
+pix_fmt must match ffmpeg's name for a pixel format.
For example:
+frame = Scale(frame, width=1280, height=720, pix_fmt="rgb24")
+IPC
+IPC allows for calling User-Defined Filters (UDFs) running on the same system.
+It is an infrastructure-level filter and is used to implement other filters.
+It is configured with a socket and func, the filter's name, both strings.
The IPC filter can not be directly invoked, rather IPC filters are constructed by a server upon request.
+This can be difficult, but vidformer-py handles this for you.
+As of right now IPC only supports rgb24 frames.
HStack & VStack
+HStack & VStack allow for composing multiple frames together, stacking them either horizontally or vertically. +It tries to automatically find a reasonable layout.
+Arguments:
+HStack(
+ *frames: list[Frame],
+ width: int,
+ height: int,
+ format: str)
+At least one frame is required, along with a width, height and format.
For example:
+compilation = HStack(left_frame, right_frame, width=1280, height=720, format="rgb24")
+OpenCV/cv2 Functions
+ +++⚠️ The
+cv2module is a work in progress. If you find a bug or need a missing feature implemented feel free to file an issue or contribute yourself!
Legend:
+-
+
- ✅ - Support +
- 🔸 - Support via OpenCV cv2 +
- ❌ - Not yet implemented +
Vidformer-specific Functions
+-
+
cv2.vidplay(video2)- Play a VideoWriter, Spec, or Source
+VideoWriter.spec()- Return the Spec of an output video
+Frame.numpy()- Return the frame as a numpy array
+cv2.setTo- The OpenCVMat.setTofunction (not in cv2)
+
opencv
+| Class | Status |
|---|---|
| VideoCapture | ✅ |
| VideoWriter | ✅ |
| VideoWriter_fourcc | ✅ |
| Function | Status |
|---|---|
| imread | ✅ |
| imwrite | ✅ |
opencv.imgproc
+Drawing Functions:
+| Function | Status |
|---|---|
| arrowedLine | ✅ |
| circle | ✅ |
| clipLine | ❌ |
| drawContours | ❌ |
| drawMarker | ❌ |
| ellipse | ❌ |
| ellipse2Poly | ❌ |
| fillConvexPoly | ❌ |
| fillPoly | ❌ |
| getFontScaleFromHeight | 🔸 |
| getTextSize | 🔸 |
| line | ✅ |
| polylines | ❌ |
| putText | ✅ |
| rectangle | ✅ |
opencv.core
+| Function | Status |
|---|---|
| addWeighted | ✅ |
User-Defined Filters
+To implement a new user-defined filter (UDF) you need to host a filter server over a UNIX Domain Socket.
+The vidformer-py library makes this easy.
Filters take some combination of frames and data (string, int, bool) and return a single frame result.
+The vidformer project uses Python-style arguments, allowing ordered and named arguments (*args and **kwargs style).
To do this we define a new filter class and host it:
+import vidformer as vf
+import cv2
+
+class MyFilter(vf.UDF):
+
+ def filter(self, frame: vf.UDFFrame, name: str):
+ """Return the result frame."""
+
+ text = f"Hello, {name}!"
+
+ image = frame.data().copy()
+ cv2.putText(
+ image,
+ text,
+ (100,100),
+ cv2.FONT_HERSHEY_SIMPLEX,
+ 1,
+ (255, 0, 0),
+ 1,
+ )
+ return vf.UDFFrame(image, frame.frame_type())
+
+ def filter_type(self, frame: vf.UDFFrameType, _name: str):
+ """Returns the type of the output frame."""
+ return frame
+
+mf_udf = MyFilter("MyFilter") # name used for pretty printing
+
+my_filter = mf_udf.into_filter() # host the UDF in a subprocess, returns a vf.Filter
+Now we can use our newly-created filter in specs: my_filter(some_frame, "vidformer").
There is a catch, UDFs currently only support rgb24 pixel formats.
+So invoking my_filter will need to convert around this:
scale = vf.Filter('Scale')
+
+def render(t, i):
+ f = scale(tos[t], pix_fmt="rgb24", width=1280, height=720)
+ f = my_filter(f, "world")
+ f = scale(f, pix_fmt="yuv420p", width=1280, height=720)
+ return f
+Roadmap
+An unordered list of potential future features:
+-
+
-
+
Igni - A scale-out multi-tenant vidformer server in the cloud
+
+ -
+
Supervision Integration
+
+ -
+
Full GPU Acceleration
+
+ -
+
WebAssembly Builds
+
+ -
+
WebAssembly user defined filters & specs
+
+
FAQ
+What video formats does vidformer support?
+In short, essentially everything. +vidformer uses the FFmpeg/libav* libraries internally, so any media FFmpeg works with should work in vidformer as well. +We support many container formats (e.g., mp4, mov) and codecs (e.g., H.264, VP8).
+A full list of supported codecs enabled in a vidformer build can be found by running:
+vidformer-cli codecs
+Can I access remote videos on the internet?
+Yes, vidformer uses Apache OpenDAL for I/O, so most common data/storage access protocols are supported. +However, not all storage services are enabled in distributed binaries. +We guarantee that HTTP, S3, and the local filesystem always work.
+How does vidformer compare to FFmpeg?
+vidformer is far more expressive than the FFmpeg filter interface. +Mainly, vidformer is designed for work around data, so edits are created programatically and edits can reference data. +Also, vidformer enables serving resut videos on demand.
+vidformer uses the FFmpeg/libav* libraries internally, so any media FFmpeg works with should also work in vidformer.
+How does vidformer compare to OpenCV/cv2?
+vidformer orchestrates data movment in video synthesis tasks, but does not implement image processing directly. +Most use cases will still use OpenCV for this.
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/search-index.js b/search-index.js
new file mode 100644
index 0000000..bf9bbe2
--- /dev/null
+++ b/search-index.js
@@ -0,0 +1,4 @@
+var searchIndex = new Map(JSON.parse('[["vidformer",{"t":"PFFPFFGPPPPPPPFGPPFPPCNNNNNNNNNNNNNNNNNNNNNNNNNNNNOHHOOOONNOOCONNNNNNOOOONNNNNNNNOOHNNNNNNNNOOOONOOOOHONNNCCCCNONNNNNNNNNNNNNNNNNNNNNONNNNNNNNHNNNNNNNNKFNNNMNNNMNMNNNNNNNPPKPFPFPPPPGNNNNNNCNNNNNNNNNCNNNMMNNNOONNNNOONNNNNNNNNNNNNNNNNNNNNNOOFFFFFFFFFFFFFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFFFFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFNNNNNNNNNNNNNNNNNPPPPGGPFPPGFPGPPPPPONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFNNNNNNNOHNNOONNNNNNOOONONNOONNNNNONNNNNFKKNNNMNNONNMNNNNNN","n":["AVError","CodecDescriptor","Config","ConfigError","Context","EncoderConfig","Error","FilterInternalError","IOError","IndexOutOfBounds","InvalidFilterArgType","InvalidFilterArgValue","InvalidOutputFrameType","MissingFilterArg","Range","RangeTsFormat","SegmentLocal","SourceNotFound","Stats","StreamLocal","Unknown","array","borrow","","","","","","","","borrow_mut","","","","","","","","clone","","","","clone_into","","","","clone_to_uninit","","","","codec_name","codecs","create_spec_hls","decode_pool_size","decoder_view","decoders","decoders_created","deserialize","","encoder","end","filter","filterers","fmt","","","","","","format","format_id_pretty_name","frames_decoded","frames_written","from","","","","","","","","has_decoder","has_encoder","init","into","","","","","","","","long_name","max_decoder_count","max_encode_buffer_size","name","new","opts","output_height","output_pix_fmt","output_width","run","runtime","serialize","","","service","sir","source","spec","spec_ctx","start","to_owned","","","","to_string","try_from","","","","","","","","try_into","","","","","","","","ts_format","type_id","","","","","","","","validate","vzip","","","","","","","","Array","JsonArary","borrow","borrow_mut","deserialize","domain","","fmt","from","index","","index_t","","into","serialize","try_from","try_into","type_id","vzip","Bool","Bytes","Filter","Float","Frame","","FrameType","","Int","List","String","Val","borrow","","","borrow_mut","","","builtin","clone","","","clone_into","","","clone_to_uninit","","","cv2","deserialize","","eq","filter","filter_type","fmt","","","format","","from","","","from_expr","height","","into","","","new","serialize","","","to_owned","","","try_from","","","try_into","","","type_id","","","vzip","","","width","","Annotate","BoundingBox","BoundingBoxBound","Box","DrawBox","DrawText","HStack","IPC","InlineMat","Pad","PlaceholderFrame","Scale","SliceMat","SliceWriteMat","VStack","borrow","","","","","","","","","","","","","","","borrow_mut","","","","","","","","","","","","","","","deserialize","filter","","","","","","","","","","","","","","filter_type","","","","","","","","","","","","","","filters","fmt","from","","","","","","","","","","","","","","","into","","","","","","","","","","","","","","","new","try_from","","","","","","","","","","","","","","","try_into","","","","","","","","","","","","","","","type_id","","","","","","","","","","","","","","","via_map","vzip","","","","","","","","","","","","","","","AddWeighted","ArrowedLine","Circle","Line","PutText","Rectangle","SetTo","borrow","","","","","","","borrow_mut","","","","","","","filter","","","","","","","filter_type","","","","","","","filters","from","","","","","","","into","","","","","","","try_from","","","","","","","try_into","","","","","","","type_id","","","","","","","vzip","","","","","","","Service","borrow","borrow_mut","clone","clone_into","clone_to_uninit","default","deserialize","fmt","from","into","new","serialize","to_owned","try_from","try_into","type_id","vzip","ArrayRef","Bool","Bytes","Data","DataExpr","Expr","Filter","FilterExpr","Float","Frame","FrameExpr","FrameSource","ILoc","IndexConst","Int","List","Source","String","T","args","borrow","","","","","","borrow_mut","","","","","","clone","","","","","","clone_into","","","","","","clone_to_uninit","","","","","","cmp","","deserialize","","","","","","eq","","fmt","","","","","","","","","","from","","","","","","index","into","","","","","","kwargs","name","new","partial_cmp","","serialize","","","","","","to_owned","","","","","","to_string","","","","try_from","","","","","","try_into","","","","","","type_id","","","","","","video","vzip","","","","","","SourceFileMeta","SourceVideoStreamMeta","borrow","","borrow_mut","","clone","clone_into","clone_to_uninit","codec","create_profile_file","deserialize","","file_path","file_size","fmt","","from","","into","","keys","name","pix_fmt","profile","resolution","serialize","","service","stream_idx","to_owned","try_from","","try_into","","ts","type_id","","validate","vzip","","JsonSpec","Spec","SpecContext","borrow","borrow_mut","deserialize","domain","","fmt","frames","from","into","render","","serialize","try_from","try_into","type_id","vzip"],"q":[[0,"vidformer"],[151,"vidformer::array"],[170,"vidformer::filter"],[239,"vidformer::filter::builtin"],[407,"vidformer::filter::cv2"],[485,"vidformer::service"],[503,"vidformer::sir"],[632,"vidformer::source"],[673,"vidformer::spec"],[692,"vidformer::dve"],[693,"vidformer::util"],[694,"alloc::vec"],[695,"alloc::string"],[696,"num_rational"],[697,"core::result"],[698,"serde::de"],[699,"core::fmt"],[700,"alloc::boxed"],[701,"alloc::collections::btree::map"],[702,"alloc::sync"],[703,"core::option"],[704,"serde::ser"],[705,"core::any"],[706,"rusty_ffmpeg::ffi"],[707,"vidformer::filter::builtin::ipc"],[708,"std::collections::hash::map"],[709,"core::cmp"]],"i":"Bd``0```0000000``j1`01`Ah2fhBj4lA`574326104361436143613``44424341`477432040225743261000`57432610022053444`2432````51436175743261057432610157432610`57432610``D`00Bn1110101111111Dh0`0`0`0000`Df1Dj120`120120120`100Cd023121231321231123123123123123123121```````````````EdEfEhEjElEnF`FbFdFfFhFjFlFnEb>=<;:98765432100>=<;:987654321>=<;:987654321`0>=<;:9876543210>=<;:9876543210>>=<;:9876543210>=<;:9876543210>=<;:9876543210>>=<;:9876543210```````G`GbGdGfGhGjGl654321065432106543210`654321065432106543210654321065432106543210`Gn0000000000000000Dd00Hh``Hj`21``Hb`33130Hf1Hd14532014532014532014532014532020145320220144553320145302014531102020145320145324532014532014532014530201453``HnBl100000`100010101000000100001010010010```I`00Ad111110111111","f":"``````````````````````{b{{b{c}}}{}}0000000{{{b{d}}}{{b{dc}}}{}}0000000{{{b{f}}}f}{{{b{h}}}h}{{{b{j}}}j}{{{b{l}}}l}{{b{b{dc}}}n{}}000{bn}000`{{}{{Ab{A`}}}}{{{b{Ad}}{b{Af}}{b{Ah}}{b{f}}}{{An{AjAjAj{Ab{{An{AlAl}}}}}}}}````{c{{B`{f}}}Bb}{c{{B`{h}}}Bb}````{{{b{Bd}}{b{dBf}}}Bh}0{{{b{f}}{b{dBf}}}Bh}{{{b{h}}{b{dBf}}}Bh}{{{b{Bj}}{b{dBf}}}Bh}{{{b{A`}}{b{dBf}}}Bh}````{cc{}}0000000``{{}n}{{}c{}}0000000````{{{Ab{Bl}}{Cb{Aj{C`{Bn}}}}{Cb{Aj{C`{Cd}}}}}Ah}````{{{b{{Cf{{C`{Ad}}}}}}{b{Af}}{b{{Cf{Ah}}}}{b{{Cf{f}}}}{b{{Ch{l}}}}}{{B`{BjBd}}}}`{{{b{f}}c}B`Cj}{{{b{h}}c}B`Cj}{{{b{Bj}}c}B`Cj}````{{{b{Ah}}}{{`{Cl}}}}`{bc{}}000{bAj}{c{{B`{e}}}{}{}}0000000{{}{{B`{c}}}{}}0000000`{bCn}0000000{{{b{{Cf{{C`{Ad}}}}}}{b{{Cf{Ah}}}}{b{{Cf{f}}}}}{{B`{nBd}}}}<<<<<<<<``{b{{b{c}}}{}}{{{b{d}}}{{b{dc}}}{}}{c{{B`{D`}}}Bb}{{{b{Bn}}}{{Ab{Al}}}}{{{b{D`}}}{{Ab{Al}}}}{{{b{D`}}{b{dBf}}}Bh}{cc{}}{{{b{Bn}}Db}Dd}{{{b{D`}}Db}Dd}{{{b{Bn}}Al}Dd}{{{b{D`}}Al}Dd}{{}c{}}{{{b{D`}}c}B`Cj}{c{{B`{e}}}{}{}}{{}{{B`{c}}}{}}{bCn}4````````````???>>>`{{{b{Df}}}Df}{{{b{Dh}}}Dh}{{{b{Dj}}}Dj}{{b{b{dc}}}n{}}00{bn}00`{c{{B`{Df}}}Bb}{c{{B`{Dj}}}Bb}{{{b{Dj}}{b{Dj}}}Dl}{{{b{Cd}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DfBd}}}}{{{b{Cd}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DjBd}}}}{{{b{Df}}{b{dBf}}}Bh}{{{b{Dh}}{b{dBf}}}Bh}{{{b{Dj}}{b{dBf}}}Bh}``{cc{}}00{{{b{Dd}}{b{Ah}}}Dh}``{{}c{}}00{{DbDbE`}Dj}{{{b{Df}}c}B`Cj}{{{b{Dh}}c}B`Cj}{{{b{Dj}}c}B`Cj}{bc{}}00{c{{B`{e}}}{}{}}00{{}{{B`{c}}}{}}00{bCn}00888`````````````````{b{{b{c}}}{}}00000000000000{{{b{d}}}{{b{dc}}}{}}00000000000000{c{{B`{Eb}}}Bb}{{{b{Ed}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DfBd}}}}{{{b{Ef}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DfBd}}}}{{{b{Eh}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DfBd}}}}{{{b{Ej}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DfBd}}}}{{{b{El}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DfBd}}}}{{{b{En}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DfBd}}}}{{{b{F`}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DfBd}}}}{{{b{Fb}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DfBd}}}}{{{b{Fd}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DfBd}}}}{{{b{Ff}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DfBd}}}}{{{b{Fh}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DfBd}}}}{{{b{Fj}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DfBd}}}}{{{b{Fl}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DfBd}}}}{{{b{Fn}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DfBd}}}}{{{b{Ed}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DjBd}}}}{{{b{Ef}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DjBd}}}}{{{b{Eh}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DjBd}}}}{{{b{Ej}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DjBd}}}}{{{b{El}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DjBd}}}}{{{b{En}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DjBd}}}}{{{b{F`}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DjBd}}}}{{{b{Fb}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DjBd}}}}{{{b{Fd}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DjBd}}}}{{{b{Ff}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DjBd}}}}{{{b{Fh}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DjBd}}}}{{{b{Fj}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DjBd}}}}{{{b{Fl}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DjBd}}}}{{{b{Fn}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DjBd}}}}{{}{{Cb{Aj{C`{Cd}}}}}}{{{b{Eb}}{b{dBf}}}Bh}{cc{}}00000000000000{{}c{}}00000000000000{{AjAj}{{B`{EdBd}}}}{c{{B`{e}}}{}{}}00000000000000{{}{{B`{c}}}{}}00000000000000{bCn}00000000000000{{{b{{Cb{AjAj}}}}}{{B`{EdBd}}}}555555555555555```````{b{{b{c}}}{}}000000{{{b{d}}}{{b{dc}}}{}}000000{{{b{G`}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DfBd}}}}{{{b{Gb}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DfBd}}}}{{{b{Gd}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DfBd}}}}{{{b{Gf}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DfBd}}}}{{{b{Gh}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DfBd}}}}{{{b{Gj}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DfBd}}}}{{{b{Gl}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DfBd}}}}{{{b{G`}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DjBd}}}}{{{b{Gb}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DjBd}}}}{{{b{Gd}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DjBd}}}}{{{b{Gf}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DjBd}}}}{{{b{Gh}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DjBd}}}}{{{b{Gj}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DjBd}}}}{{{b{Gl}}{b{{Dn{Dh}}}}{b{{Cb{AjDh}}}}}{{B`{DjBd}}}}{{}{{Cb{Aj{C`{Cd}}}}}}{cc{}}000000{{}c{}}000000{c{{B`{e}}}{}{}}000000{{}{{B`{c}}}{}}000000{bCn}0000003333333`{b{{b{c}}}{}}{{{b{d}}}{{b{dc}}}{}}{{{b{Gn}}}Gn}{{b{b{dc}}}n{}}{bn}{{}Gn}{c{{B`{Gn}}}Bb}{{{b{Gn}}{b{dBf}}}Bh}<;{{Aj{H`{AjAj}}}Gn}{{{b{Gn}}c}B`Cj}{bc{}}=<;>````````````````````::::::999999{{{b{Hb}}}Hb}{{{b{Hd}}}Hd}{{{b{Hf}}}Hf}{{{b{Hh}}}Hh}{{{b{Dd}}}Dd}{{{b{Hj}}}Hj}======<<<<<<{{{b{Hb}}{b{Hb}}}Hl}{{{b{Hd}}{b{Hd}}}Hl}{c{{B`{Hb}}}Bb}{c{{B`{Hd}}}Bb}{c{{B`{Hf}}}Bb}{c{{B`{Hh}}}Bb}{c{{B`{Dd}}}Bb}{c{{B`{Hj}}}Bb}{{{b{Hb}}{b{Hb}}}Dl}{{{b{Hd}}{b{Hd}}}Dl}{{{b{Hb}}{b{dBf}}}Bh}0{{{b{Hd}}{b{dBf}}}Bh}{{{b{Hf}}{b{dBf}}}Bh}{{{b{Hh}}{b{dBf}}}Bh}0{{{b{Dd}}{b{dBf}}}Bh}0{{{b{Hj}}{b{dBf}}}Bh}0{cc{}}00000{{{b{Hd}}}{{b{Hb}}}}{{}c{}}00000``{{AjHb}Hd}{{{b{Hb}}{b{Hb}}}{{Ch{Hl}}}}{{{b{Hd}}{b{Hd}}}{{Ch{Hl}}}}{{{b{Hb}}c}B`Cj}{{{b{Hd}}c}B`Cj}{{{b{Hf}}c}B`Cj}{{{b{Hh}}c}B`Cj}{{{b{Dd}}c}B`Cj}{{{b{Hj}}c}B`Cj}{bc{}}00000{bAj}000{c{{B`{e}}}{}{}}00000{{}{{B`{c}}}{}}00000{bCn}00000{{{b{Hd}}}{{b{Af}}}}??????``{b{{b{c}}}{}}0{{{b{d}}}{{b{dc}}}{}}0{{{b{Bl}}}Bl}{{b{b{dc}}}n{}}{bn}`{{{b{{Dn{Bl}}}}}Hn}{c{{B`{Hn}}}Bb}{c{{B`{Bl}}}Bb}``{{{b{Hn}}{b{dBf}}}Bh}{{{b{Bl}}{b{dBf}}}Bh}{cc{}}0{{}c{}}0```{{{b{Af}}{b{Af}}Db{b{Gn}}}{{B`{BlBd}}}}`{{{b{Hn}}c}B`Cj}{{{b{Bl}}c}B`Cj}``{bc{}}{c{{B`{e}}}{}{}}0{{}{{B`{c}}}{}}0`{bCn}0{{{b{Af}}{b{Af}}Db{b{Gn}}}n}88```{b{{b{c}}}{}}{{{b{d}}}{{b{dc}}}{}}{c{{B`{I`}}}Bb}{{{b{Ad}}{b{Cl}}}{{Ab{Al}}}}{{{b{I`}}{b{Cl}}}{{Ab{Al}}}}{{{b{I`}}{b{dBf}}}Bh}`?>{{{b{Ad}}{b{Cl}}{b{Al}}}Hj}{{{b{I`}}{b{Cl}}{b{Al}}}Hj}{{{b{I`}}c}B`Cj}<;:{{}c{}}","D":"A@d","p":[[1,"reference"],[0,"mut"],[5,"Config",0,692],[5,"EncoderConfig",0,692],[6,"RangeTsFormat",0,692],[5,"Range",0,692],[1,"unit"],[5,"CodecDescriptor",0,693],[5,"Vec",694],[10,"Spec",673],[1,"str"],[5,"Context",0,692],[5,"String",695],[8,"Rational64",696],[1,"tuple"],[6,"Result",697],[10,"Deserializer",698],[6,"Error",0,692],[5,"Formatter",699],[8,"Result",699],[5,"Stats",0,692],[5,"SourceVideoStreamMeta",632],[10,"Array",151],[5,"Box",700],[5,"BTreeMap",701],[10,"Filter",170],[5,"Arc",702],[6,"Option",703],[10,"Serializer",704],[10,"SpecContext",673],[5,"TypeId",705],[5,"JsonArary",151],[1,"usize"],[6,"DataExpr",503],[5,"Frame",170],[6,"Val",170],[5,"FrameType",170],[1,"bool"],[1,"slice"],[8,"AVPixelFormat",706],[5,"BoundingBoxBound",239],[5,"IPC",239,707],[5,"PlaceholderFrame",239],[5,"Annotate",239],[5,"Box",239],[5,"BoundingBox",239],[5,"DrawBox",239],[5,"Scale",239],[5,"InlineMat",239],[5,"SliceMat",239],[5,"SliceWriteMat",239],[5,"Pad",239],[5,"HStack",239],[5,"VStack",239],[5,"DrawText",239],[5,"Rectangle",407],[5,"PutText",407],[5,"ArrowedLine",407],[5,"Line",407],[5,"Circle",407],[5,"SetTo",407],[5,"AddWeighted",407],[5,"Service",485],[5,"HashMap",708],[6,"IndexConst",503],[5,"FrameSource",503],[5,"FilterExpr",503],[6,"Expr",503],[6,"FrameExpr",503],[6,"Ordering",709],[5,"SourceFileMeta",632],[5,"JsonSpec",673]],"r":[[1,693],[2,692],[4,692],[5,692],[6,692],[14,692],[15,692],[18,692],[51,693],[52,692],[83,693],[101,692],[142,692],[246,707]],"b":[[63,"impl-Display-for-Error"],[64,"impl-Debug-for-Error"],[563,"impl-Debug-for-IndexConst"],[564,"impl-Display-for-IndexConst"],[567,"impl-Display-for-Expr"],[568,"impl-Debug-for-Expr"],[569,"impl-Display-for-DataExpr"],[570,"impl-Debug-for-DataExpr"],[571,"impl-Debug-for-FrameExpr"],[572,"impl-Display-for-FrameExpr"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAADICKQABAAEABAAAAAYACAARAAEAFAABABcAHAA5AAIAPQAAAEAABQBHAAIAUgABAF0ACABnAAMAbQAAAG8AHwCQAAcAmgACAJ4AAQCiAAAApAAAAKYABgCuAAAAsAAFALcABQC+AAgAyAACAMwABQDVAAIA2wAbAPgAAgD8AD0AOwEAAFoBYADKASQA8QFMAEQCAABLAj4AjgITAKUCAgCpAgIArwIFAA=="}]]'));
+if (typeof exports !== 'undefined') exports.searchIndex = searchIndex;
+else if (window.initSearch) window.initSearch(searchIndex);
+//{"start":39,"fragment_lengths":[13926]}
\ No newline at end of file
diff --git a/search.desc/vidformer/vidformer-desc-0-.js b/search.desc/vidformer/vidformer-desc-0-.js
new file mode 100644
index 0000000..09b6cf6
--- /dev/null
+++ b/search.desc/vidformer/vidformer-desc-0-.js
@@ -0,0 +1 @@
+searchState.loadedDescShard("vidformer", 0, "vidformer is a core video synthesis/transformation library.\nConfig for a spesific run of a vidformer spec\nA context for a spec\nA range spesifier\nSelect whether the output timestamps are local to the …\nStats from a run of a vidformer spec\nArrays provide access to data.\nList all available codecs\nCreate HLS artifacts for a spec\nThe number of frames which can be fit in the decode pool\nHow many output frames can be active at once This also …\nHow many decoders can be active at once\nConfiguration to use for output encoder\nFilters create and transform video frames\nHow many filter threads to run\nThe name of the format to use for output. If None, the …\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nInstantiate FFmpeg logging\nCalls
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Roadmap
+An unordered list of potential future features:
+-
+
-
+
Igni - A scale-out multi-tenant vidformer server in the cloud
+
+ -
+
Supervision Integration
+
+ -
+
Full GPU Acceleration
+
+ -
+
WebAssembly Builds
+
+ -
+
WebAssembly user defined filters & specs
+
+
U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nExecute a spec, or a range of a spec.\nServices provide access to media storage.\nSpec Intermediate Representation\nSpecs declarativly define an edited video.\nValidate that a spec can be run.\nA trait for an array\nAn array backed by a JSON file\nReturns the domain of the array.\nReturns the argument unchanged.\nReturns the value at a given positional index.\nReturns the value at a given time index.\nCalls U::from(self).\nA filter that can create a video frame from some inputs\nA decoded video frame\nA value that can be passed to a filter\nvidformer built-in filters\nvidformer cv2 filters\nCreates a video frame from some inputs\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nFilter over IPC Socket\nScale & convert pixel format of a frame\nvidformer built-in filters\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nvidformer cv2 filters\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nReturns the argument unchanged.\nCalls U::from(self).\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nReturns the argument unchanged.\nReturns the argument unchanged.\nCalls U::from(self).\nCalls U::from(self).\nA spec backed by a JSON file\nA trait for a spec\nA trait for providing information to a spec during runtime\nReturns the domain of the spec.\nReturns the argument unchanged.\nCalls U::from(self).\nReturns the “logically” rendered frame at a given time.")
\ No newline at end of file
diff --git a/searcher.js b/searcher.js
new file mode 100644
index 0000000..dc03e0a
--- /dev/null
+++ b/searcher.js
@@ -0,0 +1,483 @@
+"use strict";
+window.search = window.search || {};
+(function search(search) {
+ // Search functionality
+ //
+ // You can use !hasFocus() to prevent keyhandling in your key
+ // event handlers while the user is typing their search.
+
+ if (!Mark || !elasticlunr) {
+ return;
+ }
+
+ //IE 11 Compatibility from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith
+ if (!String.prototype.startsWith) {
+ String.prototype.startsWith = function(search, pos) {
+ return this.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
+ };
+ }
+
+ var search_wrap = document.getElementById('search-wrapper'),
+ searchbar = document.getElementById('searchbar'),
+ searchbar_outer = document.getElementById('searchbar-outer'),
+ searchresults = document.getElementById('searchresults'),
+ searchresults_outer = document.getElementById('searchresults-outer'),
+ searchresults_header = document.getElementById('searchresults-header'),
+ searchicon = document.getElementById('search-toggle'),
+ content = document.getElementById('content'),
+
+ searchindex = null,
+ doc_urls = [],
+ results_options = {
+ teaser_word_count: 30,
+ limit_results: 30,
+ },
+ search_options = {
+ bool: "AND",
+ expand: true,
+ fields: {
+ title: {boost: 1},
+ body: {boost: 1},
+ breadcrumbs: {boost: 0}
+ }
+ },
+ mark_exclude = [],
+ marker = new Mark(content),
+ current_searchterm = "",
+ URL_SEARCH_PARAM = 'search',
+ URL_MARK_PARAM = 'highlight',
+ teaser_count = 0,
+
+ SEARCH_HOTKEY_KEYCODE = 83,
+ ESCAPE_KEYCODE = 27,
+ DOWN_KEYCODE = 40,
+ UP_KEYCODE = 38,
+ SELECT_KEYCODE = 13;
+
+ function hasFocus() {
+ return searchbar === document.activeElement;
+ }
+
+ function removeChildren(elem) {
+ while (elem.firstChild) {
+ elem.removeChild(elem.firstChild);
+ }
+ }
+
+ // Helper to parse a url into its building blocks.
+ function parseURL(url) {
+ var a = document.createElement('a');
+ a.href = url;
+ return {
+ source: url,
+ protocol: a.protocol.replace(':',''),
+ host: a.hostname,
+ port: a.port,
+ params: (function(){
+ var ret = {};
+ var seg = a.search.replace(/^\?/,'').split('&');
+ var len = seg.length, i = 0, s;
+ for (;iRustdoc settings
Backvidformer/array.rs
+1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51
//! Arrays provide access to data.
+//!
+//! Arrays store conventional data (e.g. numbers, strings) and can be referenced by specs.
+//! As with the rest of the vidformer data model, arrays are duel-indexed by a timestamp or a position.
+//! Arrays can be backed by a variety of sources, such as a JSON file or a database.
+
+use num::Rational64;
+
+/// A trait for an array
+pub trait Array: Sync + Send {
+ /// Returns the domain of the array.
+ ///
+ /// The domain is the set of times at which the array is defined.
+ /// Each time corresponds to a single output value at that timestamp.
+ ///
+ /// The output must:
+ /// - Be sorted in ascending order
+ /// - Contain no duplicate values
+ /// - Begin with 0
+ fn domain(&self) -> Vec<Rational64>;
+
+ /// Returns the value at a given positional index.
+ fn index(&self, idx: usize) -> crate::sir::DataExpr;
+
+ /// Returns the value at a given time index.
+ fn index_t(&self, idx: Rational64) -> crate::sir::DataExpr;
+}
+
+/// An array backed by a JSON file
+#[derive(Debug, serde::Deserialize, serde::Serialize)]
+pub struct JsonArary {
+ array: Vec<(Rational64, crate::sir::DataExpr)>,
+}
+
+impl Array for JsonArary {
+ fn domain(&self) -> Vec<Rational64> {
+ self.array.iter().map(|(t, _)| *t).collect()
+ }
+
+ fn index(&self, idx: usize) -> crate::sir::DataExpr {
+ self.array[idx].1.clone()
+ }
+
+ fn index_t(&self, idx: Rational64) -> crate::sir::DataExpr {
+ let idx = self
+ .array
+ .binary_search_by(|(t, _)| t.partial_cmp(&idx).unwrap())
+ .unwrap();
+ self.index(idx)
+ }
+}
+vidformer/av/decoder.rs
+1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83
use log::*;
+use rusty_ffmpeg::ffi;
+use std::ptr;
+
+pub struct Decoder {
+ pub codec_context: *mut ffi::AVCodecContext,
+}
+
+pub enum DecoderResult {
+ Frame,
+ Again,
+ Eof,
+}
+
+impl Decoder {
+ pub fn new(
+ codec: *const ffi::AVCodec,
+ codec_parameters: *const ffi::AVCodecParameters,
+ ) -> Result<Self, crate::Error> {
+ let codec_context = unsafe { ffi::avcodec_alloc_context3(codec) };
+
+ if codec_context.is_null() {
+ return Err(crate::Error::AVError(
+ "Failed to allocate memory for codec context".to_string(),
+ ));
+ }
+
+ let response =
+ unsafe { ffi::avcodec_parameters_to_context(codec_context, codec_parameters) };
+
+ if response < 0 {
+ return Err(crate::Error::AVError(
+ "Failed to copy codec parameters to codec context".to_string(),
+ ));
+ }
+
+ let response = unsafe { ffi::avcodec_open2(codec_context, codec, ptr::null_mut()) };
+ if response < 0 {
+ return Err(crate::Error::AVError(
+ "Decoder failed to open codec".to_string(),
+ ));
+ }
+
+ Ok(Decoder { codec_context })
+ }
+
+ pub fn send_packet(&mut self, packet: *mut ffi::AVPacket) {
+ let response = unsafe { ffi::avcodec_send_packet(self.codec_context, packet) };
+
+ if response < 0 {
+ error!("Error sending packet to decoder");
+ }
+ }
+
+ pub fn flush(&mut self) {
+ let response = unsafe { ffi::avcodec_send_packet(self.codec_context, ptr::null_mut()) };
+ if response < 0 {
+ error!("Error flushing decoder");
+ }
+ }
+
+ pub fn read_frame(&mut self, frame: *mut ffi::AVFrame) -> Result<DecoderResult, crate::Error> {
+ let response = unsafe { ffi::avcodec_receive_frame(self.codec_context, frame) };
+
+ if response == ffi::AVERROR(ffi::EAGAIN) {
+ Ok(DecoderResult::Again)
+ } else if response == ffi::AVERROR_EOF {
+ Ok(DecoderResult::Eof)
+ } else if response < 0 {
+ Err(crate::Error::AVError(
+ "Error while receiving a frame from the decoder.".to_string(),
+ ))
+ } else {
+ Ok(DecoderResult::Frame)
+ }
+ }
+
+ pub fn close(&self) {
+ unsafe {
+ ffi::avcodec_free_context(&mut (self.codec_context as *mut _));
+ }
+ }
+}
+vidformer/av/demuxer.rs
+1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359
use log::*;
+use num::Zero;
+use num_rational::Rational64;
+use rusty_ffmpeg::ffi;
+use std::io::Read;
+use std::io::Seek;
+use std::{ptr, slice};
+
+struct IoCtx {
+ canary: u64, // We're doing some unsafe opaque pointer passing, so let's add a canary to make sure we didn't mess up. Valid value is 0xdeadbeef
+ size: u64,
+ buf_reader: std::io::BufReader<opendal::StdReader>,
+ err: Option<std::io::Error>,
+}
+
+unsafe extern "C" fn vidformer_avio_read_packet(
+ opaque: *mut ::std::os::raw::c_void,
+ buf: *mut u8,
+ buf_size: ::std::os::raw::c_int,
+) -> ::std::os::raw::c_int {
+ let io_ctx = &mut *(opaque as *mut IoCtx);
+ debug_assert_eq!(io_ctx.canary, 0xdeadbeef);
+
+ let buf: &mut [u8] = unsafe { slice::from_raw_parts_mut(buf, buf_size as usize) };
+ let read = io_ctx.buf_reader.read(buf);
+ match read {
+ Ok(read) => {
+ if read == 0 {
+ debug_assert!(io_ctx.buf_reader.stream_position().unwrap() == io_ctx.size);
+ ffi::AVERROR_EOF
+ } else {
+ read as i32
+ }
+ }
+ Err(e) => {
+ error!("Error reading packet: {}", e);
+ if io_ctx.err.is_none() {
+ io_ctx.err = Some(e);
+ }
+ ffi::AVERROR_EXTERNAL
+ }
+ }
+}
+
+unsafe extern "C" fn vidformer_avio_seek(
+ opaque: *mut ::std::os::raw::c_void,
+ offset: i64,
+ whence: ::std::os::raw::c_int,
+) -> i64 {
+ let io_ctx = &mut *(opaque as *mut IoCtx);
+ debug_assert_eq!(io_ctx.canary, 0xdeadbeef);
+
+ let whence = match whence as u32 {
+ ffi::SEEK_CUR => std::io::SeekFrom::Current(offset),
+ ffi::SEEK_END => std::io::SeekFrom::End(offset),
+ ffi::SEEK_SET => std::io::SeekFrom::Start(offset as u64),
+ ffi::AVSEEK_SIZE => {
+ // whence == AVSEEK_SIZE is the libav way of asking for the size of the file
+ return io_ctx.size as i64;
+ }
+ ffi::AVSEEK_FORCE => panic!("AVSEEK_FORCE is not supported"), // libav way of saying "seek even if you have to reopen the file"
+ _ => panic!("invalid seek whence ({})", whence,),
+ };
+
+ let seeked = io_ctx.buf_reader.seek(whence);
+ match seeked {
+ Ok(seeked) => seeked as i64,
+ Err(e) => {
+ error!("Error seeking: {}", e);
+ if io_ctx.err.is_none() {
+ io_ctx.err = Some(e);
+ }
+ ffi::AVERROR_EXTERNAL as i64
+ }
+ }
+}
+
+pub struct Demuxer {
+ pub format_context: *mut ffi::AVFormatContext,
+ avio_context: *mut ffi::AVIOContext,
+ #[allow(unused)] // We need to keep this alive since libav keeps it as an opaque pointer
+ io_ctx: std::pin::Pin<std::boxed::Box<IoCtx>>,
+ pub time_base: Rational64,
+ pub codec: *const ffi::AVCodec,
+ pub codec_parameters: *const ffi::AVCodecParameters,
+ pub video_stream_index: Option<usize>,
+ pub stream: *mut ffi::AVStream,
+}
+
+impl Demuxer {
+ pub fn new(
+ file_path: &str,
+ stream_idx: usize,
+ service: &crate::service::Service,
+ file_size: u64,
+ io_runtime_handle: &tokio::runtime::Handle,
+ ) -> Result<Self, crate::Error> {
+ let mut format_context = unsafe { ffi::avformat_alloc_context() };
+ if format_context.is_null() {
+ return Err(crate::Error::AVError(
+ "could not allocate memory for Format Context".to_string(),
+ ));
+ }
+
+ debug!("Opening {} for read", file_path);
+
+ let op = service.blocking_operator(io_runtime_handle)?;
+
+ let reader: opendal::BlockingReader = op.reader(file_path).map_err(|e| {
+ if e.kind() == opendal::ErrorKind::NotFound {
+ crate::Error::IOError(format!("File `{}` not found", file_path))
+ } else {
+ crate::Error::IOError(format!("OpenDAL error: {}", e))
+ }
+ })?;
+
+ let reader: opendal::StdReader = match reader.into_std_read(0..file_size) {
+ Ok(reader) => reader,
+ Err(err) => {
+ return Err(crate::Error::IOError(format!(
+ "OpenDAL failed to convert BlockingReader to StdReader: {}",
+ err
+ )));
+ }
+ };
+ let buffered_reader = std::io::BufReader::new(reader);
+
+ let io_ctx = IoCtx {
+ canary: 0xdeadbeef,
+ size: file_size,
+ buf_reader: buffered_reader,
+ err: None,
+ };
+ let io_ctx = Box::pin(io_ctx);
+ let io_ctx_ptr =
+ io_ctx.as_ref().get_ref() as *const IoCtx as *mut IoCtx as *mut ::std::os::raw::c_void;
+
+ let avio_buffer_size = 128 * 1024; // 128KiB buffer, probably good enough for now
+ let avio_buffer: *mut std::ffi::c_void =
+ unsafe { ffi::av_malloc(avio_buffer_size as usize) };
+
+ let avio_context = unsafe {
+ ffi::avio_alloc_context(
+ avio_buffer as *mut u8,
+ avio_buffer_size,
+ 0,
+ io_ctx_ptr,
+ Some(vidformer_avio_read_packet),
+ None,
+ Some(vidformer_avio_seek),
+ )
+ };
+
+ if avio_context.is_null() {
+ return Err(crate::Error::AVError(
+ "could not allocate memory for AVIO Context".to_string(),
+ ));
+ }
+
+ unsafe {
+ (*format_context).pb = avio_context;
+ }
+
+ let ret = unsafe {
+ ffi::avformat_open_input(
+ &mut format_context,
+ ptr::null_mut(),
+ ptr::null_mut(),
+ ptr::null_mut(),
+ )
+ };
+ if ret != 0 {
+ if ret == ffi::AVERROR_EXTERNAL {
+ let err = io_ctx.err.as_ref().unwrap();
+ if err.kind() == std::io::ErrorKind::NotFound {
+ return Err(crate::Error::IOError(format!(
+ "File `{}` not found",
+ file_path
+ )));
+ } else {
+ return Err(crate::Error::IOError(format!("OpenDAL error: {}", err)));
+ }
+ }
+
+ let err_str = crate::util::av_strerror(ret);
+ return Err(crate::Error::AVError(format!(
+ "failed to open media format: {}",
+ err_str
+ )));
+ }
+
+ // TODO: This may decode a few frames, which could be slow. Maybe don't do that when actually running a spec?
+ if unsafe { ffi::avformat_find_stream_info(format_context, ptr::null_mut()) } < 0 {
+ return Err(crate::Error::AVError(
+ "could not get the stream info".to_string(),
+ ));
+ }
+
+ let mut codec_ptr: *const ffi::AVCodec = ptr::null_mut();
+ let mut codec_parameters_ptr: *const ffi::AVCodecParameters = ptr::null_mut();
+ let mut video_stream_index = None;
+
+ let streams = unsafe {
+ slice::from_raw_parts_mut(
+ (*format_context).streams,
+ (*format_context).nb_streams as usize,
+ )
+ };
+
+ for (i, stream) in streams
+ .iter_mut()
+ .map(|stream| unsafe { stream.as_mut() }.expect("null stream pointer"))
+ .enumerate()
+ {
+ if i != stream_idx {
+ stream.discard = ffi::AVDiscard_AVDISCARD_ALL;
+ continue;
+ }
+
+ let local_codec_params = unsafe { stream.codecpar.as_ref() }.expect("codecpar is null");
+ let local_codec =
+ unsafe { ffi::avcodec_find_decoder(local_codec_params.codec_id).as_ref() }
+ .expect("ERROR unsupported codec!");
+
+ if local_codec_params.codec_type == ffi::AVMediaType_AVMEDIA_TYPE_VIDEO {
+ if video_stream_index.is_none() {
+ video_stream_index = Some(i);
+ codec_ptr = local_codec;
+ codec_parameters_ptr = local_codec_params;
+ }
+ } else {
+ println!("Stream {i} is not a video");
+ continue;
+ }
+ }
+
+ let time_base = crate::util::avrat_to_rat(&unsafe { (*streams[stream_idx]).time_base });
+ debug_assert!(!time_base.is_zero());
+
+ Ok(Demuxer {
+ format_context,
+ avio_context,
+ io_ctx,
+ time_base,
+ codec: codec_ptr,
+ codec_parameters: codec_parameters_ptr,
+ video_stream_index,
+ stream: unsafe { streams[stream_idx].as_mut() }.unwrap(),
+ })
+ }
+
+ pub fn seek(&mut self, ts: &Rational64) -> Result<(), crate::Error> {
+ let seek_ts = ts / self.time_base;
+ assert_eq!(*seek_ts.denom(), 1);
+ let seek_ts = *seek_ts.numer();
+
+ debug!("Seeking to {}", ts);
+
+ if unsafe { ffi::avformat_seek_file(self.format_context, 0, seek_ts, seek_ts, seek_ts, 0) }
+ < 0
+ {
+ return Err(crate::Error::AVError("failed to seek file".to_string()));
+ }
+
+ Ok(())
+ }
+
+ pub fn read_packet(&mut self, packet: *mut ffi::AVPacket) -> Option<()> {
+ loop {
+ if unsafe { ffi::av_read_frame(self.format_context, packet) } >= 0 {
+ // debug!(
+ // "DEMUX - Packet stream index {} pts = {} dts = {} key_frame = {} size = {}",
+ // unsafe { (*packet).stream_index },
+ // unsafe { (*packet).pts },
+ // unsafe { (*packet).dts },
+ // unsafe { (*packet).flags } as u32 & ffi::AV_PKT_FLAG_KEY != 0,
+ // unsafe { (*packet).size }
+ // );
+
+ // Is this packet from the correct stream?
+ if unsafe { (*packet).stream_index } as usize == self.video_stream_index.unwrap() {
+ // If so, we have updated the pointer, so return
+ return Some(());
+ } else {
+ // If not, unref the packet and keep trying
+ unsafe {
+ ffi::av_packet_unref(packet);
+ }
+ continue;
+ }
+ } else {
+ return None;
+ }
+ }
+ }
+
+ pub fn close(&self) {
+ unsafe {
+ ffi::avformat_close_input(&mut (self.format_context as *mut _));
+
+ // Free the avio buffer. libav and us share memory control over it, so its probably not even the one we allocated.
+ // Sorry that pointer casting is so ugly, it makes sure to pass the pointer to the buffer pointer, not the buffer pointer itself.
+ // Probably a better way to do this which doesn't involve using the mut keyword six times in one expression. ¯\_(ツ)_/¯
+ ffi::av_freep(
+ &mut (*self.avio_context).buffer as *mut *mut u8 as *mut *mut std::os::raw::c_void
+ as *mut std::os::raw::c_void,
+ );
+
+ ffi::av_free(self.avio_context as *mut std::os::raw::c_void);
+ }
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+ use rusty_ffmpeg::ffi;
+
+ const TEST_VID: &str = "../tos_720p.mp4";
+ const TEST_STREAM: usize = 0;
+
+ #[test]
+ fn tos_test() {
+ let service = crate::service::Service::default();
+ let profile = crate::source::SourceVideoStreamMeta::profile(
+ "tos_720p",
+ "../tos_720p.mp4",
+ 0,
+ &service,
+ )
+ .unwrap();
+
+ let io_runtime = tokio::runtime::Builder::new_multi_thread()
+ .worker_threads(1)
+ .enable_all()
+ .build()
+ .unwrap();
+
+ let mut demuxer = Demuxer::new(
+ TEST_VID,
+ TEST_STREAM,
+ &service,
+ profile.file_size,
+ io_runtime.handle(),
+ )
+ .unwrap();
+
+ let packet = unsafe { ffi::av_packet_alloc().as_mut() }
+ .expect("failed to allocated memory for AVPacket");
+
+ let mut demuxed_packets = 0;
+ while demuxer.read_packet(packet).is_some() {
+ demuxed_packets += 1;
+ }
+ demuxer.close();
+
+ assert_eq!(demuxed_packets, 17616);
+ }
+}
+vidformer/av/encoder.rs
+1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187
use crate::dve::AVFrame;
+use crate::util;
+use log::*;
+use num_rational::Rational64;
+use rusty_ffmpeg::ffi;
+use std::ffi::CString;
+use std::ptr;
+
+use crate::dve::Config;
+
+pub struct Encoder {
+ pub(crate) codec_ctx: *mut ffi::AVCodecContext,
+ pub(crate) packet: *mut ffi::AVPacket,
+ pub(crate) time_base: Rational64,
+ pub(crate) flushed: bool,
+}
+
+impl Encoder {
+ pub(crate) fn new(config: &Config, time_base: &Rational64) -> Result<Self, crate::Error> {
+ let codec = match &config.encoder {
+ Some(enc_cfg) => enc_cfg.avcodec()?,
+ None => {
+ let codec = unsafe { ffi::avcodec_find_encoder(ffi::AVCodecID_AV_CODEC_ID_H264) };
+ match unsafe { codec.as_ref() } {
+ Some(codec) => codec,
+ None => panic!("Failed to find default h264 encoder"),
+ }
+ }
+ };
+
+ debug!("Encoder has codec {}", util::fmt_av_codec(codec));
+
+ let codec_ctx: *mut ffi::AVCodecContext = unsafe { ffi::avcodec_alloc_context3(codec) };
+ if codec_ctx.is_null() {
+ return Err(crate::Error::AVError(
+ "Failed to allocate codec context".to_string(),
+ ));
+ }
+
+ let default_opts = &[("preset".to_string(), "ultrafast".to_string())];
+
+ let opts: &[(String, String)] = match &config.encoder {
+ Some(enc_cfg) => &enc_cfg.opts,
+ None => default_opts,
+ };
+
+ for (opt_k, opt_v) in opts {
+ let opt_k_cstr = CString::new(opt_k.clone()).unwrap();
+ let opt_v_cstr = CString::new(opt_v.clone()).unwrap();
+
+ let ret = unsafe {
+ ffi::av_opt_set(
+ (*codec_ctx).priv_data,
+ opt_k_cstr.as_ptr(),
+ opt_v_cstr.as_ptr(),
+ 0,
+ )
+ };
+ if ret < 0 {
+ return Err(crate::Error::AVError(format!(
+ "Failed to set encoder opt `{}` to `{}`",
+ opt_k, opt_v
+ )));
+ }
+ }
+
+ let pix_fmt_name = CString::new(config.output_pix_fmt.clone()).unwrap();
+ let output_pix_fmt = unsafe { ffi::av_get_pix_fmt(pix_fmt_name.as_ptr()) };
+ if output_pix_fmt == ffi::AVPixelFormat_AV_PIX_FMT_NONE {
+ return Err(crate::Error::ConfigError(format!(
+ "Failed to find output pix fmt `{}`",
+ config.output_pix_fmt
+ )));
+ }
+
+ // If supported pix_fmts are known make sure the output pix_fmt is supported
+ if !codec.pix_fmts.is_null() {
+ let mut found = false;
+ for i in 0.. {
+ let pix_fmt = unsafe { *codec.pix_fmts.add(i) };
+ if pix_fmt == -1 {
+ break;
+ }
+ if pix_fmt == output_pix_fmt {
+ found = true;
+ break;
+ }
+ }
+ if !found {
+ return Err(crate::Error::ConfigError(format!(
+ "Output pix_fmt `{}` not supported by encoder",
+ config.output_pix_fmt
+ )));
+ }
+ }
+
+ let av_time_base = crate::util::rat_to_avrat(time_base);
+ unsafe {
+ (*codec_ctx).height = config.output_height as i32;
+ (*codec_ctx).width = config.output_width as i32;
+ (*codec_ctx).time_base = av_time_base;
+ (*codec_ctx).gop_size = 10; // TODO: Don't set?
+ (*codec_ctx).pix_fmt = output_pix_fmt;
+ (*codec_ctx).flags |= ffi::AV_CODEC_FLAG_GLOBAL_HEADER as i32;
+ }
+
+ if unsafe { ffi::avcodec_open2(codec_ctx, codec, ptr::null_mut()) } < 0 {
+ return Err(crate::Error::AVError("Failed to open encoder".to_string()));
+ }
+
+ let packet = unsafe { ffi::av_packet_alloc() };
+ if packet.is_null() {
+ return Err(crate::Error::AVError(
+ "Failed to allocate packet".to_string(),
+ ));
+ }
+
+ Ok(Encoder {
+ codec_ctx,
+ packet,
+ time_base: *time_base,
+ flushed: false,
+ })
+ }
+
+ pub(crate) fn encode(&mut self, pts: &Rational64, frame: &AVFrame) -> Result<(), crate::Error> {
+ // TODO: Do this elsewhere?
+ if unsafe { ffi::av_frame_make_writable(frame.inner) } < 0 {
+ return Err(crate::Error::AVError(
+ "Failed to make frame writable".to_string(),
+ ));
+ }
+ unsafe {
+ // It's none of our business what the input frame type is
+ // Also, we don't want the encoder to complain if something looks weird
+ (*frame.inner).pict_type = ffi::AVPictureType_AV_PICTURE_TYPE_NONE;
+ }
+
+ let time_scaled = pts / self.time_base;
+ assert!(*time_scaled.denom() == 1);
+ debug!("ENCODE - Set packet pts to {}", *time_scaled.numer());
+ unsafe {
+ (*frame.inner).pts = *time_scaled.numer();
+ (*frame.inner).pkt_dts = 0;
+ }
+
+ let ret = unsafe { ffi::avcodec_send_frame(self.codec_ctx, frame.inner) };
+ if ret < 0 {
+ let error = ffi::av_err2str(ret);
+ return Err(crate::Error::AVError(format!(
+ "Failed to send frame to encoder: {}",
+ error
+ )));
+ }
+
+ Ok(())
+ }
+
+ pub(crate) fn flush(&mut self) -> Result<(), crate::Error> {
+ assert!(!self.flushed);
+ self.flushed = true;
+ if unsafe { ffi::avcodec_send_frame(self.codec_ctx, ptr::null_mut()) } < 0 {
+ return Err(crate::Error::AVError("Failed to flush encoder".to_string()));
+ }
+
+ Ok(())
+ }
+
+ pub(crate) fn get_packet(&mut self) -> Option<*mut ffi::AVPacket> {
+ if unsafe { ffi::avcodec_receive_packet(self.codec_ctx, self.packet) } >= 0 {
+ Some(self.packet)
+ } else {
+ None
+ }
+ }
+
+ pub(crate) fn close(&mut self) {
+ assert!(self.flushed);
+ assert!(self.get_packet().is_none());
+
+ info!("Closing encoder");
+ unsafe {
+ ffi::av_packet_free(&mut self.packet);
+ ffi::avcodec_free_context(&mut self.codec_ctx);
+ }
+ }
+}
+vidformer/av/framesource.rs
+1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153
use num::Zero;
+use num_rational::Rational64;
+use rusty_ffmpeg::ffi;
+
+use crate::av::decoder::Decoder;
+use crate::av::demuxer::Demuxer;
+
+pub struct FrameSource {
+ demuxer: Demuxer,
+ decoder: Decoder,
+ packet: *mut ffi::AVPacket,
+ pub frame: *mut ffi::AVFrame,
+ frames_needs_unref: bool,
+}
+
+impl FrameSource {
+ pub fn new(
+ vid_path: &str,
+ stream: usize,
+ seek_ts: &Rational64,
+ service: &crate::service::Service,
+ file_size: u64,
+ io_runtime_handle: &tokio::runtime::Handle,
+ ) -> Result<FrameSource, crate::Error> {
+ let mut demuxer = crate::av::demuxer::Demuxer::new(
+ vid_path,
+ stream,
+ service,
+ file_size,
+ io_runtime_handle,
+ )?;
+ if !seek_ts.is_zero() {
+ demuxer.seek(seek_ts)?;
+ }
+
+ let decoder = crate::av::decoder::Decoder::new(demuxer.codec, demuxer.codec_parameters)?;
+
+ let frame = unsafe { ffi::av_frame_alloc().as_mut() }
+ .expect("failed to allocate memory for AVFrame");
+ let packet = unsafe { ffi::av_packet_alloc().as_mut() }
+ .expect("failed to allocate memory for AVPacket");
+
+ Ok(FrameSource {
+ demuxer,
+ decoder,
+ packet,
+ frame,
+ frames_needs_unref: false,
+ })
+ }
+
+ pub fn next_frame(&mut self) -> Result<Option<()>, crate::Error> {
+ if self.frames_needs_unref {
+ unsafe {
+ ffi::av_frame_unref(self.frame);
+ }
+ self.frames_needs_unref = false;
+ }
+
+ // Always try to remove ready frames before reading more packets
+ loop {
+ match self.decoder.read_frame(self.frame)? {
+ crate::av::decoder::DecoderResult::Frame => {
+ // we have a frame, yay!
+ self.frames_needs_unref = true;
+ return Ok(Some(()));
+ }
+ crate::av::decoder::DecoderResult::Again => {
+ // we need more packets
+ if self.demuxer.read_packet(self.packet).is_some() {
+ self.decoder.send_packet(self.packet);
+ unsafe {
+ ffi::av_packet_unref(self.packet);
+ }
+ } else {
+ // no more packets, flush the decoder and go until EOF
+ self.decoder.flush();
+ }
+ }
+ crate::av::decoder::DecoderResult::Eof => {
+ // we are done
+ return Ok(None);
+ }
+ }
+ }
+ }
+
+ pub fn time_base(&self) -> &Rational64 {
+ &self.demuxer.time_base
+ }
+
+ pub fn as_avframe(&self) -> std::sync::Arc<crate::dve::AVFrame> {
+ std::sync::Arc::new(crate::dve::AVFrame::clone_avframe(self.frame))
+ }
+}
+
+impl Drop for FrameSource {
+ fn drop(&mut self) {
+ if self.frames_needs_unref {
+ unsafe {
+ ffi::av_frame_unref(self.frame);
+ }
+ }
+ unsafe {
+ ffi::av_frame_free(&mut (self.frame as *mut _));
+ ffi::av_packet_free(&mut (self.packet as *mut _));
+ }
+ self.decoder.close();
+ self.demuxer.close();
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+ const TEST_VID: &str = "../tos_720p.mp4";
+ const TEST_STREAM: usize = 0;
+
+ #[test]
+ fn tos_test() {
+ let service = crate::service::Service::default();
+ let profile = crate::source::SourceVideoStreamMeta::profile(
+ "tos_720p",
+ "../tos_720p.mp4",
+ 0,
+ &service,
+ )
+ .unwrap();
+
+ let io_runtime = tokio::runtime::Builder::new_multi_thread()
+ .worker_threads(1)
+ .enable_all()
+ .build()
+ .unwrap();
+
+ let mut decoded_frames = 0;
+ let mut framesource = FrameSource::new(
+ TEST_VID,
+ TEST_STREAM,
+ &0.into(),
+ &service,
+ profile.file_size,
+ io_runtime.handle(),
+ )
+ .unwrap();
+
+ while framesource.next_frame().unwrap().is_some() {
+ decoded_frames += 1;
+ }
+
+ assert_eq!(decoded_frames, 17616);
+ }
+}
+vidformer/av/mod.rs
vidformer/av/muxer.rs
+1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155
use log::*;
+use num_rational::Rational64;
+use rusty_ffmpeg::ffi;
+use std::ffi::CString;
+use std::ptr;
+
+pub struct Muxer {
+ pub ofmt_ctx: *mut ffi::AVFormatContext,
+ pub out_time_base: ffi::AVRational,
+ pub out_stream: *mut ffi::AVStream,
+ pub frames: usize,
+}
+
+impl Muxer {
+ pub fn new(
+ output_path: &str,
+ codecpar: *mut ffi::AVCodecParameters,
+ time_base: &Rational64,
+ format_name: Option<&str>,
+ ) -> Result<Self, crate::Error> {
+ let output_path = CString::new(output_path).unwrap();
+ let mut ofmt_ctx: *mut ffi::AVFormatContext = ptr::null_mut();
+
+ let format_name_cstr: Option<CString> = format_name.map(|name| CString::new(name).unwrap());
+
+ if unsafe {
+ ffi::avformat_alloc_output_context2(
+ &mut ofmt_ctx,
+ ptr::null_mut(),
+ format_name_cstr
+ .as_ref()
+ .map_or(ptr::null(), |s| s.as_ptr()),
+ output_path.as_ptr(),
+ )
+ } < 0
+ {
+ return Err(crate::Error::AVError(
+ "Failed to allocate output context".to_string(),
+ ));
+ }
+
+ unsafe {
+ (*ofmt_ctx).debug = 1;
+ }
+
+ let out_stream = unsafe { ffi::avformat_new_stream(ofmt_ctx, ptr::null()) };
+ if out_stream.is_null() {
+ return Err(crate::Error::AVError(
+ "Failed to allocate output stream".to_string(),
+ ));
+ }
+
+ let time_base = crate::util::rat_to_avrat(time_base);
+ unsafe {
+ ffi::avcodec_parameters_free(&mut (*out_stream).codecpar); // free existing codec parameters, this is the only reference to them
+
+ (*out_stream).codecpar = ffi::avcodec_parameters_alloc();
+ if (*out_stream).codecpar.is_null() {
+ return Err(crate::Error::AVError(
+ "Failed to allocate codec parameters".to_string(),
+ ));
+ }
+ if ffi::avcodec_parameters_copy((*out_stream).codecpar, codecpar) < 0 {
+ return Err(crate::Error::AVError(
+ "Failed to copy codec parameters".to_string(),
+ ));
+ }
+
+ (*out_stream).time_base = time_base;
+ }
+
+ if unsafe { (*(*ofmt_ctx).oformat).flags } & ffi::AVFMT_NOFILE as i32 == 0
+ && unsafe {
+ ffi::avio_open(
+ &mut (*ofmt_ctx).pb,
+ output_path.as_ptr(),
+ ffi::AVIO_FLAG_WRITE as i32,
+ )
+ } < 0
+ {
+ return Err(crate::Error::AVError(
+ "Failed to open output file".to_string(),
+ ));
+ }
+
+ // show output on terminal
+ unsafe {
+ ffi::av_dump_format(ofmt_ctx, 0, output_path.as_ptr(), 1);
+ }
+
+ if unsafe { ffi::avformat_write_header(ofmt_ctx, ptr::null_mut()) } < 0 {
+ return Err(crate::Error::AVError(
+ "Failed to write output container header".to_string(),
+ ));
+ }
+
+ Ok(Muxer {
+ ofmt_ctx,
+ out_time_base: unsafe { (*out_stream).time_base },
+ out_stream,
+ frames: 0,
+ })
+ }
+
+ pub fn mux_packet(&mut self, packet: *mut ffi::AVPacket) -> Result<(), crate::Error> {
+ let input_pts = unsafe { (*packet).pts };
+ let input_dts = unsafe { (*packet).dts };
+
+ unsafe {
+ (*packet).pos = -1;
+ (*packet).stream_index = (*self.out_stream).index;
+ (*packet).duration = 0;
+ }
+
+ info!(
+ "MUX - Write packet with pts {} and dts {} side_elements={} flags={} (output pts = {}/{} and dts = {}/{})",
+ input_pts,
+ input_dts,
+ unsafe { (*packet).side_data_elems },
+ unsafe { (*packet).flags },
+ unsafe { (*packet).pts },
+ unsafe { (*self.out_stream).time_base.den},
+ unsafe { (*packet).dts },
+ unsafe { (*self.out_stream).time_base.den},
+ );
+
+ // Todo: maybe optionally interleave?
+ if unsafe { ffi::av_interleaved_write_frame(self.ofmt_ctx, packet) } < 0 {
+ return Err(crate::Error::AVError(
+ "Failed to write packet to output".to_string(),
+ ));
+ }
+
+ self.frames += 1;
+
+ Ok(())
+ }
+
+ pub fn close(self) -> Result<(), crate::Error> {
+ info!("Closing muxer");
+
+ // flush
+ if unsafe { ffi::av_interleaved_write_frame(self.ofmt_ctx, ptr::null_mut()) } < 0 {
+ return Err(crate::Error::AVError("Failed to flush output".to_string()));
+ }
+
+ unsafe {
+ ffi::av_write_trailer(self.ofmt_ctx);
+ ffi::avio_close((*self.ofmt_ctx).pb);
+ ffi::avformat_free_context(self.ofmt_ctx);
+ }
+
+ Ok(())
+ }
+}
+vidformer/dve.rs
+1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +441 +442 +443 +444 +445 +446 +447 +448 +449 +450 +451 +452 +453 +454 +455 +456 +457 +458 +459 +460 +461 +462 +463 +464 +465 +466 +467 +468 +469 +470 +471 +472 +473 +474 +475 +476 +477 +478 +479 +480 +481 +482 +483 +484 +485 +486 +487 +488 +489 +490 +491 +492 +493 +494 +495 +496 +497 +498 +499 +500 +501 +502 +503 +504 +505 +506 +507 +508 +509 +510 +511 +512 +513 +514 +515 +516 +517 +518 +519 +520 +521 +522 +523 +524 +525 +526 +527 +528 +529 +530 +531 +532 +533 +534 +535 +536 +537 +538 +539 +540 +541 +542 +543 +544 +545 +546 +547 +548 +549 +550 +551 +552 +553 +554 +555 +556 +557 +558 +559 +560 +561 +562 +563 +564 +565 +566 +567 +568 +569 +570 +571 +572 +573 +574 +575 +576 +577 +578 +579 +580 +581 +582 +583 +584 +585 +586 +587 +588 +589 +590 +591 +592 +593 +594 +595 +596 +597 +598 +599 +600 +601 +602 +603 +604 +605 +606 +607 +608 +609 +610 +611 +612 +613 +614 +615 +616 +617 +618 +619 +620 +621 +622 +623 +624 +625 +626 +627 +628 +629 +630 +631 +632 +633 +634 +635 +636 +637 +638 +639 +640 +641 +642 +643 +644 +645 +646 +647 +648 +649 +650 +651 +652 +653 +654 +655 +656 +657 +658 +659 +660 +661 +662 +663 +664 +665 +666 +667 +668 +669 +670 +671 +672 +673 +674 +675 +676 +677 +678 +679 +680 +681 +682 +683 +684 +685 +686 +687 +688 +689 +690 +691 +692 +693 +694 +695 +696 +697 +698 +699 +700 +701 +702 +703 +704 +705 +706 +707 +708 +709 +710 +711 +712 +713 +714 +715 +716 +717 +718 +719 +720 +721 +722 +723 +724 +725 +726 +727 +728 +729 +730 +731 +732 +733 +734 +735 +736 +737 +738 +739 +740 +741 +742 +743 +744 +745 +746 +747 +748 +749 +750 +751 +752 +753 +754 +755 +756 +757 +758 +759 +760 +761 +762 +763 +764 +765 +766 +767 +768 +769 +770 +771 +772 +773 +774 +775 +776 +777 +778 +779 +780 +781 +782 +783 +784 +785 +786 +787 +788 +789 +790 +791 +792 +793 +794 +795 +796 +797 +798 +799 +800 +801 +802 +803 +804 +805 +806 +807 +808 +809 +810 +811 +812 +813 +814 +815 +816 +817 +818 +819 +820 +821 +822 +823 +824 +825 +826 +827 +828 +829 +830 +831 +832 +833 +834 +835 +836 +837 +838 +839 +840 +841 +842 +843 +844 +845 +846 +847 +848 +849 +850 +851 +852 +853 +854 +855 +856 +857 +858 +859 +860 +861 +862 +863 +864 +865 +866 +867 +868 +869 +870 +871 +872 +873 +874 +875 +876 +877 +878 +879 +880 +881 +882 +883 +884 +885 +886 +887 +888 +889 +890 +891 +892 +893 +894 +895 +896 +897 +898 +899 +900 +901 +902 +903 +904 +905 +906 +907 +908 +909 +910 +911 +912 +913 +914 +915 +916 +917 +918 +919 +920 +921 +922 +923 +924 +925 +926 +927 +928 +929 +930 +931 +932 +933 +934 +935 +936 +937 +938 +939 +940 +941 +942 +943 +944 +945 +946 +947 +948 +949 +950 +951 +952 +953 +954 +955 +956 +957 +958 +959 +960 +961 +962 +963 +964 +965 +966 +967 +968 +969 +970 +971 +972 +973 +974 +975 +976 +977 +978 +979 +980 +981 +982 +983 +984 +985 +986 +987 +988 +989 +990 +991 +992 +993 +994 +995 +996 +997 +998 +999 +1000 +1001 +1002 +1003 +1004 +1005 +1006 +1007 +1008 +1009 +1010 +1011 +1012 +1013 +1014 +1015 +1016 +1017 +1018 +1019 +1020 +1021 +1022 +1023 +1024 +1025 +1026 +1027 +1028 +1029 +1030 +1031 +1032 +1033 +1034 +1035 +1036 +1037 +1038 +1039 +1040 +1041 +1042 +1043 +1044 +1045 +1046 +1047 +1048 +1049 +1050 +1051 +1052 +1053 +1054 +1055 +1056 +1057 +1058 +1059 +1060 +1061 +1062 +1063 +1064 +1065 +1066 +1067 +1068 +1069 +1070 +1071 +1072 +1073 +1074 +1075 +1076 +1077 +1078 +1079 +1080 +1081 +1082 +1083 +1084 +1085 +1086 +1087 +1088 +1089 +1090 +1091 +1092 +1093 +1094 +1095 +1096 +1097 +1098 +1099 +1100 +1101 +1102 +1103 +1104 +1105 +1106 +1107 +1108 +1109 +1110 +1111 +1112 +1113 +1114 +1115 +1116 +1117 +1118 +1119 +1120 +1121 +1122 +1123 +1124 +1125 +1126 +1127 +1128 +1129 +1130 +1131 +1132 +1133 +1134 +1135 +1136 +1137 +1138 +1139 +1140 +1141 +1142 +1143 +1144 +1145 +1146 +1147 +1148 +1149 +1150 +1151 +1152 +1153 +1154 +1155 +1156 +1157 +1158 +1159 +1160 +1161 +1162 +1163 +1164 +1165 +1166 +1167 +1168 +1169 +1170 +1171 +1172 +1173 +1174 +1175 +1176 +1177 +1178 +1179 +1180 +1181 +1182 +1183 +1184 +1185 +1186 +1187 +1188 +1189 +1190 +1191 +1192 +1193 +1194 +1195 +1196 +1197 +1198 +1199 +1200 +1201 +1202 +1203 +1204 +1205 +1206 +1207 +1208 +1209 +1210 +1211 +1212 +1213 +1214 +1215 +1216 +1217 +1218 +1219 +1220 +1221 +1222 +1223 +1224 +1225 +1226 +1227 +1228 +1229 +1230 +1231 +1232 +1233 +1234 +1235 +1236 +1237 +1238 +1239 +1240 +1241 +1242 +1243 +1244 +1245 +1246 +1247 +1248 +1249 +1250 +1251 +1252 +1253 +1254 +1255 +1256 +1257 +1258 +1259 +1260 +1261 +1262 +1263 +1264 +1265 +1266 +1267 +1268 +1269 +1270 +1271 +1272 +1273 +1274 +1275 +1276 +1277 +1278 +1279 +1280 +1281 +1282 +1283 +1284 +1285 +1286 +1287 +1288 +1289 +1290 +1291 +1292 +1293 +1294 +1295 +1296 +1297 +1298 +1299 +1300 +1301 +1302 +1303 +1304 +1305 +1306 +1307 +1308 +1309 +1310 +1311 +1312 +1313 +1314 +1315 +1316 +1317 +1318 +1319 +1320 +1321 +1322 +1323 +1324 +1325 +1326 +1327 +1328 +1329 +1330 +1331 +1332 +1333 +1334 +1335 +1336 +1337 +1338 +1339 +1340 +1341 +1342 +1343 +1344 +1345 +1346 +1347 +1348 +1349 +1350 +1351 +1352 +1353 +1354 +1355 +1356 +1357 +1358 +1359 +1360 +1361 +1362 +1363
use crate::av;
+use crate::filter;
+use crate::filter::Frame;
+use crate::pool::Pool;
+use crate::sir;
+
+use crate::spec::Spec;
+use crate::util;
+use log::*;
+use num::integer::Roots;
+use num_rational::Rational64;
+use parking_lot::Condvar;
+use parking_lot::Mutex;
+use rusty_ffmpeg::ffi;
+use serde::Deserialize;
+use serde::Serialize;
+use std::collections::BTreeMap;
+use std::collections::BTreeSet;
+use std::ffi::CString;
+use std::sync::atomic::AtomicI64;
+use std::sync::atomic::Ordering;
+use std::sync::Arc;
+
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+ #[error("Source `{0}` not found")]
+ SourceNotFound(String),
+ #[error("Index `{1:?}` out of bounds on source `{0}`")]
+ IndexOutOfBounds(String, sir::IndexConst),
+ #[error("Missing filter arg")]
+ MissingFilterArg,
+ #[error("Invalid filter arg type on `{0}`. Expected `{1}`, got `{2}`")]
+ InvalidFilterArgType(String, String, String),
+ #[error("Invalid filter arg value `{0}`: `{1}`")]
+ InvalidFilterArgValue(String, String),
+ #[error("Filter internal error: {0}")]
+ FilterInternalError(String),
+ #[error("Invalid output frame type")]
+ InvalidOutputFrameType,
+ #[error("Config error: {0}")]
+ ConfigError(String),
+ #[error("AV error: {0}")]
+ AVError(String),
+ #[error("IO error: {0}")]
+ IOError(String),
+ #[error("Unknown error: {0}")]
+ Unknown(String),
+}
+
+#[derive(Ord, Eq, PartialEq, PartialOrd, Clone, Debug)]
+pub(crate) struct SourceRef {
+ video: String,
+}
+
+impl SourceRef {
+ pub fn new(video: &str) -> Self {
+ SourceRef {
+ video: video.to_string(),
+ }
+ }
+}
+
+impl std::fmt::Display for SourceRef {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ write!(f, "{}", self.video)
+ }
+}
+
+/// A context for a spec
+///
+/// This is a collection of sources, filters, and arrays that are used to execute a DVE spec.
+/// It's a pretty simple layout here, but if you really want to incorporate vidformer deep into a VDBMS, you
+/// gut this object and make the sources and arrays backed directly through your DB.
+pub struct Context {
+ pub(crate) sources: BTreeMap<SourceRef, crate::source::SourceVideoStreamMeta>,
+ pub(crate) filters: BTreeMap<String, Box<dyn crate::filter::Filter>>,
+ pub(crate) arrays: BTreeMap<String, Box<dyn crate::array::Array>>,
+}
+
+#[derive(Debug)]
+
+pub(crate) struct AVFrame {
+ pub(crate) inner: *mut ffi::AVFrame,
+}
+
+impl AVFrame {
+ pub(crate) fn clone_avframe(frame: *mut ffi::AVFrame) -> AVFrame {
+ let new_frame = unsafe { ffi::av_frame_clone(frame) };
+ AVFrame { inner: new_frame }
+ }
+}
+
+unsafe impl Send for AVFrame {}
+unsafe impl Sync for AVFrame {}
+
+impl Drop for AVFrame {
+ fn drop(&mut self) {
+ unsafe { ffi::av_frame_free(&mut self.inner) }
+ }
+}
+
+pub(crate) struct EmptySpecCtx;
+impl crate::spec::SpecContext for EmptySpecCtx {}
+
+impl Context {
+ pub fn new(
+ source_files: Vec<crate::source::SourceVideoStreamMeta>,
+ arrays: BTreeMap<String, Box<dyn crate::array::Array>>,
+ filters: BTreeMap<String, Box<dyn crate::filter::Filter>>,
+ ) -> Context {
+ let mut sources = BTreeMap::new();
+ for source in source_files {
+ sources.insert(SourceRef::new(&source.name), source);
+ }
+ Context {
+ sources,
+ arrays,
+ filters,
+ }
+ }
+
+ pub fn spec_ctx(&self) -> impl crate::spec::SpecContext {
+ EmptySpecCtx
+ }
+
+ pub(crate) fn get_gop_frames(
+ &self,
+ source: &SourceRef,
+ gop_idx: usize,
+ ) -> BTreeSet<Rational64> {
+ let stream_meta = &self.sources.get(source).unwrap();
+ let mut out = BTreeSet::new();
+
+ let gop_start_ts = stream_meta.keys[gop_idx];
+ let next_gop_start_ts = if gop_idx >= stream_meta.keys.len() - 1 {
+ None
+ } else {
+ Some(stream_meta.keys[gop_idx + 1])
+ };
+
+ // TODO: Use binary search to speed up
+ for frame_ts in &stream_meta.ts {
+ if frame_ts >= &gop_start_ts {
+ if next_gop_start_ts.is_some() && frame_ts >= next_gop_start_ts.as_ref().unwrap() {
+ break;
+ }
+ out.insert(*frame_ts);
+ }
+ }
+
+ out
+ }
+
+ pub(crate) fn resolve_frame_source(
+ &self,
+ frame_source: &crate::sir::FrameSource,
+ ) -> Result<(SourceRef, Rational64), Error> {
+ let source_name: &String = &frame_source.video;
+ let sourceref = SourceRef::new(source_name);
+ if let Some(source) = self.sources.get(&sourceref) {
+ match &frame_source.index {
+ crate::sir::IndexConst::T(t) => {
+ // make sure the timestamp exists
+ match source.ts.binary_search(t) {
+ Ok(_) => Ok((sourceref, *t)),
+ Err(_) => Err(Error::IndexOutOfBounds(
+ source_name.clone(),
+ frame_source.index.clone(),
+ )),
+ }
+ }
+ crate::sir::IndexConst::ILoc(k) => {
+ if let Some(t) = source.ts.get(*k) {
+ Ok((SourceRef::new(&frame_source.video), *t))
+ } else {
+ Err(Error::IndexOutOfBounds(
+ source_name.clone(),
+ frame_source.index.clone(),
+ ))
+ }
+ }
+ }
+ } else {
+ Err(Error::SourceNotFound(source_name.clone()))
+ }
+ }
+}
+
+#[derive(Debug)]
+pub(crate) struct DecoderState {
+ pub source: SourceRef,
+ pub gop_idx: usize,
+ pub future_frames: BTreeSet<Rational64>,
+ pub past_frames: BTreeSet<Rational64>,
+}
+
+impl DecoderState {
+ pub(crate) fn future_iframerefs(&self) -> BTreeSet<IFrameRef> {
+ self.future_frames
+ .iter()
+ .map(|t| IFrameRef {
+ sourceref: self.source.clone(),
+ pts: *t,
+ })
+ .collect()
+ }
+}
+
+pub(crate) fn run_decoder(
+ context: &Context,
+ stat: &StatRunner,
+ source: &SourceRef,
+ gop_idx: usize,
+ pool: &Arc<(Mutex<Pool>, Condvar)>,
+ decoder_id: String,
+ io_runtime_handle: &tokio::runtime::Handle,
+) -> Result<(), Error> {
+ let stream_meta = &context.sources.get(source).unwrap();
+ let stream_service = &stream_meta.service;
+
+ let mut framesource = av::framesource::FrameSource::new(
+ &stream_meta.file_path,
+ stream_meta.stream_idx,
+ &stream_meta.keys[gop_idx],
+ stream_service,
+ stream_meta.file_size,
+ io_runtime_handle,
+ )?;
+
+ while framesource.next_frame()?.is_some() {
+ stat.frames_decoded
+ .fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+ unsafe {
+ debug!(
+ "DECODE - Frame (type={}, size={} bytes, pts={} key_frame={})",
+ char::from(ffi::av_get_picture_type_char((*framesource.frame).pict_type) as u8),
+ (*framesource.frame).pkt_size,
+ (*framesource.frame).pts,
+ (*framesource.frame).key_frame,
+ );
+ }
+ let frame_t =
+ Rational64::new(unsafe { (*framesource.frame).pts }, 1) * framesource.time_base();
+ let iframeref = IFrameRef {
+ sourceref: source.clone(),
+ pts: frame_t,
+ };
+
+ loop {
+ let mut pool_ref = pool.0.lock();
+ if pool_ref.terminate_decoders {
+ return Ok(());
+ }
+
+ {
+ let decoder_state = pool_ref.decoders.get_mut(&decoder_id).unwrap();
+ debug_assert!(decoder_state.source == *source);
+ debug_assert!(decoder_state.gop_idx == gop_idx);
+
+ if !decoder_state.future_frames.contains(&iframeref.pts) {
+ warn!(
+ "Decoded frame pts={} not extected in {}:gop{}",
+ iframeref.pts, source, gop_idx
+ );
+ return Err(Error::AVError(format!(
+ "Decoded frame not expected, source {} gop {} not encoded correctly!",
+ source, gop_idx
+ )));
+ }
+ }
+
+ if pool_ref.should_stall(&decoder_id) {
+ if pool_ref.should_decoder_abandon(&decoder_id) {
+ pool_ref.decoders.remove(&decoder_id);
+ pool_ref
+ .finished_unjoined_decoders
+ .insert(decoder_id.clone());
+ pool.1.notify_all();
+ return Ok(());
+ } else {
+ pool.1.wait(&mut pool_ref);
+ continue;
+ }
+ }
+
+ let avframe = framesource.as_avframe();
+ debug!("Adding frame {}:{} to pool", source, iframeref.pts);
+ pool_ref.decoded(&decoder_id, iframeref.clone(), avframe);
+
+ let decoder_state = pool_ref.decoders.get_mut(&decoder_id).unwrap();
+ decoder_state.future_frames.remove(&iframeref.pts);
+ decoder_state.past_frames.insert(iframeref.pts);
+
+ // we've mutated the pool
+ pool.1.notify_all();
+
+ if decoder_state.future_frames.is_empty() {
+ pool_ref.decoders.remove(&decoder_id);
+ pool_ref
+ .finished_unjoined_decoders
+ .insert(decoder_id.clone());
+ return Ok(());
+ } else {
+ break;
+ }
+ }
+ }
+
+ Err(Error::AVError("Decoder ran out of frames".to_string()))
+}
+
+struct FilterTask {
+ gen: usize,
+ oframe_expr: crate::sir::FrameExpr,
+ dep_frames: BTreeMap<IFrameRef, Arc<AVFrame>>,
+}
+
+struct FilterTaskResult {
+ gen: usize,
+ oframe: Arc<AVFrame>,
+}
+
+fn run_filter(
+ context: &Context,
+ config: &Config,
+ _stat: &StatRunner,
+ input_channel: crossbeam_channel::Receiver<Option<FilterTask>>,
+ output_channel: crossbeam_channel::Sender<FilterTaskResult>,
+) -> Result<(), Error> {
+ loop {
+ match input_channel.recv() {
+ Ok(Some(filter_task)) => {
+ debug!("Filtering gen {}", filter_task.gen);
+ let oframe = render_frame(
+ context,
+ config,
+ &filter_task.oframe_expr,
+ &filter_task.dep_frames,
+ )?;
+
+ let result = FilterTaskResult {
+ gen: filter_task.gen,
+ oframe,
+ };
+
+ output_channel.send(result).unwrap();
+ }
+ Ok(None) => {
+ debug!("Filter recieved kill signal");
+ return Ok(());
+ }
+ Err(crossbeam_channel::RecvError) => {
+ return Err(Error::Unknown("Filter channel closed".to_string()));
+ }
+ }
+ }
+}
+
+#[derive(Ord, Eq, PartialEq, PartialOrd, Clone, Debug)]
+pub struct IFrameRef {
+ pub sourceref: SourceRef,
+ pub pts: Rational64,
+}
+
+/// Config for a spesific run of a vidformer spec
+///
+/// This is a collection of settings that are used to execute a spec.
+/// This combines information about the output with internal performance knobs.
+///
+/// The max number of frames in memory is roughly decoders + decode_pool_size + decoder_view
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct Config {
+ /// The number of frames which can be fit in the decode pool
+ pub decode_pool_size: usize,
+ /// How many output frames can be active at once
+ /// This also limits how many frames can be in the filters + encode buffer at once
+ pub decoder_view: usize,
+ /// How many decoders can be active at once
+ pub decoders: usize,
+ /// How many filter threads to run
+ pub filterers: usize,
+
+ pub output_width: usize,
+ pub output_height: usize,
+ pub output_pix_fmt: String, // needs to be an AVPixelFormat
+
+ /// Configuration to use for output encoder
+ pub encoder: Option<EncoderConfig>,
+
+ /// The name of the format to use for output.
+ /// If None, the format will be inferred from the output path.
+ pub format: Option<String>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct EncoderConfig {
+ pub codec_name: String,
+
+ pub opts: Vec<(String, String)>,
+}
+
+impl EncoderConfig {
+ pub(crate) fn avcodec(&self) -> Result<&'static ffi::AVCodec, Error> {
+ let codec_name = &self.codec_name;
+ let codec_name_cstr = CString::new(codec_name.clone()).unwrap();
+
+ let av_codec =
+ unsafe { ffi::avcodec_find_encoder_by_name(codec_name_cstr.as_ptr()).as_ref() };
+ match av_codec {
+ Some(av_codec) => Ok(av_codec),
+ None => Err(Error::ConfigError(format!(
+ "Failed to find encoder for `{}` codec",
+ codec_name
+ ))),
+ }
+ }
+}
+
+impl Config {
+ pub(crate) fn expected_output_type(&self) -> filter::FrameType {
+ filter::FrameType {
+ width: self.output_width,
+ height: self.output_height,
+ format: util::pixel_fmt_str_to_av_pix_fmt(self.output_pix_fmt.as_str()).unwrap(),
+ }
+ }
+}
+
+/// Stats from a run of a vidformer spec
+#[derive(Debug, Serialize)]
+pub struct Stats {
+ pub max_decoder_count: usize,
+ pub max_encode_buffer_size: usize,
+ pub decoders_created: usize,
+ pub frames_written: usize,
+ pub frames_decoded: usize,
+ pub runtime: std::time::Duration,
+}
+
+pub(crate) struct StatRunner {
+ max_decoder_count: std::sync::atomic::AtomicUsize,
+ max_encode_buffer_size: std::sync::atomic::AtomicUsize,
+ decoders_created: std::sync::atomic::AtomicUsize,
+ frames_written: std::sync::atomic::AtomicUsize,
+ frames_decoded: std::sync::atomic::AtomicUsize,
+ start_time: std::time::Instant,
+}
+
+impl StatRunner {
+ fn new() -> Self {
+ StatRunner {
+ max_decoder_count: std::sync::atomic::AtomicUsize::new(0),
+ max_encode_buffer_size: std::sync::atomic::AtomicUsize::new(0),
+ decoders_created: std::sync::atomic::AtomicUsize::new(0),
+ frames_written: std::sync::atomic::AtomicUsize::new(0),
+ frames_decoded: std::sync::atomic::AtomicUsize::new(0),
+ start_time: std::time::Instant::now(),
+ }
+ }
+
+ fn stats(&self) -> Stats {
+ Stats {
+ max_decoder_count: self
+ .max_decoder_count
+ .load(std::sync::atomic::Ordering::SeqCst),
+ max_encode_buffer_size: self
+ .max_encode_buffer_size
+ .load(std::sync::atomic::Ordering::SeqCst),
+ decoders_created: self
+ .decoders_created
+ .load(std::sync::atomic::Ordering::SeqCst),
+ frames_written: self
+ .frames_written
+ .load(std::sync::atomic::Ordering::SeqCst),
+ frames_decoded: self
+ .frames_decoded
+ .load(std::sync::atomic::Ordering::SeqCst),
+ runtime: std::time::Instant::now() - self.start_time,
+ }
+ }
+}
+
+pub(crate) fn type_frame(
+ context: &Context,
+ _config: &Config,
+ frame: &crate::sir::FrameExpr,
+) -> Result<filter::FrameType, Error> {
+ match frame {
+ crate::sir::FrameExpr::Source(s) => {
+ let (sourceref, _t) = context.resolve_frame_source(s)?;
+ let source = context.sources.get(&sourceref).unwrap();
+ Ok(filter::FrameType {
+ width: source.resolution.0,
+ height: source.resolution.1,
+ format: util::pixel_fmt_str_to_av_pix_fmt(source.pix_fmt.as_str()).unwrap(),
+ })
+ }
+ crate::sir::FrameExpr::Filter(f) => {
+ let filter = context.filters.get(&f.name);
+
+ if filter.is_none() {
+ return Err(Error::Unknown(format!("Filter `{}` not found", f.name)));
+ }
+ let filter = filter.unwrap();
+
+ let mut args = Vec::new();
+ let mut kwargs = BTreeMap::new();
+
+ for arg in &f.args {
+ match arg {
+ crate::sir::Expr::Frame(frame) => {
+ let frame = type_frame(context, _config, frame)?;
+ args.push(filter::Val::FrameType(frame));
+ }
+ crate::sir::Expr::Data(data) => {
+ args.push(crate::filter::Val::from_expr(data, context));
+ }
+ }
+ }
+ for (k, v) in &f.kwargs {
+ match v {
+ crate::sir::Expr::Frame(frame) => {
+ let frame = type_frame(context, _config, frame)?;
+ kwargs.insert(k.clone(), filter::Val::FrameType(frame));
+ }
+ crate::sir::Expr::Data(data) => {
+ kwargs.insert(k.clone(), crate::filter::Val::from_expr(data, context));
+ }
+ }
+ }
+
+ Ok(filter.filter_type(&args, &kwargs)?)
+ }
+ }
+}
+
+fn render_frame(
+ context: &Context,
+ _config: &Config,
+ frame: &crate::sir::FrameExpr,
+ loaded_frames: &BTreeMap<IFrameRef, Arc<AVFrame>>,
+) -> Result<Arc<AVFrame>, Error> {
+ info!("Rendering frame {}", frame);
+ match frame {
+ crate::sir::FrameExpr::Source(s) => {
+ let (source_ref, t) = context.resolve_frame_source(s)?;
+ let frame_ref = IFrameRef {
+ sourceref: source_ref,
+ pts: t,
+ };
+ let frame = loaded_frames.get(&frame_ref).unwrap();
+ Ok(frame.clone())
+ }
+ crate::sir::FrameExpr::Filter(f) => {
+ let filter = context.filters.get(&f.name).unwrap();
+ let mut args = Vec::new();
+ let mut kwargs = BTreeMap::new();
+
+ // TODO: Very easy to parallelize these two loops
+ for arg in &f.args {
+ match arg {
+ crate::sir::Expr::Frame(frame) => {
+ let frame = render_frame(context, _config, frame, loaded_frames)?;
+ args.push(crate::filter::Val::Frame(Frame::new_arc(frame)));
+ }
+ crate::sir::Expr::Data(data) => {
+ args.push(crate::filter::Val::from_expr(data, context));
+ }
+ }
+ }
+ for (k, v) in &f.kwargs {
+ match v {
+ crate::sir::Expr::Frame(frame) => {
+ let frame = render_frame(context, _config, frame, loaded_frames)?;
+ kwargs.insert(k.clone(), crate::filter::Val::Frame(Frame::new_arc(frame)));
+ }
+ crate::sir::Expr::Data(data) => {
+ kwargs.insert(k.clone(), crate::filter::Val::from_expr(data, context));
+ }
+ }
+ }
+
+ let oframe = filter.filter(&args, &kwargs)?;
+
+ Ok(oframe.into_avframe())
+ }
+ }
+}
+
+/// Select whether the output timestamps are local to the ranged segment or the entire output
+///
+/// - `SegmentLocal`: The output timestamps are in the same timebase as the ranged segment. Used for VOD.
+/// - `StreamLocal`: The output timestamps are in the same timebase as the entire output.
+#[derive(Clone)]
+pub enum RangeTsFormat {
+ SegmentLocal,
+ StreamLocal,
+}
+
+/// A range spesifier
+///
+/// `start` and `end` are the start and end of the range in the timebase of the input, inclusive.
+#[derive(Clone)]
+pub struct Range {
+ pub start: Rational64,
+ pub end: Rational64,
+ pub ts_format: RangeTsFormat,
+}
+
+struct EncodeBuffer {
+ members: Vec<(usize, Arc<AVFrame>)>,
+ terminate_encoder: bool,
+}
+
+impl EncodeBuffer {
+ fn new() -> Self {
+ EncodeBuffer {
+ members: Vec::new(),
+ terminate_encoder: false,
+ }
+ }
+}
+
+struct ExecContext {
+ output_path: String,
+ context: Arc<Context>,
+ config: Arc<Config>,
+
+ stat: Arc<StatRunner>,
+ process_span: Arc<sir::ProcessSpan>,
+
+ pool: Arc<(Mutex<Pool>, Condvar)>,
+ output_time_base: num_rational::Ratio<i64>,
+
+ to_filter_channel: (
+ crossbeam_channel::Sender<Option<FilterTask>>,
+ crossbeam_channel::Receiver<Option<FilterTask>>,
+ ),
+ from_filter_channel: (
+ crossbeam_channel::Sender<FilterTaskResult>,
+ crossbeam_channel::Receiver<FilterTaskResult>,
+ ),
+
+ decoder_count: Arc<AtomicI64>,
+ io_runtime: tokio::runtime::Runtime,
+
+ filtering_gens: BTreeSet<usize>,
+ frames_post_filtering: usize,
+
+ encode_buffer: Arc<(Mutex<EncodeBuffer>, Condvar)>,
+ dec_join_handles: BTreeMap<String, std::thread::JoinHandle<Result<(), Error>>>,
+ filter_join_handles: Vec<std::thread::JoinHandle<Result<(), Error>>>,
+}
+
+impl ExecContext {
+ fn run(mut self) -> Result<Stats, Error> {
+ let enc_thread = {
+ let encode_buffer = self.encode_buffer.clone();
+ let output_path = self.output_path.to_string();
+ let config = self.config.clone();
+ let process_span = self.process_span.clone();
+ let stat = self.stat.clone();
+ let output_time_base = self.output_time_base;
+
+ std::thread::spawn(move || {
+ let r = encoder_thread(
+ config,
+ stat,
+ output_time_base,
+ output_path,
+ process_span,
+ encode_buffer,
+ );
+
+ debug!("Enc thread ended");
+ r
+ })
+ };
+
+ for _i in 0..self.config.filterers {
+ let context = self.context.clone();
+ let config = self.config.clone();
+ let stat = self.stat.clone();
+ let reciever = self.to_filter_channel.1.clone();
+ let sender = self.from_filter_channel.0.clone();
+ let filter_thread =
+ std::thread::spawn(move || run_filter(&context, &config, &stat, reciever, sender));
+ self.filter_join_handles.push(filter_thread);
+ }
+
+ let mut return_err: Option<Error> = Option::None;
+
+ 'control_loop: loop {
+ debug_assert!(return_err.is_none());
+
+ // Create new decoders
+ let r = self.create_new_decoders();
+ if let Err(e) = r {
+ return_err = Some(e);
+ break 'control_loop;
+ }
+
+ // Join finished decoders
+ let r = self.join_finished_decoders();
+ match r {
+ Ok(request_early_stop) if request_early_stop => break,
+ Ok(_) => {}
+ Err(e) => {
+ return_err = Some(e);
+ break 'control_loop;
+ }
+ }
+ // Create filters
+ let r = self.send_to_filters();
+ if let Err(e) = r {
+ return_err = Some(e);
+ break 'control_loop;
+ }
+
+ // Process filtered frames
+ let r = self.recieve_filtered_frames();
+ if let Err(e) = r {
+ return_err = Some(e);
+ break 'control_loop;
+ }
+
+ // Check if encoder finished
+ {
+ if enc_thread.is_finished() {
+ // This means the encoder had an error and we should stop
+ break;
+ }
+ }
+
+ // Check if any filter threads panicked
+ {
+ let finished_i = self
+ .filter_join_handles
+ .iter()
+ .position(|h| h.is_finished());
+ // for filter_join_handle in self.filter_join_handles.iter() {
+ // if filter_join_handle.is_finished() {
+ // return_err = Some(Error::Unknown("Filter thread panicked".to_string()));
+ // break 'control_loop;
+ // }
+ // }
+ if let Some(finished_i) = finished_i {
+ let thread_return = self.filter_join_handles.remove(finished_i).join();
+
+ match thread_return {
+ Ok(Ok(_)) => {
+ return_err =
+ Some(Error::Unknown("Filter thread finished early?".to_string()));
+ break 'control_loop;
+ }
+ Ok(Err(e)) => {
+ return_err = Some(e);
+ break 'control_loop;
+ }
+ Err(e) => {
+ return_err = Some(Error::Unknown(format!(
+ "Filter thread {} panicked: {:?}",
+ finished_i, e
+ )));
+ break 'control_loop;
+ }
+ }
+ }
+ }
+
+ if self.frames_post_filtering == self.process_span.frames.len() {
+ break;
+ }
+
+ std::thread::sleep(std::time::Duration::from_micros(250));
+ }
+
+ // If we are here either all frames have been filtered or we have an error
+ debug!("Main exec loop finished");
+
+ // Wait for all decoders to finish
+ {
+ let mut pool_ref = self.pool.0.lock();
+ pool_ref.terminate_decoders = true;
+ self.pool.1.notify_all();
+ }
+
+ while let Some((_decoder_id, dec_join_handle)) = self.dec_join_handles.pop_first() {
+ match dec_join_handle.join() {
+ Ok(decoder_result) => {
+ match decoder_result {
+ Ok(_) => {} // Thread finished successfully
+ Err(e) => {
+ if return_err.is_none() {
+ return_err = Some(e);
+ }
+ }
+ }
+ }
+ Err(e) => {
+ if return_err.is_none() {
+ return_err =
+ Some(Error::Unknown(format!("Decoder thread panicked: {:?}", e)));
+ }
+ break;
+ }
+ }
+ }
+ debug!("All decoders finished");
+
+ // Wait for all filters to finish
+ for _i in 0..self.config.filterers {
+ self.to_filter_channel.0.send(None).unwrap();
+ }
+ while let Some(filter_join_handle) = self.filter_join_handles.pop() {
+ match filter_join_handle.join() {
+ Ok(filter_result) => {
+ match filter_result {
+ Ok(_) => {} // Thread finished successfully
+ Err(e) => {
+ if return_err.is_none() {
+ return_err = Some(e);
+ }
+ }
+ }
+ }
+ Err(e) => {
+ if return_err.is_none() {
+ return_err =
+ Some(Error::Unknown(format!("Filter thread panicked: {:?}", e)));
+ }
+ break;
+ }
+ }
+ }
+ debug!("All filters finished");
+
+ // Wait for encoder to finish
+ if return_err.is_some() {
+ let mut encode_buffer_ref = self.encode_buffer.0.lock();
+ // If we have an error kill the encoder now
+ encode_buffer_ref.terminate_encoder = true;
+ self.encode_buffer.1.notify_one();
+ }
+ match enc_thread.join() {
+ Ok(enc_result) => {
+ match enc_result {
+ Ok(_) => {} // Thread finished successfully
+ Err(e) => {
+ assert!(return_err.is_none());
+ return_err = Some(e);
+ }
+ }
+ }
+ Err(e) => {
+ assert!(return_err.is_none());
+ return_err = Some(Error::Unknown(format!("Encoder thread panicked: {:?}", e)));
+ }
+ }
+ debug!("Encoder finished");
+
+ match return_err {
+ Some(e) => Err(e),
+ None => Ok(self.stat.stats()),
+ }
+ }
+
+ fn recieve_filtered_frames(&mut self) -> Result<(), Error> {
+ loop {
+ match self.from_filter_channel.1.try_recv() {
+ Ok(result) => {
+ debug!("Recieved gen {} from filter", result.gen);
+ debug_assert!(self.filtering_gens.contains(&result.gen));
+ self.filtering_gens.remove(&result.gen);
+
+ let oframe = result.oframe;
+ let gen = result.gen;
+
+ {
+ let mut pool_ref = self.pool.0.lock();
+ debug_assert!(pool_ref.is_gen_ready(gen));
+ pool_ref.finish_gen(gen);
+ self.pool.1.notify_all();
+ }
+
+ {
+ let mut encode_buffer_ref = self.encode_buffer.0.lock();
+ encode_buffer_ref.members.push((gen, oframe));
+ let encode_buffer_size = encode_buffer_ref.members.len();
+ self.stat
+ .max_encode_buffer_size
+ .fetch_max(encode_buffer_size, Ordering::SeqCst);
+
+ self.encode_buffer.1.notify_one();
+ }
+
+ self.frames_post_filtering += 1;
+ }
+ Err(crossbeam_channel::TryRecvError::Empty) => {
+ return Ok(());
+ }
+ Err(crossbeam_channel::TryRecvError::Disconnected) => {
+ return Err(Error::Unknown("Filter channel closed".to_string()));
+ }
+ }
+ }
+ }
+
+ fn join_finished_decoders(&mut self) -> Result<bool, Error> {
+ let mut pool_ref = self.pool.0.lock();
+ while let Some(finished_decoder_id) = pool_ref.finished_unjoined_decoders.pop_first() {
+ let dec_join_handle = self.dec_join_handles.remove(&finished_decoder_id).unwrap();
+ match dec_join_handle.join() {
+ Ok(decoder_result) => {
+ match decoder_result {
+ Ok(_) => {} // Thread finished successfully
+ Err(e) => {
+ return Err(e);
+ }
+ }
+ }
+ Err(e) => {
+ return Err(Error::Unknown(format!("Decoder thread panicked: {:?}", e)));
+ }
+ }
+ self.pool.1.notify_all();
+ }
+
+ // now that we've removed all decoders which reported themselves as finished check for any panicked decoders
+ for (decoder_id, dec_join_handle) in self.dec_join_handles.iter() {
+ if dec_join_handle.is_finished() {
+ info!(
+ "Found a unexpected finished decoder thread: {:?}",
+ decoder_id
+ );
+ return Ok(true);
+ }
+ }
+
+ Ok(false)
+ }
+
+ fn create_new_decoders(&mut self) -> Result<(), Error> {
+ if self.decoder_count.load(Ordering::SeqCst) < self.config.decoders as i64 {
+ debug_assert!(self.decoder_count.load(Ordering::SeqCst) >= 0);
+ let mut pool_ref = self.pool.0.lock();
+ let new_decoder = pool_ref.new_decoder_gop();
+ if let Some((sourceref, gop_idx)) = new_decoder {
+ let source = sourceref.clone();
+ let decoder_id = crate::util::rand_uuid();
+ let decooder_id_join_handle_copy = decoder_id.clone();
+ let pool = self.pool.clone();
+ let context = self.context.clone();
+ let stat = self.stat.clone();
+ let io_runtime_handle = self.io_runtime.handle().clone();
+
+ let num_decoders = self.decoder_count.fetch_add(1, Ordering::SeqCst) + 1;
+ stat.max_decoder_count
+ .fetch_max(num_decoders as usize, Ordering::SeqCst);
+ stat.decoders_created.fetch_add(1, Ordering::SeqCst);
+ let decoder_count = self.decoder_count.clone();
+
+ let decoder_state = DecoderState {
+ source: source.clone(),
+ gop_idx,
+ future_frames: context.get_gop_frames(&source, gop_idx),
+ past_frames: BTreeSet::new(),
+ };
+ pool_ref.decoders.insert(decoder_id.clone(), decoder_state);
+ self.pool.1.notify_all();
+
+ debug!("Creating decoder {decoder_id} on {source}:gop{gop_idx}");
+
+ let dec_join_handle = std::thread::Builder::new()
+ .name("decoder".to_string())
+ .spawn(move || {
+ let decoder_result = run_decoder(
+ &context,
+ &stat,
+ &source,
+ gop_idx,
+ &pool,
+ decoder_id.clone(),
+ &io_runtime_handle,
+ );
+ // TODO: Handle error
+ decoder_count.fetch_add(-1, Ordering::SeqCst);
+ debug!("Decoder {decoder_id} finished");
+ decoder_result
+ })
+ .unwrap();
+
+ self.dec_join_handles
+ .insert(decooder_id_join_handle_copy, dec_join_handle);
+ }
+ }
+
+ Ok(())
+ }
+
+ fn send_to_filters(&mut self) -> Result<(), Error> {
+ loop {
+ let gen_to_filter = {
+ let mut out = None;
+ let pool_ref = self.pool.0.lock();
+ for active_gen in pool_ref.active_gens() {
+ if !self.filtering_gens.contains(&active_gen)
+ && pool_ref.is_gen_ready(active_gen)
+ {
+ out = Some(active_gen);
+ break;
+ }
+ }
+ out
+ };
+
+ if gen_to_filter.is_none() {
+ break;
+ }
+ let gen_to_filter = gen_to_filter.unwrap();
+ self.filtering_gens.insert(gen_to_filter);
+
+ let frame_deps = {
+ let pool_ref = self.pool.0.lock();
+ pool_ref.get_ready_gen_frames(gen_to_filter)
+ };
+
+ let filter_task = FilterTask {
+ gen: gen_to_filter,
+ oframe_expr: self.process_span.frames[gen_to_filter].clone(),
+ dep_frames: frame_deps,
+ };
+
+ debug!("Sending gen {} to filter", gen_to_filter);
+
+ self.to_filter_channel.0.send(Some(filter_task)).unwrap();
+ }
+
+ Ok(())
+ }
+}
+
+/// Execute a spec, or a range of a spec.
+pub fn run(
+ spec: &Arc<Box<dyn Spec>>,
+ output_path: &str,
+ context: &Arc<Context>,
+ config: &Arc<Config>,
+ range: &Option<Range>,
+) -> Result<Stats, Error> {
+ if config.decoders > u16::MAX as usize {
+ // yes this is arbitrary, but bad things happen if do something like usize::MAX because we track counts with a i64 internally
+ return Err(Error::ConfigError(
+ "Decoders must be less than u16::MAX".to_string(),
+ ));
+ }
+
+ // Make sure the encoder config is valid
+ if let Some(enc_cfg) = &config.encoder {
+ let _avcodec: &ffi::AVCodec = enc_cfg.avcodec()?;
+ }
+
+ let stat = Arc::new(StatRunner::new());
+ let expected_output_type = config.expected_output_type();
+
+ let process_span = Arc::new(crate::sir::ProcessSpan::create(
+ spec.as_ref().as_ref(),
+ context,
+ range,
+ ));
+
+ // Type check frames
+ for oframe in &process_span.frames {
+ let frame_type = type_frame(context, config, oframe)?;
+ if frame_type != expected_output_type {
+ return Err(Error::InvalidOutputFrameType);
+ }
+ }
+
+ let (pool, output_time_base) = build_pool(&process_span, config, context)?;
+
+ let pool = Arc::new((Mutex::new(pool), Condvar::new()));
+
+ let decoder_count = Arc::new(AtomicI64::new(0));
+
+ let filtering_gens: BTreeSet<usize> = BTreeSet::new();
+ let encode_buffer = Arc::new((Mutex::new(EncodeBuffer::new()), Condvar::new()));
+ let dec_join_handles: BTreeMap<String, std::thread::JoinHandle<Result<(), Error>>> =
+ BTreeMap::new();
+ let filter_join_handles: Vec<std::thread::JoinHandle<Result<(), Error>>> = Vec::new();
+
+ let io_runtime = tokio::runtime::Builder::new_multi_thread()
+ .worker_threads(2.max(config.decoders.sqrt())) // guess a good number of threads to use for I/O
+ .enable_all()
+ .build()
+ .unwrap();
+
+ let exec_contex = ExecContext {
+ output_path: output_path.to_string(),
+ context: context.clone(),
+ config: config.clone(),
+ stat: stat.clone(),
+ process_span,
+ pool,
+ output_time_base,
+ to_filter_channel: crossbeam_channel::unbounded(),
+ from_filter_channel: crossbeam_channel::unbounded(),
+ decoder_count,
+ io_runtime,
+ filtering_gens,
+ frames_post_filtering: 0,
+ encode_buffer,
+ dec_join_handles,
+ filter_join_handles,
+ };
+
+ exec_contex.run()
+}
+
+/// Validate that a spec can be run.
+pub fn validate(
+ spec: &Arc<Box<dyn Spec>>,
+ context: &Arc<Context>,
+ config: &Arc<Config>,
+) -> Result<(), Error> {
+ let expected_output_type = config.expected_output_type();
+
+ let process_span = Arc::new(crate::sir::ProcessSpan::create(
+ spec.as_ref().as_ref(),
+ context,
+ &None,
+ ));
+
+ // Type check frames
+ for oframe in &process_span.frames {
+ let frame_type = type_frame(context, config, oframe)?;
+ if frame_type != expected_output_type {
+ return Err(Error::InvalidOutputFrameType);
+ }
+ }
+
+ Ok(())
+}
+
+fn encoder_thread(
+ config: Arc<Config>,
+ stat: Arc<StatRunner>,
+ output_time_base: num_rational::Ratio<i64>,
+ output_path: String,
+ process_span: Arc<sir::ProcessSpan>,
+ encode_buffer: Arc<(Mutex<EncodeBuffer>, Condvar)>,
+) -> Result<(), Error> {
+ let mut encoder = av::encoder::Encoder::new(&config, &output_time_base)?;
+
+ let mut encoder_codec_params = unsafe { ffi::avcodec_parameters_alloc() };
+ // copy from encoder context
+ if unsafe { ffi::avcodec_parameters_from_context(encoder_codec_params, encoder.codec_ctx) } < 0
+ {
+ return Err(Error::AVError(
+ "Encoder failed to copy codec params to codec context".to_string(),
+ ));
+ }
+
+ let mut muxer = av::muxer::Muxer::new(
+ &output_path,
+ encoder_codec_params,
+ &output_time_base,
+ config.format.as_deref(),
+ )?;
+ let muxer_time_base = crate::util::avrat_to_rat(&muxer.out_time_base);
+ let encoder_to_muxer_ts_multiplier: num_rational::Ratio<i64> =
+ encoder.time_base / muxer_time_base;
+
+ if *encoder_to_muxer_ts_multiplier.denom() != 1 {
+ return Err(Error::AVError(format!(
+ "Can't operate with encoder timebase {} and muxer timebase {}. Are you using mkv?",
+ encoder.time_base, muxer_time_base
+ )));
+ }
+
+ let mut oframe_next = 0;
+
+ loop {
+ // Encode frames
+ {
+ if oframe_next >= process_span.frames.len() {
+ break;
+ }
+
+ let mut encode_buffer_ref = encode_buffer.0.lock();
+
+ if encode_buffer_ref.terminate_encoder {
+ break;
+ }
+
+ let target_index = encode_buffer_ref
+ .members
+ .iter()
+ .position(|(gen, _)| *gen == oframe_next);
+
+ if let Some(target_index) = target_index {
+ let (gen, frame) = encode_buffer_ref.members.remove(target_index);
+
+ let pts = match process_span.output_ts_offset {
+ Some(offset) => process_span.ts[gen] - offset,
+ None => process_span.ts[gen],
+ };
+ encoder.encode(&pts, &frame)?;
+ oframe_next += 1;
+ } else {
+ encode_buffer.1.wait(&mut encode_buffer_ref);
+ continue;
+ }
+ }
+
+ // Mux frames
+ if let Some(packet) = encoder.get_packet() {
+ unsafe {
+ (*packet).pts *= *encoder_to_muxer_ts_multiplier.numer();
+ (*packet).dts *= *encoder_to_muxer_ts_multiplier.numer();
+ }
+
+ stat.frames_written
+ .fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+ muxer.mux_packet(packet)?;
+ }
+ }
+
+ encoder.flush()?;
+
+ // Mux frames
+ while let Some(packet) = encoder.get_packet() {
+ unsafe {
+ (*packet).pts *= *encoder_to_muxer_ts_multiplier.numer();
+ (*packet).dts *= *encoder_to_muxer_ts_multiplier.numer();
+ }
+
+ stat.frames_written
+ .fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+ muxer.mux_packet(packet)?;
+ }
+
+ encoder.close();
+ muxer.close()?;
+
+ unsafe {
+ ffi::avcodec_parameters_free(&mut encoder_codec_params);
+ }
+
+ Ok(())
+}
+
+fn build_pool(
+ process_span: &sir::ProcessSpan,
+ config: &Arc<Config>,
+ context: &Arc<Context>,
+) -> Result<(Pool, num_rational::Ratio<i64>), Error> {
+ let mut iframes_per_oframe: Vec<BTreeSet<IFrameRef>> =
+ Vec::<BTreeSet<IFrameRef>>::with_capacity(process_span.frames.len());
+ let mut iframe_refs_in_out_idx: BTreeMap<IFrameRef, BTreeSet<usize>> = BTreeMap::new();
+
+ for (oframe_i, oframe) in process_span.frames.iter().enumerate() {
+ let mut frame_deps = std::collections::BTreeSet::new();
+ oframe.add_deps(&mut frame_deps);
+ assert!(
+ frame_deps.len() <= config.decode_pool_size,
+ "OFrame {} has too many dependencies ({}) for decode pool size {}",
+ oframe_i,
+ frame_deps.len(),
+ config.decode_pool_size
+ );
+
+ let mut iframe_refs = BTreeSet::new();
+ for dep in &frame_deps {
+ let (source_ref, t) = context.resolve_frame_source(dep)?;
+
+ let iframe_ref = IFrameRef {
+ sourceref: source_ref.clone(),
+ pts: t,
+ };
+ iframe_refs.insert(iframe_ref.clone());
+
+ iframe_refs_in_out_idx
+ .entry(iframe_ref)
+ .or_default()
+ .insert(oframe_i);
+ }
+ iframes_per_oframe.push(iframe_refs);
+ }
+ debug_assert_eq!(iframes_per_oframe.len(), process_span.frames.len());
+
+ let output_time_base = {
+ let mut lcm = *process_span.ts[0].denom();
+ for t in &process_span.ts {
+ lcm = num::integer::lcm(lcm, *t.denom());
+ }
+ Rational64::new(1, lcm)
+ };
+
+ let pool = crate::pool::Pool::new(
+ iframes_per_oframe,
+ iframe_refs_in_out_idx,
+ context.clone(),
+ config.clone(),
+ )?;
+
+ Ok((pool, output_time_base))
+}
+
+/// Create [HLS](https://en.wikipedia.org/wiki/HTTP_Live_Streaming) artifacts for a spec
+///
+/// * `spec` - The spec to create HLS artifacts for
+/// * `host_prefix` - The prefix to use for the host (e.g., `https://example.com:8000`)
+/// * `context` - The context to use for the spec
+/// * `config` - The config to use for the spec
+///
+/// Returns a tuple of:
+/// * The namespace for the HLS artifacts
+/// * The text of the m3u8 playlist file
+/// * The text of the m3u8 stream file
+/// * A vector of tuples of the start and end timestamps of each segment
+pub fn create_spec_hls(
+ spec: &dyn Spec,
+ host_prefix: &str,
+ context: &Context,
+ _config: &Config,
+) -> (String, String, String, Vec<(Rational64, Rational64)>) {
+ let namespace = crate::util::rand_uuid().to_string();
+
+ let _playlist_path = format!("{namespace}/playlist.m3u8");
+ let playlist_text = format!(
+ "#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=640000\n{}/{}/stream.m3u8\n",
+ host_prefix, namespace
+ );
+
+ let stream_ts = sir::spec_domain(spec, context);
+ let frame_rate = crate::spec::get_framerate(spec);
+ let segment_duration = 2;
+
+ let mut stream_text = format!("#EXTM3U\n#EXT-X-PLAYLIST-TYPE:VOD\n#EXT-X-TARGETDURATION:{segment_duration}\n#EXT-X-VERSION:4\n#EXT-X-MEDIA-SEQUENCE:0\n");
+ let mut ranges = Vec::new();
+
+ // todo fix off-by-one error
+ for segment_id in 0..=(stream_ts.len() - 1) / (frame_rate * segment_duration) {
+ let stream_ts_path = format!("segment-{segment_id}.ts");
+ stream_text +=
+ &format!("#EXTINF:{segment_duration}.0,\n{host_prefix}/{namespace}/{stream_ts_path}\n");
+
+ let range_start = stream_ts[segment_id * frame_rate * segment_duration];
+ let range_end = if (segment_id + 1) * frame_rate * segment_duration - 1 < stream_ts.len() {
+ stream_ts[(segment_id + 1) * frame_rate * segment_duration - 1]
+ } else {
+ stream_ts[stream_ts.len() - 1]
+ };
+
+ ranges.push((range_start, range_end));
+ }
+
+ stream_text += "#EXT-X-ENDLIST\n";
+ let _stream_path = format!("{namespace}/stream.m3u8");
+
+ (namespace, playlist_text, stream_text, ranges)
+}
+vidformer/filter.rs
+1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340
//! Filters create and transform video frames
+//!
+//! A filter is a function that takes some inputs and returns a video frame.
+//! For example a filter could blur an input: `MyBlur(frame, amount=5)`.
+
+use crate::dve::AVFrame;
+use opencv::prelude::MatTraitConst;
+use rusty_ffmpeg::ffi;
+use serde::ser::SerializeMap;
+use serde::Deserialize;
+use std::collections::BTreeMap;
+use std::sync::Arc;
+
+pub mod builtin;
+pub mod cv2;
+mod filter_utils;
+
+/// A decoded video frame
+#[derive(Clone)]
+pub struct Frame {
+ inner: Arc<AVFrame>,
+ pub width: i32,
+ pub height: i32,
+ pub format: ffi::AVPixelFormat,
+}
+
+impl serde::Serialize for Frame {
+ fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+ let mut map = serializer.serialize_map(Some(4))?;
+ map.serialize_entry("width", &self.width)?;
+ map.serialize_entry("height", &self.height)?;
+
+ let pix_format_name = crate::util::pixel_fmt_str(self.format);
+ map.serialize_entry("format", pix_format_name)?;
+
+ let av_frame: ffi::AVFrame = unsafe { *self.inner.inner };
+ let frame_encoded_size_all_planes =
+ unsafe { ffi::av_image_get_buffer_size(self.format, self.width, self.height, 1) };
+
+ let frame_buffer = vec![0u8; frame_encoded_size_all_planes as usize];
+ let frame_buffer_ptr = frame_buffer.as_ptr() as *mut u8;
+
+ // Copy the frame data to the buffer
+ unsafe {
+ ffi::av_image_copy_to_buffer(
+ frame_buffer_ptr,
+ frame_encoded_size_all_planes,
+ av_frame.data.as_ptr() as *const *const u8,
+ av_frame.linesize.as_ptr(),
+ self.format,
+ self.width,
+ self.height,
+ 1,
+ );
+ }
+
+ let frame_buffer = serde_bytes::Bytes::new(&frame_buffer);
+ map.serialize_entry("data", &frame_buffer)?;
+ map.end()
+ }
+}
+
+impl<'de> Deserialize<'de> for Frame {
+ fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+ struct FrameVisitor;
+
+ impl<'de> serde::de::Visitor<'de> for FrameVisitor {
+ type Value = Frame;
+
+ fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+ formatter.write_str("a frame")
+ }
+
+ fn visit_map<A: serde::de::MapAccess<'de>>(
+ self,
+ mut map: A,
+ ) -> Result<Self::Value, A::Error> {
+ let mut width = None;
+ let mut height = None;
+ let mut format = None;
+ let mut data = None;
+
+ while let Some(key) = map.next_key()? {
+ match key {
+ "width" => {
+ if width.is_some() {
+ return Err(serde::de::Error::duplicate_field("width"));
+ }
+ width = Some(map.next_value()?);
+ }
+ "height" => {
+ if height.is_some() {
+ return Err(serde::de::Error::duplicate_field("height"));
+ }
+ height = Some(map.next_value()?);
+ }
+ "format" => {
+ if format.is_some() {
+ return Err(serde::de::Error::duplicate_field("format"));
+ }
+ format = Some(map.next_value()?);
+ }
+ "data" => {
+ if data.is_some() {
+ return Err(serde::de::Error::duplicate_field("data"));
+ }
+ data = Some(map.next_value()?);
+ }
+ _ => {
+ return Err(serde::de::Error::unknown_field(
+ key,
+ &["width", "height", "format", "data"],
+ ));
+ }
+ }
+ }
+
+ let width: i32 = width.ok_or_else(|| serde::de::Error::missing_field("width"))?;
+ let height: i32 =
+ height.ok_or_else(|| serde::de::Error::missing_field("height"))?;
+ let format_str: &str =
+ format.ok_or_else(|| serde::de::Error::missing_field("format"))?;
+
+ let fmt_cstr = std::ffi::CString::new(format_str).unwrap();
+
+ let format = unsafe { ffi::av_get_pix_fmt(fmt_cstr.as_ptr()) };
+ if format == ffi::AVPixelFormat_AV_PIX_FMT_NONE {
+ return Err(serde::de::Error::custom(format!(
+ "Invalid pixel format {:?}",
+ format_str
+ )));
+ }
+
+ let data: serde_bytes::ByteBuf =
+ data.ok_or_else(|| serde::de::Error::missing_field("data"))?;
+ let data = data.into_vec();
+
+ // Check we got the right amount of data
+ let frame_encoded_size_all_planes = unsafe {
+ ffi::av_image_get_buffer_size(format as ffi::AVPixelFormat, width, height, 1)
+ };
+ if data.len() != frame_encoded_size_all_planes as usize {
+ return Err(serde::de::Error::custom(format!(
+ "IPC frame data length ({}) does not match expected size ({})",
+ data.len(),
+ frame_encoded_size_all_planes
+ )));
+ }
+
+ if data.len() != frame_encoded_size_all_planes as usize {
+ return Err(serde::de::Error::custom(
+ "Data length does not match frame size",
+ ));
+ }
+
+ let av_frame = unsafe { ffi::av_frame_alloc() };
+ if av_frame.is_null() {
+ return Err(serde::de::Error::custom("Failed to allocate frame"));
+ }
+
+ unsafe {
+ (*av_frame).width = width;
+ (*av_frame).height = height;
+ (*av_frame).format = format;
+ };
+
+ // alloc frame buffer
+ let ret = unsafe { ffi::av_frame_get_buffer(av_frame, 0) };
+ if ret < 0 {
+ return Err(serde::de::Error::custom("Failed to allocate frame buffer"));
+ }
+
+ // Copy the data to the frame
+ let num_planes =
+ unsafe { ffi::av_pix_fmt_count_planes(format as ffi::AVPixelFormat) };
+ if num_planes < 0 {
+ return Err(serde::de::Error::custom("Failed to get number of planes"));
+ }
+
+ let mut data_offset = 0;
+ for plane in 0..num_planes {
+ let plane_size = unsafe { (*av_frame).linesize[plane as usize] * height };
+ unsafe {
+ std::ptr::copy_nonoverlapping(
+ // TODO: check linesize[0]
+ data.as_ptr().add(data_offset),
+ (*av_frame).data[plane as usize],
+ plane_size as usize,
+ );
+ }
+ data_offset += plane_size as usize;
+ }
+
+ let frame = AVFrame { inner: av_frame };
+
+ Ok(Frame::new(frame))
+ }
+ }
+
+ deserializer.deserialize_map(FrameVisitor)
+ }
+}
+
+impl Frame {
+ pub(crate) fn new(inner: AVFrame) -> Self {
+ let width = unsafe { (*inner.inner).width };
+ let height = unsafe { (*inner.inner).height };
+ let format = unsafe { (*inner.inner).format };
+ Frame {
+ inner: Arc::new(inner),
+ width,
+ height,
+ format,
+ }
+ }
+
+ pub(crate) fn new_arc(inner: Arc<AVFrame>) -> Self {
+ let width = unsafe { (*inner.inner).width };
+ let height = unsafe { (*inner.inner).height };
+ let format = unsafe { (*inner.inner).format };
+ Frame {
+ inner,
+ width,
+ height,
+ format,
+ }
+ }
+
+ pub(crate) fn inner(&self) -> *mut ffi::AVFrame {
+ self.inner.inner
+ }
+
+ pub(crate) fn into_avframe(self) -> Arc<AVFrame> {
+ self.inner
+ }
+}
+
+impl std::fmt::Debug for Frame {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ f.debug_struct("Frame")
+ .field("width", &self.width)
+ .field("height", &self.height)
+ .field("format", &self.format)
+ .finish()
+ }
+}
+
+/// A value that can be passed to a filter
+///
+/// This can be a either a video frame or a conventional data value
+#[derive(Debug, Clone, serde::Serialize)]
+pub enum Val {
+ Frame(Frame),
+ FrameType(FrameType),
+ Bool(bool),
+ Int(i64),
+ String(String),
+ Bytes(Vec<u8>),
+ Float(f64),
+ List(Vec<Val>),
+}
+
+#[derive(PartialEq, Eq, Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct FrameType {
+ pub width: usize,
+ pub height: usize,
+ pub format: ffi::AVPixelFormat,
+}
+
+impl FrameType {
+ pub fn new(width: usize, height: usize, format: ffi::AVPixelFormat) -> Self {
+ FrameType {
+ width,
+ height,
+ format,
+ }
+ }
+}
+
+impl Val {
+ pub fn from_expr(expr: &crate::sir::DataExpr, context: &crate::dve::Context) -> Self {
+ match expr {
+ crate::sir::DataExpr::Bool(b) => Val::Bool(*b),
+ crate::sir::DataExpr::Int(i) => Val::Int(*i),
+ crate::sir::DataExpr::String(s) => Val::String(s.to_string()),
+ crate::sir::DataExpr::Bytes(b) => Val::Bytes(b.clone()),
+ crate::sir::DataExpr::Float(f) => Val::Float(*f),
+ crate::sir::DataExpr::ArrayRef(name, crate::sir::IndexConst::ILoc(idx)) => {
+ let array = &context.arrays[name];
+ let val = array.index(*idx);
+ Val::from_expr(&val, context)
+ }
+ crate::sir::DataExpr::ArrayRef(name, crate::sir::IndexConst::T(t)) => {
+ let array = &context.arrays[name];
+ let val = array.index_t(*t);
+ Val::from_expr(&val, context)
+ }
+ crate::sir::DataExpr::List(list) => {
+ let list = list
+ .iter()
+ .map(|expr| Val::from_expr(expr, context))
+ .collect();
+ Val::List(list)
+ }
+ }
+ }
+
+ pub(crate) fn as_int(&self) -> Option<i64> {
+ match self {
+ Val::Int(i) => Some(*i),
+ _ => None,
+ }
+ }
+
+ pub(crate) fn as_frame_type(&self) -> Option<&FrameType> {
+ match self {
+ Val::FrameType(frame_type) => Some(frame_type),
+ _ => None,
+ }
+ }
+}
+
+/// A filter that can create a video frame from some inputs
+pub trait Filter: Send + Sync {
+ /// Creates a video frame from some inputs
+ ///
+ /// The inputs are arbitrary and user provided. An input can either be
+ /// ordered (arg) or named (kwargs). This is similar to Python function calls.
+ fn filter(
+ &self,
+ args: &[Val],
+ kwargs: &BTreeMap<String, Val>,
+ ) -> Result<Frame, crate::dve::Error>;
+
+ fn filter_type(
+ &self,
+ args: &[Val],
+ kwargs: &BTreeMap<String, Val>,
+ ) -> Result<FrameType, crate::dve::Error>;
+}
+vidformer/filter/builtin.rs
+1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +441 +442 +443 +444 +445 +446 +447 +448 +449 +450 +451 +452 +453 +454 +455 +456 +457 +458 +459 +460 +461 +462 +463 +464 +465 +466 +467 +468 +469 +470 +471 +472 +473 +474 +475 +476 +477 +478 +479 +480 +481 +482 +483 +484 +485 +486 +487 +488 +489 +490 +491 +492 +493 +494 +495 +496 +497 +498 +499 +500 +501 +502 +503 +504 +505 +506 +507 +508 +509 +510 +511 +512 +513 +514 +515 +516 +517 +518 +519 +520 +521 +522 +523 +524 +525 +526 +527 +528 +529 +530 +531 +532 +533 +534 +535 +536 +537 +538 +539 +540 +541 +542 +543 +544 +545 +546 +547 +548 +549 +550 +551 +552 +553 +554 +555 +556 +557 +558 +559 +560 +561 +562 +563 +564 +565 +566 +567 +568 +569 +570 +571 +572 +573 +574 +575 +576 +577 +578 +579 +580 +581 +582 +583 +584 +585 +586 +587 +588 +589 +590 +591 +592 +593 +594 +595 +596 +597 +598 +599 +600 +601 +602 +603 +604 +605 +606 +607 +608 +609 +610 +611 +612 +613 +614 +615 +616 +617 +618 +619 +620 +621 +622 +623 +624 +625 +626 +627 +628 +629 +630 +631 +632 +633 +634 +635 +636 +637 +638 +639 +640 +641 +642 +643 +644 +645 +646 +647 +648 +649 +650 +651 +652 +653 +654 +655 +656 +657 +658 +659 +660 +661 +662 +663 +664 +665 +666 +667 +668 +669 +670 +671 +672 +673 +674 +675 +676 +677 +678 +679 +680 +681 +682 +683 +684 +685 +686 +687 +688 +689 +690 +691 +692 +693 +694 +695 +696 +697 +698 +699 +700 +701 +702 +703 +704 +705 +706 +707 +708 +709 +710 +711 +712 +713 +714 +715 +716 +717 +718 +719 +720 +721 +722 +723 +724 +725 +726 +727 +728 +729 +730 +731 +732 +733 +734 +735 +736 +737 +738 +739 +740 +741 +742 +743 +744 +745 +746 +747 +748 +749 +750 +751 +752 +753 +754 +755 +756 +757 +758 +759 +760 +761 +762 +763 +764 +765 +766 +767 +768 +769 +770 +771 +772 +773 +774 +775 +776 +777 +778 +779 +780 +781 +782 +783 +784 +785 +786 +787 +788 +789 +790 +791 +792 +793 +794 +795 +796 +797 +798 +799 +800 +801 +802 +803 +804 +805 +806 +807 +808 +809 +810 +811 +812 +813 +814 +815 +816 +817 +818 +819 +820 +821 +822 +823 +824 +825 +826 +827 +828 +829 +830 +831 +832 +833 +834 +835 +836 +837 +838 +839 +840 +841 +842 +843 +844 +845 +846 +847 +848 +849 +850 +851 +852 +853 +854 +855 +856 +857 +858 +859 +860 +861 +862 +863 +864 +865 +866 +867 +868 +869 +870 +871 +872 +873 +874 +875 +876 +877 +878 +879 +880 +881 +882 +883 +884 +885 +886 +887 +888 +889 +890 +891 +892 +893 +894 +895 +896 +897 +898 +899 +900 +901 +902 +903 +904 +905 +906 +907 +908 +909 +910 +911 +912 +913 +914 +915 +916 +917 +918 +919 +920 +921 +922 +923 +924 +925 +926 +927 +928 +929 +930 +931 +932 +933 +934 +935 +936 +937 +938 +939 +940 +941 +942 +943 +944 +945 +946 +947 +948 +949 +950 +951 +952 +953 +954 +955 +956 +957 +958 +959 +960 +961 +962 +963 +964 +965 +966 +967 +968 +969 +970 +971 +972 +973 +974 +975 +976 +977 +978 +979 +980 +981 +982 +983 +984 +985 +986 +987 +988 +989 +990 +991 +992 +993 +994 +995 +996 +997 +998 +999 +1000 +1001 +1002 +1003 +1004 +1005 +1006 +1007 +1008 +1009 +1010 +1011 +1012 +1013 +1014 +1015 +1016 +1017 +1018 +1019 +1020 +1021 +1022 +1023 +1024 +1025 +1026 +1027 +1028 +1029 +1030 +1031 +1032 +1033 +1034 +1035 +1036 +1037 +1038 +1039 +1040 +1041 +1042 +1043 +1044 +1045 +1046 +1047 +1048 +1049 +1050 +1051 +1052 +1053 +1054 +1055 +1056 +1057 +1058 +1059 +1060 +1061 +1062 +1063 +1064 +1065 +1066 +1067 +1068 +1069 +1070 +1071 +1072 +1073 +1074 +1075 +1076 +1077 +1078 +1079 +1080 +1081 +1082 +1083 +1084 +1085 +1086 +1087 +1088 +1089 +1090 +1091 +1092 +1093 +1094 +1095 +1096 +1097 +1098 +1099 +1100 +1101 +1102 +1103 +1104 +1105 +1106 +1107 +1108 +1109 +1110 +1111 +1112 +1113 +1114 +1115 +1116 +1117 +1118 +1119 +1120 +1121 +1122 +1123 +1124 +1125 +1126 +1127 +1128 +1129 +1130 +1131 +1132 +1133 +1134 +1135 +1136 +1137 +1138 +1139 +1140 +1141 +1142 +1143 +1144 +1145 +1146 +1147 +1148 +1149 +1150 +1151 +1152 +1153 +1154 +1155 +1156 +1157 +1158 +1159 +1160 +1161 +1162 +1163 +1164 +1165 +1166 +1167 +1168 +1169 +1170 +1171 +1172 +1173 +1174 +1175 +1176 +1177 +1178 +1179 +1180 +1181 +1182 +1183 +1184 +1185 +1186 +1187 +1188 +1189 +1190 +1191 +1192 +1193 +1194 +1195 +1196 +1197 +1198 +1199 +1200 +1201 +1202 +1203 +1204 +1205 +1206 +1207 +1208 +1209 +1210 +1211 +1212 +1213 +1214 +1215 +1216 +1217 +1218 +1219 +1220 +1221 +1222 +1223 +1224 +1225 +1226 +1227 +1228 +1229 +1230 +1231 +1232 +1233 +1234 +1235 +1236 +1237 +1238 +1239 +1240 +1241 +1242 +1243 +1244 +1245 +1246 +1247 +1248 +1249 +1250 +1251 +1252 +1253 +1254 +1255 +1256 +1257 +1258 +1259 +1260 +1261 +1262 +1263 +1264 +1265 +1266 +1267 +1268 +1269 +1270 +1271 +1272 +1273 +1274 +1275 +1276 +1277 +1278 +1279 +1280 +1281 +1282 +1283 +1284 +1285 +1286 +1287 +1288 +1289 +1290 +1291 +1292 +1293 +1294 +1295 +1296 +1297 +1298 +1299 +1300 +1301 +1302 +1303 +1304 +1305 +1306 +1307 +1308 +1309 +1310 +1311 +1312 +1313 +1314 +1315 +1316 +1317 +1318 +1319 +1320 +1321 +1322 +1323 +1324 +1325 +1326 +1327 +1328 +1329 +1330 +1331 +1332 +1333 +1334 +1335 +1336 +1337 +1338 +1339 +1340 +1341 +1342 +1343 +1344 +1345 +1346 +1347 +1348 +1349 +1350 +1351 +1352 +1353 +1354 +1355 +1356 +1357 +1358 +1359 +1360 +1361 +1362 +1363 +1364 +1365 +1366 +1367 +1368 +1369 +1370 +1371 +1372 +1373 +1374 +1375 +1376 +1377 +1378 +1379 +1380 +1381 +1382 +1383 +1384 +1385 +1386 +1387 +1388 +1389 +1390 +1391 +1392 +1393 +1394 +1395 +1396 +1397 +1398 +1399 +1400 +1401 +1402 +1403 +1404 +1405 +1406 +1407 +1408 +1409 +1410 +1411 +1412 +1413 +1414 +1415 +1416 +1417 +1418 +1419 +1420 +1421 +1422 +1423 +1424 +1425 +1426 +1427 +1428 +1429 +1430 +1431 +1432 +1433 +1434 +1435 +1436 +1437 +1438 +1439 +1440 +1441 +1442 +1443 +1444 +1445 +1446 +1447 +1448 +1449 +1450 +1451 +1452 +1453 +1454 +1455 +1456 +1457 +1458 +1459 +1460 +1461 +1462 +1463 +1464 +1465 +1466 +1467 +1468 +1469 +1470 +1471 +1472 +1473 +1474 +1475 +1476 +1477 +1478 +1479 +1480 +1481 +1482 +1483 +1484 +1485 +1486 +1487 +1488 +1489 +1490 +1491 +1492 +1493 +1494 +1495 +1496 +1497 +1498 +1499 +1500 +1501 +1502 +1503 +1504 +1505 +1506 +1507 +1508 +1509 +1510 +1511 +1512 +1513 +1514 +1515 +1516 +1517 +1518 +1519 +1520 +1521 +1522 +1523 +1524 +1525 +1526 +1527 +1528 +1529 +1530 +1531 +1532 +1533 +1534 +1535 +1536 +1537 +1538 +1539 +1540 +1541 +1542 +1543 +1544 +1545 +1546 +1547 +1548 +1549 +1550 +1551 +1552 +1553 +1554 +1555 +1556 +1557 +1558 +1559 +1560 +1561 +1562 +1563 +1564 +1565 +1566 +1567 +1568 +1569 +1570 +1571 +1572 +1573 +1574 +1575 +1576 +1577 +1578 +1579 +1580 +1581 +1582 +1583 +1584 +1585 +1586 +1587 +1588 +1589 +1590 +1591 +1592 +1593 +1594 +1595 +1596 +1597 +1598 +1599 +1600 +1601 +1602 +1603 +1604 +1605 +1606 +1607 +1608 +1609 +1610 +1611 +1612 +1613 +1614 +1615 +1616 +1617 +1618 +1619 +1620 +1621 +1622 +1623 +1624 +1625 +1626 +1627 +1628 +1629 +1630 +1631 +1632 +1633 +1634 +1635 +1636 +1637 +1638 +1639 +1640 +1641 +1642 +1643 +1644 +1645 +1646 +1647 +1648 +1649 +1650 +1651 +1652 +1653 +1654 +1655 +1656 +1657 +1658 +1659 +1660 +1661 +1662 +1663 +1664 +1665 +1666 +1667 +1668 +1669 +1670 +1671 +1672 +1673 +1674 +1675 +1676 +1677 +1678 +1679 +1680 +1681 +1682 +1683 +1684 +1685 +1686 +1687 +1688 +1689 +1690 +1691 +1692 +1693 +1694 +1695 +1696 +1697 +1698 +1699 +1700 +1701 +1702 +1703 +1704 +1705 +1706 +1707 +1708 +1709 +1710 +1711 +1712 +1713 +1714 +1715 +1716 +1717 +1718 +1719 +1720 +1721 +1722 +1723 +1724 +1725 +1726 +1727 +1728 +1729 +1730 +1731 +1732 +1733 +1734 +1735 +1736 +1737 +1738 +1739 +1740 +1741 +1742 +1743 +1744 +1745 +1746 +1747 +1748 +1749 +1750 +1751 +1752 +1753 +1754 +1755 +1756 +1757 +1758 +1759 +1760 +1761 +1762 +1763 +1764 +1765 +1766 +1767 +1768 +1769 +1770 +1771 +1772 +1773 +1774 +1775 +1776 +1777 +1778 +1779 +1780 +1781 +1782 +1783 +1784 +1785 +1786 +1787 +1788 +1789 +1790 +1791 +1792 +1793 +1794 +1795 +1796 +1797 +1798 +1799 +1800 +1801 +1802 +1803 +1804 +1805 +1806 +1807 +1808 +1809 +1810 +1811 +1812 +1813 +1814 +1815 +1816 +1817 +1818 +1819 +1820 +1821 +1822 +1823 +1824 +1825 +1826 +1827 +1828 +1829 +1830 +1831 +1832 +1833 +1834 +1835 +1836 +1837 +1838 +1839 +1840 +1841 +1842 +1843 +1844 +1845 +1846 +1847 +1848 +1849 +1850 +1851 +1852 +1853 +1854 +1855 +1856 +1857 +1858 +1859 +1860 +1861 +1862 +1863 +1864 +1865 +1866 +1867 +1868 +1869 +1870 +1871 +1872 +1873 +1874 +1875 +1876 +1877 +1878 +1879 +1880 +1881 +1882 +1883 +1884 +1885 +1886 +1887 +1888 +1889 +1890 +1891 +1892 +1893 +1894 +1895 +1896 +1897 +1898 +1899 +1900 +1901 +1902 +1903 +1904 +1905 +1906 +1907 +1908 +1909 +1910 +1911 +1912 +1913 +1914 +1915 +1916 +1917 +1918 +1919 +1920 +1921 +1922 +1923 +1924 +1925 +1926 +1927 +1928 +1929 +1930 +1931 +1932 +1933 +1934 +1935 +1936 +1937 +1938 +1939 +1940 +1941 +1942 +1943 +1944 +1945 +1946 +1947 +1948 +1949 +1950 +1951 +1952 +1953 +1954 +1955 +1956 +1957 +1958 +1959 +1960 +1961 +1962 +1963 +1964 +1965 +1966 +1967 +1968 +1969
//! vidformer built-in filters
+
+use crate::dve::AVFrame;
+use crate::dve::Error;
+use crate::filter::*;
+use opencv::core::*;
+use opencv::imgproc;
+use rusty_ffmpeg::ffi;
+use std::collections::BTreeMap;
+use std::ffi::CString;
+use std::ptr;
+use std::sync::Arc;
+
+mod drawutils;
+mod ipc;
+pub use ipc::IPC;
+
+/// vidformer built-in filters
+pub fn filters() -> BTreeMap<String, std::boxed::Box<dyn Filter>> {
+ let mut filters: BTreeMap<String, std::boxed::Box<dyn Filter>> = BTreeMap::new();
+ filters.insert(
+ "PlaceholderFrame".to_string(),
+ std::boxed::Box::new(PlaceholderFrame {}),
+ );
+ filters.insert("Annotate".to_string(), std::boxed::Box::new(Annotate {}));
+ filters.insert("Box".to_string(), std::boxed::Box::new(Box {}));
+ filters.insert(
+ "BoundingBox".to_string(),
+ std::boxed::Box::new(BoundingBox {}),
+ );
+ filters.insert("DrawBox".to_string(), std::boxed::Box::new(DrawBox {}));
+ filters.insert("Scale".to_string(), std::boxed::Box::new(Scale {}));
+ filters.insert(
+ "_inline_mat".to_string(),
+ std::boxed::Box::new(InlineMat {}),
+ );
+ filters.insert("_slice_mat".to_string(), std::boxed::Box::new(SliceMat {}));
+ filters.insert(
+ "_slice_write_mat".to_string(),
+ std::boxed::Box::new(SliceWriteMat {}),
+ );
+ filters.insert("Pad".to_string(), std::boxed::Box::new(Pad {}));
+ filters.insert("HStack".to_string(), std::boxed::Box::new(HStack {}));
+ filters.insert("VStack".to_string(), std::boxed::Box::new(VStack {}));
+ filters.insert("DrawText".to_string(), std::boxed::Box::new(DrawText {}));
+
+ filters
+}
+
+fn avfilter_backed_uniframe(
+ frame: &Arc<AVFrame>,
+ filter: &str,
+) -> Result<Frame, crate::dve::Error> {
+ let buffer_str = CString::new("buffer").unwrap();
+ let buffersink_str = CString::new("buffersink").unwrap();
+
+ let buffersrc = unsafe { rusty_ffmpeg::ffi::avfilter_get_by_name(buffer_str.as_ptr()) };
+ let buffersink = unsafe { rusty_ffmpeg::ffi::avfilter_get_by_name(buffersink_str.as_ptr()) };
+ let mut outputs = unsafe { rusty_ffmpeg::ffi::avfilter_inout_alloc() };
+ if outputs.is_null() {
+ panic!("ERROR could not allocate output");
+ }
+ let mut inputs = unsafe { rusty_ffmpeg::ffi::avfilter_inout_alloc() };
+ if inputs.is_null() {
+ panic!("ERROR could not allocate input");
+ }
+
+ let args: CString = CString::new(format!(
+ "video_size={}x{}:pix_fmt={}:time_base={}/{}:pixel_aspect={}/{}",
+ unsafe { (*frame.inner).width },
+ unsafe { (*frame.inner).height },
+ unsafe { (*frame.inner).format },
+ 1, // time base doesn't matter since we're doing single-frame filters only
+ 12288,
+ unsafe { (*frame.inner).sample_aspect_ratio.num },
+ unsafe { (*frame.inner).sample_aspect_ratio.den }
+ ))
+ .unwrap();
+
+ let mut filter_graph = unsafe { rusty_ffmpeg::ffi::avfilter_graph_alloc() };
+ if filter_graph.is_null() {
+ panic!("ERROR could not allocate filter graph");
+ }
+ unsafe {
+ (*filter_graph).nb_threads = 1;
+ }
+
+ let mut buffersrc_ctx: *mut ffi::AVFilterContext = ptr::null_mut();
+
+ let in_str = CString::new("in").unwrap();
+ if unsafe {
+ ffi::avfilter_graph_create_filter(
+ &mut buffersrc_ctx,
+ buffersrc,
+ in_str.as_ptr(),
+ args.as_ptr(),
+ std::ptr::null_mut(),
+ filter_graph,
+ )
+ } < 0
+ {
+ panic!("ERROR could not create buffer source");
+ }
+
+ let mut buffersink_ctx: *mut ffi::AVFilterContext = ptr::null_mut();
+ let out_str = CString::new("out").unwrap();
+ if unsafe {
+ ffi::avfilter_graph_create_filter(
+ &mut buffersink_ctx,
+ buffersink,
+ out_str.as_ptr(),
+ std::ptr::null(),
+ std::ptr::null_mut(),
+ filter_graph,
+ )
+ } < 0
+ {
+ panic!("ERROR could not create buffer sink");
+ }
+
+ unsafe {
+ (*outputs).name = CString::new("in").unwrap().into_raw();
+ (*outputs).filter_ctx = buffersrc_ctx;
+ (*outputs).pad_idx = 0;
+ (*outputs).next = std::ptr::null_mut();
+
+ (*inputs).name = CString::new("out").unwrap().into_raw();
+ (*inputs).filter_ctx = buffersink_ctx;
+ (*inputs).pad_idx = 0;
+ (*inputs).next = std::ptr::null_mut();
+ }
+
+ let filter_cstr = CString::new(filter).unwrap();
+ if unsafe {
+ ffi::avfilter_graph_parse_ptr(
+ filter_graph,
+ filter_cstr.as_ptr(),
+ &mut inputs,
+ &mut outputs,
+ std::ptr::null_mut(),
+ )
+ } < 0
+ {
+ panic!("ERROR could not parse filter graph");
+ }
+
+ if unsafe { ffi::avfilter_graph_config(filter_graph, std::ptr::null_mut()) } < 0 {
+ panic!("ERROR could not configure filter graph");
+ }
+
+ // clone frame just in case something mutates it
+ let mut f = unsafe { ffi::av_frame_alloc() };
+ if f.is_null() {
+ panic!("ERROR could not allocate frame");
+ }
+
+ unsafe {
+ (*f).width = (*frame.inner).width;
+ (*f).height = (*frame.inner).height;
+ (*f).format = ffi::AVPixelFormat_AV_PIX_FMT_YUV420P;
+
+ if ffi::av_frame_get_buffer(f, 0) < 0 {
+ panic!(
+ "ERROR could not allocate frame data buffer ({}x{}, {})",
+ (*f).width,
+ (*f).height,
+ (*f).format
+ );
+ }
+ }
+ if unsafe { ffi::av_frame_copy(f, frame.inner) } < 0 {
+ panic!("ERROR could not copy frame data");
+ }
+
+ if unsafe { ffi::av_buffersrc_add_frame_flags(buffersrc_ctx, f, 0) } < 0 {
+ panic!("ERROR could not add frame to buffer source");
+ }
+
+ let filtered_frame = unsafe { ffi::av_frame_alloc() };
+ if filtered_frame.is_null() {
+ panic!("ERROR could not allocate filtered frame");
+ }
+ if unsafe { ffi::av_buffersink_get_frame(buffersink_ctx, filtered_frame) } < 0 {
+ panic!("ERROR could not get frame from buffer sink");
+ }
+
+ let filtered_frame = AVFrame {
+ inner: filtered_frame,
+ };
+
+ unsafe {
+ ffi::av_frame_free(&mut f);
+ ffi::avfilter_inout_free(&mut inputs);
+ ffi::avfilter_inout_free(&mut outputs);
+ ffi::avfilter_graph_free(&mut filter_graph);
+ }
+
+ Ok(Frame::new(filtered_frame))
+}
+
+fn opencv_backed_uniframe<F>(input_frame: &Frame, filter: F) -> Result<Frame, crate::dve::Error>
+where
+ F: FnOnce(&mut Mat),
+{
+ let width = input_frame.width;
+ let height = input_frame.height;
+
+ let data_y = unsafe {
+ std::slice::from_raw_parts(
+ (*input_frame.inner.inner).data[0],
+ (*input_frame.inner.inner).linesize[0] as usize * height as usize,
+ )
+ };
+
+ let data_u = unsafe {
+ std::slice::from_raw_parts(
+ (*input_frame.inner.inner).data[1],
+ (*input_frame.inner.inner).linesize[1] as usize * height as usize / 2,
+ )
+ };
+
+ let data_v = unsafe {
+ std::slice::from_raw_parts(
+ (*input_frame.inner.inner).data[2],
+ (*input_frame.inner.inner).linesize[2] as usize * height as usize / 2,
+ )
+ };
+
+ let mut yuv_data = vec![
+ 0;
+ height as usize * width as usize
+ + 2 * (height as usize / 2) * (width as usize / 2)
+ ];
+ yuv_data[..(height as usize * width as usize)].copy_from_slice(data_y);
+ yuv_data[(height as usize * width as usize)
+ ..(height as usize * width as usize + (height as usize / 2) * (width as usize / 2))]
+ .copy_from_slice(data_u);
+ yuv_data[(height as usize * width as usize + (height as usize / 2) * (width as usize / 2))..]
+ .copy_from_slice(data_v);
+
+ let mut yuv_mat =
+ Mat::new_rows_cols_with_data_mut(height + height / 2, width, &mut yuv_data).unwrap();
+ let mut bgr_mat = unsafe { Mat::new_size(Size::new(width, height), CV_8UC3).unwrap() };
+ imgproc::cvt_color(&yuv_mat, &mut bgr_mat, imgproc::COLOR_YUV2BGR_I420, 0).unwrap();
+
+ // draw bounding boxes
+
+ filter(&mut bgr_mat);
+
+ // convert back to yuv
+ imgproc::cvt_color(&bgr_mat, &mut yuv_mat, imgproc::COLOR_BGR2YUV_I420, 0).unwrap();
+
+ let f = unsafe { ffi::av_frame_alloc() };
+ unsafe {
+ (*f).width = width;
+ (*f).height = height;
+ (*f).format = ffi::AVPixelFormat_AV_PIX_FMT_YUV420P;
+
+ if ffi::av_frame_get_buffer(f, 0) < 0 {
+ panic!("ERROR could not allocate frame data");
+ }
+ }
+
+ // copy data
+ let data_y = unsafe {
+ std::slice::from_raw_parts_mut((*f).data[0], (*f).linesize[0] as usize * height as usize)
+ };
+ let data_u = unsafe {
+ std::slice::from_raw_parts_mut(
+ (*f).data[1],
+ (*f).linesize[1] as usize * height as usize / 2,
+ )
+ };
+ let data_v = unsafe {
+ std::slice::from_raw_parts_mut(
+ (*f).data[2],
+ (*f).linesize[2] as usize * height as usize / 2,
+ )
+ };
+
+ data_y.copy_from_slice(&yuv_data[..(height as usize * width as usize)]);
+ data_u.copy_from_slice(
+ &yuv_data[(height as usize * width as usize)
+ ..(height as usize * width as usize + (height as usize / 2) * (width as usize / 2))],
+ );
+ data_v.copy_from_slice(
+ &yuv_data
+ [(height as usize * width as usize + (height as usize / 2) * (width as usize / 2))..],
+ );
+
+ Ok(Frame::new(AVFrame { inner: f }))
+}
+
+pub struct PlaceholderFrame {}
+impl super::Filter for PlaceholderFrame {
+ fn filter(
+ &self,
+ _args: &[Val],
+ kwargs: &BTreeMap<String, Val>,
+ ) -> Result<Frame, crate::dve::Error> {
+ let width = kwargs.get("width").unwrap().as_int().unwrap();
+ let height: i64 = kwargs.get("height").unwrap().as_int().unwrap();
+
+ let f = unsafe { ffi::av_frame_alloc() };
+ unsafe {
+ (*f).width = width as i32;
+ (*f).height = height as i32;
+ (*f).format = ffi::AVPixelFormat_AV_PIX_FMT_YUV420P;
+
+ if ffi::av_frame_get_buffer(f, 0) < 0 {
+ panic!("ERROR could not allocate frame data");
+ }
+ }
+
+ for y in 0..unsafe { (*f).height } as usize {
+ for x in 0..unsafe { (*f).width } as usize {
+ unsafe {
+ *(*f).data[0].add(y * (*f).linesize[0] as usize + x) = ((x + y) % 256) as u8;
+ }
+ }
+ }
+
+ for y in 0..unsafe { (*f).height } as usize / 2 {
+ for x in 0..unsafe { (*f).width } as usize / 2 {
+ unsafe {
+ *(*f).data[1].add(y * (*f).linesize[1] as usize + x) = ((x + y) % 256) as u8;
+ *(*f).data[2].add(y * (*f).linesize[2] as usize + x) = ((x + y) % 256) as u8;
+ }
+ }
+ }
+
+ Ok(Frame::new(AVFrame { inner: f }))
+ }
+
+ fn filter_type(
+ &self,
+ _args: &[Val],
+ kwargs: &BTreeMap<String, Val>,
+ ) -> Result<FrameType, Error> {
+ let width = kwargs.get("width").unwrap().as_int().unwrap();
+ let height: i64 = kwargs.get("height").unwrap().as_int().unwrap();
+
+ Ok(FrameType::new(
+ width as usize,
+ height as usize,
+ ffi::AVPixelFormat_AV_PIX_FMT_YUV420P,
+ ))
+ }
+}
+
+pub struct Annotate {}
+impl super::Filter for Annotate {
+ fn filter(
+ &self,
+ args: &[Val],
+ kwargs: &BTreeMap<String, Val>,
+ ) -> Result<Frame, crate::dve::Error> {
+ assert!(args.len() == 1);
+ assert!(kwargs.is_empty());
+
+ let input_frame = match &args[0] {
+ Val::Frame(f) => f,
+ _ => panic!("Expected frame"),
+ };
+
+ assert_eq!(input_frame.format, ffi::AVPixelFormat_AV_PIX_FMT_YUV420P);
+
+ let f = unsafe { ffi::av_frame_alloc() };
+ unsafe {
+ (*f).width = input_frame.width;
+ (*f).height = input_frame.height;
+ (*f).format = ffi::AVPixelFormat_AV_PIX_FMT_YUV420P;
+
+ if ffi::av_frame_get_buffer(f, 0) < 0 {
+ panic!("ERROR could not allocate frame data");
+ }
+ }
+
+ if unsafe { ffi::av_frame_copy(f, input_frame.inner()) } < 0 {
+ panic!("ERROR could not copy frame data");
+ }
+
+ for y in 100..200 {
+ for x in 100..200 {
+ unsafe {
+ *(*f).data[0].add(y * (*f).linesize[0] as usize + x) = ((x + y) % 256) as u8;
+ }
+ }
+ }
+
+ for y in 100..200 {
+ for x in 100..200 {
+ unsafe {
+ let x = x / 2;
+ let y = y / 2;
+
+ *(*f).data[1].add(y * (*f).linesize[1] as usize + x) = ((x + y) % 256) as u8;
+ *(*f).data[2].add(y * (*f).linesize[2] as usize + x) = ((x + y) % 256) as u8;
+ }
+ }
+ }
+
+ Ok(Frame::new(AVFrame { inner: f }))
+ }
+
+ fn filter_type(
+ &self,
+ _args: &[Val],
+ _kwargs: &BTreeMap<String, Val>,
+ ) -> Result<FrameType, Error> {
+ todo!()
+ }
+}
+
+pub struct Box {}
+impl super::Filter for Box {
+ fn filter(
+ &self,
+ args: &[Val],
+ kwargs: &BTreeMap<String, Val>,
+ ) -> Result<Frame, crate::dve::Error> {
+ assert!(args.len() == 1);
+ assert!(kwargs.is_empty());
+
+ let input_frame = match &args[0] {
+ Val::Frame(f) => f,
+ _ => panic!("Expected frame"),
+ };
+
+ avfilter_backed_uniframe(
+ &input_frame.inner,
+ "drawbox=x=100:y=100:w=100:h=100:color=Cyan",
+ )
+ }
+
+ fn filter_type(
+ &self,
+ args: &[Val],
+ _kwargs: &BTreeMap<String, Val>,
+ ) -> Result<FrameType, Error> {
+ let input_frame = &args[0];
+ match input_frame {
+ Val::FrameType(frame_type) => Ok(frame_type.clone()),
+ _ => Err(Error::MissingFilterArg),
+ }
+ }
+}
+
+pub struct BoundingBox {}
+
+/*
+ For example: [{"class": "person", "confidence": 0.9243842363357544, "x1": 2049.759765625, "y1": 244.0765838623047, "x2": 3025.21875, "y2": 1714.0}, {"class": "person", "confidence": 0.9086535573005676, "x1": 1062.2205810546875, "y1": 111.629638671875, "x2": 1809.4146728515625, "y2": 1708.45458984375}]
+*/
+#[allow(dead_code)] // used in parsing
+#[derive(Debug, serde::Deserialize)]
+pub struct BoundingBoxBound {
+ class: String,
+ confidence: f64,
+ x1: f64,
+ y1: f64,
+ x2: f64,
+ y2: f64,
+}
+
+impl super::Filter for BoundingBox {
+ fn filter(
+ &self,
+ args: &[Val],
+ kwargs: &BTreeMap<String, Val>,
+ ) -> Result<Frame, crate::dve::Error> {
+ assert!(args.len() == 1);
+ let bounds_str = match kwargs.get("bounds").unwrap() {
+ Val::String(s) => s,
+ _ => panic!("Expected string"),
+ };
+
+ let bounds: Vec<BoundingBoxBound> = serde_json::from_str(bounds_str).unwrap();
+
+ let input_frame = match &args[0] {
+ Val::Frame(f) => f,
+ _ => panic!("Expected frame"),
+ };
+
+ if bounds.is_empty() {
+ let frame_copy = unsafe { ffi::av_frame_clone(input_frame.inner.inner) };
+ return Ok(Frame::new(AVFrame { inner: frame_copy }));
+ }
+
+ let filter = |frame: &mut Mat| {
+ for bound in bounds {
+ let x1 = bound.x1 as i32;
+ let y1 = bound.y1 as i32;
+ let x2 = bound.x2 as i32;
+ let y2 = bound.y2 as i32;
+
+ let color = Scalar::new(255.0, 0.0, 0.0, 0.0);
+ let thickness = 2;
+ let line_type = opencv::imgproc::LINE_8;
+ let shift = 0;
+
+ let pt1 = Point::new(x1, y1);
+ let pt2 = Point::new(x2, y2);
+
+ opencv::imgproc::rectangle(
+ frame,
+ Rect2i::from_points(pt1, pt2),
+ color,
+ thickness,
+ line_type,
+ shift,
+ )
+ .unwrap();
+ }
+ };
+
+ opencv_backed_uniframe(input_frame, filter)
+ }
+
+ fn filter_type(
+ &self,
+ args: &[Val],
+ _kwargs: &BTreeMap<String, Val>,
+ ) -> Result<FrameType, Error> {
+ let frame = args[0].as_frame_type().unwrap();
+ Ok(frame.clone())
+ }
+}
+
+pub struct DrawBox {}
+
+impl super::Filter for DrawBox {
+ fn filter(
+ &self,
+ args: &[Val],
+ kwargs: &BTreeMap<String, Val>,
+ ) -> Result<Frame, crate::dve::Error> {
+ assert!(args.len() == 1);
+
+ let input_frame = match &args[0] {
+ Val::Frame(f) => f,
+ _ => panic!("Expected frame"),
+ };
+
+ let x1 = match kwargs.get("x1").unwrap() {
+ Val::Int(val) => *val as i32,
+ _ => panic!("Expected a int for x1"),
+ };
+
+ let y1 = match kwargs.get("y1").unwrap() {
+ Val::Int(val) => *val as i32,
+ _ => panic!("Expected a int for y1"),
+ };
+
+ let x2 = match kwargs.get("x2").unwrap() {
+ Val::Int(val) => *val as i32,
+ _ => panic!("Expected a int for x2"),
+ };
+
+ let y2 = match kwargs.get("y2").unwrap() {
+ Val::Int(val) => *val as i32,
+ _ => panic!("Expected a int for y2"),
+ };
+
+ let filter = |frame: &mut Mat| {
+ let color = Scalar::new(255.0, 0.0, 0.0, 0.0);
+ let thickness = 2;
+ let line_type = opencv::imgproc::LINE_8;
+ let shift = 0;
+
+ let pt1 = Point::new(x1, y1);
+ let pt2 = Point::new(x2, y2);
+
+ imgproc::rectangle(
+ frame,
+ opencv::core::Rect2i::from_points(pt1, pt2),
+ color,
+ thickness,
+ line_type,
+ shift,
+ )
+ .unwrap();
+ };
+
+ opencv_backed_uniframe(input_frame, filter)
+ }
+
+ fn filter_type(
+ &self,
+ args: &[Val],
+ _kwargs: &BTreeMap<String, Val>,
+ ) -> Result<FrameType, Error> {
+ let frame = args[0].as_frame_type().unwrap();
+ Ok(frame.clone())
+ }
+}
+
+/// Scale & convert pixel format of a frame
+///
+/// # Arguments
+///
+/// * `width` - Width of the output frame (optional, but required if `height` is provided)
+/// * `height` - Height of the output frame (optional, but required if `width` is provided)
+/// * `format` - Pixel format of the output frame (optional)
+pub struct Scale {}
+impl super::Filter for Scale {
+ fn filter(
+ &self,
+ args: &[Val],
+ kwargs: &BTreeMap<String, Val>,
+ ) -> Result<Frame, crate::dve::Error> {
+ let (width, height) = {
+ if kwargs.contains_key("width") || kwargs.contains_key("height") {
+ if !(kwargs.contains_key("width") && kwargs.contains_key("height")) {
+ return Err(Error::MissingFilterArg);
+ }
+ (
+ match kwargs.get("width").unwrap() {
+ Val::Int(i) => Some(*i as usize),
+ _ => return Err(Error::MissingFilterArg),
+ },
+ match kwargs.get("height").unwrap() {
+ Val::Int(i) => Some(*i as usize),
+ _ => return Err(Error::MissingFilterArg),
+ },
+ )
+ } else {
+ (None, None)
+ }
+ };
+
+ let format = {
+ if kwargs.contains_key("pix_fmt") {
+ match kwargs.get("pix_fmt").unwrap() {
+ Val::String(s) => {
+ let format_cstr = CString::new(s.as_str()).unwrap();
+ let format = unsafe { ffi::av_get_pix_fmt(format_cstr.as_ptr()) };
+ if format == ffi::AVPixelFormat_AV_PIX_FMT_NONE {
+ return Err(Error::InvalidFilterArgValue(
+ s.clone(),
+ "Invalid pixel format".to_string(),
+ ));
+ }
+ Some(format)
+ }
+ _ => return Err(Error::MissingFilterArg),
+ }
+ } else {
+ None
+ }
+ };
+
+ assert!(args.len() == 1);
+
+ let input_frame = match &args[0] {
+ Val::Frame(f) => f,
+ _ => return Err(Error::MissingFilterArg),
+ };
+
+ let output_type = FrameType {
+ width: width.unwrap_or(input_frame.width as usize),
+ height: height.unwrap_or(input_frame.height as usize),
+ format: format.unwrap_or(input_frame.format),
+ };
+
+ let swscale_ctx = unsafe {
+ ffi::sws_getContext(
+ input_frame.width,
+ input_frame.height,
+ input_frame.format,
+ output_type.width as i32,
+ output_type.height as i32,
+ output_type.format,
+ ffi::SWS_BICUBIC as i32,
+ std::ptr::null_mut(),
+ std::ptr::null_mut(),
+ std::ptr::null_mut(),
+ )
+ };
+
+ let f = unsafe { ffi::av_frame_alloc() };
+ unsafe {
+ (*f).width = output_type.width as i32;
+ (*f).height = output_type.height as i32;
+ (*f).format = output_type.format;
+
+ if ffi::av_frame_get_buffer(f, 0) < 0 {
+ panic!("ERROR could not allocate frame data");
+ }
+ }
+
+ unsafe {
+ ffi::sws_scale(
+ swscale_ctx,
+ (*input_frame.inner.inner).data.as_ptr() as *const *const u8,
+ (*input_frame.inner.inner).linesize.as_ptr(),
+ 0,
+ input_frame.height,
+ (*f).data.as_mut_ptr(),
+ (*f).linesize.as_mut_ptr(),
+ );
+ }
+
+ unsafe {
+ ffi::sws_freeContext(swscale_ctx);
+ }
+
+ Ok(Frame::new(AVFrame { inner: f }))
+ }
+
+ fn filter_type(
+ &self,
+ args: &[Val],
+ kwargs: &BTreeMap<String, Val>,
+ ) -> Result<FrameType, Error> {
+ let (width, height) = {
+ if kwargs.contains_key("width") || kwargs.contains_key("height") {
+ if !(kwargs.contains_key("width") && kwargs.contains_key("height")) {
+ return Err(Error::MissingFilterArg);
+ }
+ (
+ match kwargs.get("width").unwrap() {
+ Val::Int(i) => Some(*i),
+ _ => return Err(Error::MissingFilterArg),
+ },
+ match kwargs.get("height").unwrap() {
+ Val::Int(i) => Some(*i),
+ _ => return Err(Error::MissingFilterArg),
+ },
+ )
+ } else {
+ (None, None)
+ }
+ };
+
+ let format = {
+ if kwargs.contains_key("pix_fmt") {
+ match kwargs.get("pix_fmt").unwrap() {
+ Val::String(s) => {
+ let format_cstr = CString::new(s.as_str()).unwrap();
+ let format = unsafe { ffi::av_get_pix_fmt(format_cstr.as_ptr()) };
+ if format == ffi::AVPixelFormat_AV_PIX_FMT_NONE {
+ return Err(Error::InvalidFilterArgValue(
+ s.clone(),
+ "Invalid pixel format".to_string(),
+ ));
+ }
+ Some(format)
+ }
+ _ => return Err(Error::MissingFilterArg),
+ }
+ } else {
+ None
+ }
+ };
+
+ assert!(args.len() == 1);
+
+ let frame = &args[0];
+ match frame {
+ Val::FrameType(frame_type) => {
+ let mut new_frame_type = frame_type.clone();
+ if let Some(width) = width {
+ assert!(width > 0 && width % 2 == 0);
+ new_frame_type.width = width as usize;
+ }
+ if let Some(height) = height {
+ assert!(height > 0 && height % 2 == 0);
+ new_frame_type.height = height as usize;
+ }
+ if let Some(format) = format {
+ new_frame_type.format = format;
+ }
+ Ok(new_frame_type)
+ }
+ _ => Err(Error::MissingFilterArg),
+ }
+ }
+}
+
+pub struct InlineMat;
+impl super::Filter for InlineMat {
+ fn filter(
+ &self,
+ args: &[Val],
+ kwargs: &BTreeMap<String, Val>,
+ ) -> Result<Frame, crate::dve::Error> {
+ let width = match kwargs.get("width").unwrap() {
+ Val::Int(i) => *i,
+ _ => panic!("Expected int"),
+ };
+
+ let height = match kwargs.get("height").unwrap() {
+ Val::Int(i) => *i,
+ _ => panic!("Expected int"),
+ };
+
+ let data = match &args[0] {
+ Val::Bytes(b) => b,
+ _ => panic!("Expected bytes"),
+ };
+
+ let f = unsafe { ffi::av_frame_alloc() };
+ if f.is_null() {
+ panic!("ERROR could not allocate frame");
+ }
+
+ unsafe {
+ (*f).width = width as i32;
+ (*f).height = height as i32;
+ (*f).format = ffi::AVPixelFormat_AV_PIX_FMT_RGB24;
+
+ if ffi::av_frame_get_buffer(f, 0) < 0 {
+ panic!("ERROR could not allocate frame data");
+ }
+ }
+
+ // check if ffmpeg wants padding
+ let linesize = unsafe { (*f).linesize[0] as usize };
+ let data_len = data.len();
+ let data_linesize = width as usize * 3;
+
+ if linesize != data_linesize {
+ for i in 0..height as usize {
+ let src = &data[i * data_linesize..(i + 1) * data_linesize];
+ let dst = unsafe { (*f).data[0].add(i * linesize) };
+ unsafe {
+ std::ptr::copy_nonoverlapping(src.as_ptr(), dst, data_linesize);
+ }
+ }
+ } else {
+ let src = data.as_ptr();
+ let dst = unsafe { (*f).data[0] };
+ unsafe {
+ std::ptr::copy_nonoverlapping(src, dst, data_len);
+ }
+ }
+
+ Ok(Frame::new(AVFrame { inner: f }))
+ }
+
+ fn filter_type(
+ &self,
+ args: &[Val],
+ kwargs: &BTreeMap<String, Val>,
+ ) -> Result<FrameType, Error> {
+ let width = match kwargs.get("width") {
+ Some(Val::Int(i)) => *i,
+ _ => return Err(Error::MissingFilterArg),
+ };
+
+ let height = match kwargs.get("height") {
+ Some(Val::Int(i)) => *i,
+ _ => return Err(Error::MissingFilterArg),
+ };
+
+ let pix_fmt = match kwargs.get("pix_fmt") {
+ Some(Val::String(s)) => s,
+ _ => return Err(Error::MissingFilterArg),
+ };
+
+ if pix_fmt != "rgb24" {
+ return Err(Error::InvalidFilterArgValue(
+ pix_fmt.clone(),
+ "Invalid pixel format".to_string(),
+ ));
+ }
+
+ if args.is_empty() {
+ return Err(Error::MissingFilterArg);
+ }
+
+ if args.len() > 1 {
+ return Err(Error::InvalidFilterArgValue(
+ format!("{:?}", args.len()),
+ "Invalid number of arguments".to_string(),
+ ));
+ }
+
+ let data: &Vec<u8> = match args[0] {
+ Val::Bytes(ref b) => b,
+ _ => return Err(Error::MissingFilterArg),
+ };
+
+ // check if data length matches width, height, and pix_fmt
+ if data.len() != width as usize * height as usize * 3 {
+ return Err(Error::InvalidFilterArgValue(
+ format!("{:?}", data.len()),
+ "Invalid data length".to_string(),
+ ));
+ }
+
+ Ok(FrameType {
+ width: width as usize,
+ height: height as usize,
+ format: ffi::AVPixelFormat_AV_PIX_FMT_RGB24,
+ })
+ }
+}
+
+// _slice_mat(frame, miny, maxy, minx, maxx)
+pub struct SliceMat {}
+impl super::Filter for SliceMat {
+ fn filter(
+ &self,
+ args: &[Val],
+ _kwargs: &BTreeMap<String, Val>,
+ ) -> Result<Frame, crate::dve::Error> {
+ let frame = match &args[0] {
+ Val::Frame(f) => f,
+ _ => panic!("Expected frame"),
+ };
+
+ let miny = args[1].as_int().unwrap();
+ let maxy = args[2].as_int().unwrap();
+ let minx = args[3].as_int().unwrap();
+ let maxx = args[4].as_int().unwrap();
+
+ // create output frame
+ let f = unsafe { ffi::av_frame_alloc() };
+ if f.is_null() {
+ panic!("ERROR could not allocate frame");
+ }
+
+ unsafe {
+ (*f).width = (maxx - minx) as i32;
+ (*f).height = (maxy - miny) as i32;
+ (*f).format = ffi::AVPixelFormat_AV_PIX_FMT_RGB24;
+
+ if ffi::av_frame_get_buffer(f, 0) < 0 {
+ panic!("ERROR could not allocate frame data");
+ }
+ }
+
+ for y in miny..maxy {
+ let src = unsafe {
+ (*frame.inner.inner).data[0]
+ .add(y as usize * (*frame.inner.inner).linesize[0] as usize + minx as usize * 3)
+ };
+ let dst = unsafe { (*f).data[0].add((y - miny) as usize * (*f).linesize[0] as usize) };
+ unsafe {
+ std::ptr::copy_nonoverlapping(src, dst, ((maxx - minx) * 3) as usize);
+ }
+ }
+
+ Ok(Frame::new(AVFrame { inner: f }))
+ }
+
+ fn filter_type(
+ &self,
+ args: &[Val],
+ kwargs: &BTreeMap<String, Val>,
+ ) -> Result<FrameType, Error> {
+ if args.len() < 5 {
+ return Err(Error::MissingFilterArg);
+ } else if args.len() > 5 {
+ return Err(Error::InvalidFilterArgValue(
+ format!("{:?}", args.len()),
+ "Invalid number of arguments".to_string(),
+ ));
+ }
+
+ if !kwargs.is_empty() {
+ return Err(Error::InvalidFilterArgValue(
+ format!("{:?}", kwargs.len()),
+ "Invalid number of keyword arguments".to_string(),
+ ));
+ }
+
+ let frame = match args[0] {
+ Val::FrameType(ref f) => f,
+ _ => return Err(Error::MissingFilterArg),
+ };
+
+ if frame.format != ffi::AVPixelFormat_AV_PIX_FMT_RGB24 {
+ return Err(Error::InvalidFilterArgValue(
+ format!("{:?}", frame.format),
+ "Invalid pixel format".to_string(),
+ ));
+ }
+
+ let miny = match args[1] {
+ Val::Int(i) => i,
+ _ => return Err(Error::MissingFilterArg),
+ };
+
+ let maxy = match args[2] {
+ Val::Int(i) => i,
+ _ => return Err(Error::MissingFilterArg),
+ };
+
+ let minx = match args[3] {
+ Val::Int(i) => i,
+ _ => return Err(Error::MissingFilterArg),
+ };
+
+ let maxx = match args[4] {
+ Val::Int(i) => i,
+ _ => return Err(Error::MissingFilterArg),
+ };
+
+ if miny < 0
+ || miny > frame.height as i64
+ || maxy < 0
+ || maxy > frame.height as i64
+ || minx < 0
+ || minx > frame.width as i64
+ || maxx < 0
+ || maxx > frame.width as i64
+ || miny >= maxy
+ || minx >= maxx
+ {
+ return Err(Error::InvalidFilterArgValue(
+ format!("{:?}", args),
+ "Invalid slice bounds".to_string(),
+ ));
+ }
+
+ Ok(FrameType {
+ width: (maxx - minx) as usize,
+ height: (maxy - miny) as usize,
+ format: frame.format,
+ })
+ }
+}
+
+// _slice_write_mat(f1, f2, miny, maxy, minx, maxx)
+// equiv to python f1[miny:maxy, minx:maxx] = f2
+pub struct SliceWriteMat {}
+impl super::Filter for SliceWriteMat {
+ fn filter(
+ &self,
+ args: &[Val],
+ _kwargs: &BTreeMap<String, Val>,
+ ) -> Result<Frame, crate::dve::Error> {
+ let f1 = match &args[0] {
+ Val::Frame(f) => f,
+ _ => panic!("Expected frame"),
+ };
+
+ let f2 = match &args[1] {
+ Val::Frame(f) => f,
+ _ => panic!("Expected frame"),
+ };
+
+ let miny = args[2].as_int().unwrap() as usize;
+ let maxy = args[3].as_int().unwrap() as usize;
+ let minx = args[4].as_int().unwrap() as usize;
+ let maxx = args[5].as_int().unwrap() as usize;
+
+ let f = unsafe { ffi::av_frame_alloc() };
+ if f.is_null() {
+ panic!("ERROR could not allocate frame");
+ }
+
+ unsafe {
+ (*f).width = f1.width;
+ (*f).height = f1.height;
+ (*f).format = ffi::AVPixelFormat_AV_PIX_FMT_RGB24;
+
+ if ffi::av_frame_get_buffer(f, 0) < 0 {
+ panic!("ERROR could not allocate frame data");
+ }
+ }
+
+ for y in 0..f1.height as usize {
+ let src = unsafe {
+ (*f1.inner.inner).data[0].add(y * (*f1.inner.inner).linesize[0] as usize)
+ };
+ let dst = unsafe { (*f).data[0].add(y * (*f).linesize[0] as usize) };
+ unsafe {
+ std::ptr::copy_nonoverlapping(src, dst, f1.width as usize * 3);
+ }
+
+ if y >= miny && y < maxy {
+ let src = unsafe {
+ (*f2.inner.inner).data[0]
+ .add((y - miny) * (*f2.inner.inner).linesize[0] as usize)
+ };
+ let dst = unsafe { (*f).data[0].add(y * (*f).linesize[0] as usize) };
+ unsafe {
+ std::ptr::copy_nonoverlapping(src, dst.add(minx * 3), (maxx - minx) * 3);
+ }
+ }
+ }
+
+ Ok(Frame::new(AVFrame { inner: f }))
+ }
+
+ fn filter_type(
+ &self,
+ args: &[Val],
+ kwargs: &BTreeMap<String, Val>,
+ ) -> Result<FrameType, Error> {
+ if args.len() < 6 {
+ return Err(Error::MissingFilterArg);
+ } else if args.len() > 6 {
+ return Err(Error::InvalidFilterArgValue(
+ format!("{:?}", args.len()),
+ "Invalid number of arguments".to_string(),
+ ));
+ }
+
+ if !kwargs.is_empty() {
+ return Err(Error::InvalidFilterArgValue(
+ format!("{:?}", kwargs.len()),
+ "Invalid number of keyword arguments".to_string(),
+ ));
+ }
+
+ let f1 = match args[0] {
+ Val::FrameType(ref f) => f,
+ _ => return Err(Error::MissingFilterArg),
+ };
+
+ let f2 = match args[1] {
+ Val::FrameType(ref f) => f,
+ _ => return Err(Error::MissingFilterArg),
+ };
+
+ if f1.format != ffi::AVPixelFormat_AV_PIX_FMT_RGB24 {
+ return Err(Error::InvalidFilterArgValue(
+ format!("{:?}", f1.format),
+ "Invalid pixel format".to_string(),
+ ));
+ }
+
+ if f2.format != ffi::AVPixelFormat_AV_PIX_FMT_RGB24 {
+ return Err(Error::InvalidFilterArgValue(
+ format!("{:?}", f2.format),
+ "Invalid pixel format".to_string(),
+ ));
+ }
+
+ let miny = match args[2] {
+ Val::Int(i) => i,
+ _ => return Err(Error::MissingFilterArg),
+ };
+
+ let maxy = match args[3] {
+ Val::Int(i) => i,
+ _ => return Err(Error::MissingFilterArg),
+ };
+
+ let minx = match args[4] {
+ Val::Int(i) => i,
+ _ => return Err(Error::MissingFilterArg),
+ };
+
+ let maxx = match args[5] {
+ Val::Int(i) => i,
+ _ => return Err(Error::MissingFilterArg),
+ };
+
+ if miny < 0
+ || miny > f1.height as i64
+ || maxy < 0
+ || maxy > f1.height as i64
+ || minx < 0
+ || minx > f1.width as i64
+ || maxx < 0
+ || maxx > f1.width as i64
+ || miny >= maxy
+ || minx >= maxx
+ {
+ return Err(Error::InvalidFilterArgValue(
+ format!("{:?}", args),
+ "Invalid slice bounds".to_string(),
+ ));
+ }
+
+ // check if f2 dimensions match slice dimensions
+ if f2.width != (maxx - minx) as usize || f2.height != (maxy - miny) as usize {
+ return Err(Error::InvalidFilterArgValue(
+ format!("{:?}", args),
+ "Frame f2 does not match slice size".to_string(),
+ ));
+ }
+
+ Ok(FrameType {
+ width: f1.width,
+ height: f1.height,
+ format: f1.format,
+ })
+ }
+}
+
+pub struct Pad {}
+impl super::Filter for Pad {
+ fn filter(
+ &self,
+ args: &[Val],
+ kwargs: &BTreeMap<String, Val>,
+ ) -> Result<Frame, crate::dve::Error> {
+ let width = match kwargs.get("width").unwrap() {
+ Val::Int(i) => *i,
+ _ => panic!("Expected int"),
+ };
+
+ let height = match kwargs.get("height").unwrap() {
+ Val::Int(i) => *i,
+ _ => panic!("Expected int"),
+ };
+
+ let x = match kwargs.get("x").unwrap() {
+ Val::Int(i) => *i,
+ _ => panic!("Expected int"),
+ };
+
+ let y = match kwargs.get("y").unwrap() {
+ Val::Int(i) => *i,
+ _ => panic!("Expected int"),
+ };
+
+ let input_frame = match &args[0] {
+ Val::Frame(f) => f,
+ _ => panic!("Expected frame"),
+ };
+
+ let f = unsafe { ffi::av_frame_alloc() };
+ if f.is_null() {
+ panic!("ERROR could not allocate frame");
+ }
+
+ unsafe {
+ (*f).width = width as i32;
+ (*f).height = height as i32;
+ (*f).format = ffi::AVPixelFormat_AV_PIX_FMT_YUV420P;
+
+ if ffi::av_frame_get_buffer(f, 0) < 0 {
+ panic!("ERROR could not allocate frame data");
+ }
+ }
+
+ let draw_context: *mut drawutils::FFDrawContext = unsafe {
+ ffi::av_calloc(1, std::mem::size_of::<drawutils::FFDrawContext>())
+ as *mut drawutils::FFDrawContext
+ };
+ if draw_context.is_null() {
+ panic!("ERROR could not allocate draw context");
+ }
+ let ret = unsafe { drawutils::ff_draw_init(draw_context, input_frame.format, 0) };
+ if ret < 0 {
+ panic!("ERROR could not initialize draw context");
+ }
+
+ let color: *mut drawutils::FFDrawColor = unsafe {
+ ffi::av_calloc(1, std::mem::size_of::<drawutils::FFDrawColor>())
+ as *mut drawutils::FFDrawColor
+ };
+ if color.is_null() {
+ panic!("ERROR could not allocate color");
+ }
+
+ let mut color_rgba = [0u8; 4];
+ match kwargs.get("color") {
+ Some(Val::String(s)) => {
+ let color_str = CString::new(s.to_string()).unwrap();
+ let ret = unsafe {
+ ffi::av_parse_color(
+ color_rgba.as_ptr() as *mut u8,
+ color_str.as_ptr(),
+ -1,
+ std::ptr::null_mut(),
+ )
+ };
+ if ret < 0 {
+ return Err(Error::InvalidFilterArgValue(
+ s.to_string(),
+ "Invalid color".to_string(),
+ ));
+ }
+ }
+ _ => {
+ color_rgba[0] = 0;
+ color_rgba[1] = 0;
+ color_rgba[2] = 0;
+ color_rgba[3] = 255;
+ }
+ }
+
+ unsafe { drawutils::ff_draw_color(draw_context, color, color_rgba.as_ptr()) };
+
+ let in_w = input_frame.width as i64;
+ let in_h = input_frame.height as i64;
+
+ // top bar
+ if y != 0 {
+ unsafe {
+ drawutils::ff_fill_rectangle(
+ draw_context,
+ color,
+ &mut (*f).data as *mut *mut u8,
+ &mut (*f).linesize as *mut i32,
+ 0,
+ 0,
+ width as i32,
+ height as i32,
+ )
+ };
+ }
+
+ // bottom bar
+ if height > y + in_h {
+ unsafe {
+ drawutils::ff_fill_rectangle(
+ draw_context,
+ color,
+ &mut (*f).data as *mut *mut u8,
+ &mut (*f).linesize as *mut i32,
+ 0,
+ (y + in_h) as i32,
+ width as i32,
+ (height - y - in_h) as i32,
+ )
+ };
+ }
+
+ // left border
+ if x != 0 {
+ unsafe {
+ drawutils::ff_fill_rectangle(
+ draw_context,
+ color,
+ &mut (*f).data as *mut *mut u8,
+ &mut (*f).linesize as *mut i32,
+ 0,
+ y as i32,
+ x as i32,
+ in_h as i32,
+ )
+ };
+ }
+
+ // copy input frame
+ unsafe {
+ drawutils::ff_copy_rectangle2(
+ draw_context,
+ &mut (*f).data as *mut *mut u8,
+ &mut (*f).linesize as *mut i32,
+ &mut (*input_frame.inner.inner).data as *mut *mut u8,
+ &mut (*input_frame.inner.inner).linesize as *mut i32,
+ x as i32,
+ y as i32,
+ 0,
+ 0,
+ in_w as i32,
+ in_h as i32,
+ )
+ }
+
+ // right border
+ if width > x + in_w {
+ unsafe {
+ drawutils::ff_fill_rectangle(
+ draw_context,
+ color,
+ &mut (*f).data as *mut *mut u8,
+ &mut (*f).linesize as *mut i32,
+ (x + in_w) as i32,
+ y as i32,
+ (width - x - in_w) as i32,
+ in_h as i32,
+ )
+ };
+ }
+
+ unsafe {
+ ffi::av_free(color as *mut std::ffi::c_void);
+ ffi::av_free(draw_context as *mut std::ffi::c_void);
+ }
+
+ Ok(Frame::new(AVFrame { inner: f }))
+ }
+
+ fn filter_type(
+ &self,
+ args: &[Val],
+ kwargs: &BTreeMap<String, Val>,
+ ) -> Result<FrameType, crate::dve::Error> {
+ let _x = match kwargs.get("x").unwrap() {
+ Val::Int(i) => *i,
+ _ => panic!("Expected int"),
+ };
+
+ let _y = match kwargs.get("y").unwrap() {
+ Val::Int(i) => *i,
+ _ => panic!("Expected int"),
+ };
+
+ let width = match kwargs.get("width").unwrap() {
+ Val::Int(i) => *i,
+ _ => panic!("Expected int"),
+ };
+
+ let height = match kwargs.get("height").unwrap() {
+ Val::Int(i) => *i,
+ _ => panic!("Expected int"),
+ };
+
+ let input_frame = match &args[0] {
+ Val::FrameType(f) => f,
+ _ => panic!("Expected frame"),
+ };
+
+ let mut color = [0u8; 4];
+ match kwargs.get("color") {
+ Some(Val::String(s)) => {
+ let color_str = CString::new(s.to_string()).unwrap();
+ let ret = unsafe {
+ ffi::av_parse_color(
+ color.as_ptr() as *mut u8,
+ color_str.as_ptr(),
+ -1,
+ std::ptr::null_mut(),
+ )
+ };
+ if ret < 0 {
+ return Err(Error::InvalidFilterArgValue(
+ s.to_string(),
+ "Invalid color".to_string(),
+ ));
+ }
+ }
+ _ => {
+ color[0] = 0;
+ color[1] = 0;
+ color[2] = 0;
+ color[3] = 255;
+ }
+ }
+
+ let out_frame_type = FrameType {
+ width: width as usize,
+ height: height as usize,
+ format: input_frame.format,
+ };
+
+ Ok(out_frame_type)
+ }
+}
+
+pub struct HStack {}
+impl super::Filter for HStack {
+ fn filter(
+ &self,
+ args: &[Val],
+ kwargs: &BTreeMap<String, Val>,
+ ) -> Result<Frame, crate::dve::Error> {
+ let width = match kwargs.get("width").unwrap() {
+ Val::Int(i) => *i,
+ _ => panic!("Expected int"),
+ };
+
+ let height = match kwargs.get("height").unwrap() {
+ Val::Int(i) => *i,
+ _ => panic!("Expected int"),
+ };
+
+ let format = match kwargs.get("format").unwrap() {
+ Val::String(s) => {
+ let format_cstr = CString::new(s.as_str()).unwrap();
+ let format = unsafe { ffi::av_get_pix_fmt(format_cstr.as_ptr()) };
+ if format == ffi::AVPixelFormat_AV_PIX_FMT_NONE {
+ return Err(Error::InvalidFilterArgValue(
+ s.clone(),
+ "Invalid pixel format".to_string(),
+ ));
+ }
+ format
+ }
+ _ => panic!("Expected string"),
+ };
+
+ // create output frame
+ let f = unsafe { ffi::av_frame_alloc() };
+ if f.is_null() {
+ panic!("ERROR could not allocate frame");
+ }
+
+ unsafe {
+ (*f).width = width as i32;
+ (*f).height = height as i32;
+ (*f).format = format;
+
+ if ffi::av_frame_get_buffer(f, 0) < 0 {
+ panic!("ERROR could not allocate frame data");
+ }
+
+ let draw: *mut drawutils::FFDrawContext =
+ ffi::av_calloc(1, std::mem::size_of::<drawutils::FFDrawContext>())
+ as *mut drawutils::FFDrawContext;
+
+ if draw.is_null() {
+ panic!("ERROR could not allocate draw context");
+ }
+
+ let ret = drawutils::ff_draw_init(draw, format, 0);
+ if ret < 0 {
+ panic!("ERROR could not initialize draw context");
+ }
+
+ let color_rgba = [0u8, 0u8, 0u8, 255u8];
+ let color: *mut drawutils::FFDrawColor =
+ ffi::av_calloc(1, std::mem::size_of::<drawutils::FFDrawColor>())
+ as *mut drawutils::FFDrawColor;
+ if color.is_null() {
+ panic!("ERROR could not allocate color");
+ }
+
+ drawutils::ff_draw_color(draw, color, color_rgba.as_ptr());
+
+ // fill with black
+ drawutils::ff_fill_rectangle(
+ draw,
+ color,
+ &mut (*f).data as *mut *mut u8,
+ &mut (*f).linesize as *mut i32,
+ 0,
+ 0,
+ width as i32,
+ height as i32,
+ );
+
+ ffi::av_free(color as *mut std::ffi::c_void);
+ ffi::av_free(draw as *mut std::ffi::c_void);
+ }
+
+ let input_frames: Vec<&Frame> = args
+ .iter()
+ .map(|arg| match arg {
+ Val::Frame(f) => f,
+ _ => panic!("Expected frame"),
+ })
+ .collect();
+
+ let each_frame_width = width / input_frames.len() as i64;
+
+ for (i, frame) in input_frames.iter().enumerate() {
+ let new_height =
+ (frame.height as f64 / frame.width as f64 * each_frame_width as f64).round() as i64;
+
+ let mut temp_frame = unsafe { ffi::av_frame_alloc() };
+ if temp_frame.is_null() {
+ panic!("ERROR could not allocate frame");
+ }
+
+ unsafe {
+ (*temp_frame).width = each_frame_width as i32;
+ (*temp_frame).height = new_height as i32;
+ (*temp_frame).format = format;
+
+ if ffi::av_frame_get_buffer(temp_frame, 0) < 0 {
+ panic!("ERROR could not allocate frame data");
+ }
+ }
+
+ let sws_ctx = unsafe {
+ ffi::sws_getContext(
+ frame.width,
+ frame.height,
+ frame.format,
+ each_frame_width as i32,
+ new_height as i32,
+ format,
+ ffi::SWS_BICUBIC as i32,
+ std::ptr::null_mut(),
+ std::ptr::null_mut(),
+ std::ptr::null_mut(),
+ )
+ };
+
+ unsafe {
+ ffi::sws_scale(
+ sws_ctx,
+ (*frame.inner.inner).data.as_ptr() as *const *const u8,
+ (*frame.inner.inner).linesize.as_ptr(),
+ 0,
+ frame.height,
+ (*temp_frame).data.as_mut_ptr(),
+ (*temp_frame).linesize.as_mut_ptr(),
+ );
+ }
+
+ // Try to keep the image vertically centered
+ let dst_y = (height - new_height) / 2;
+
+ let draw: *mut drawutils::FFDrawContext = unsafe {
+ ffi::av_calloc(1, std::mem::size_of::<drawutils::FFDrawContext>())
+ as *mut drawutils::FFDrawContext
+ };
+ if draw.is_null() {
+ panic!("ERROR could not allocate draw context");
+ }
+ let ret = unsafe { drawutils::ff_draw_init(draw, format, 0) };
+ if ret < 0 {
+ panic!("ERROR could not initialize draw context");
+ }
+
+ // use ff_copy_rectangle2 to copy temp_frame to f
+ unsafe {
+ drawutils::ff_copy_rectangle2(
+ draw,
+ &mut (*f).data as *mut *mut u8,
+ &mut (*f).linesize as *mut i32,
+ &mut (*temp_frame).data as *mut *mut u8,
+ &mut (*temp_frame).linesize as *mut i32,
+ i as i32 * each_frame_width as i32, // i as i32 * each_frame_width as i32
+ dst_y as i32, // dst_y as i32,
+ 0,
+ 0,
+ each_frame_width as i32,
+ new_height as i32,
+ )
+ };
+
+ unsafe {
+ ffi::av_frame_free(&mut temp_frame);
+ ffi::sws_freeContext(sws_ctx);
+ ffi::av_free(draw as *mut std::ffi::c_void);
+ }
+ }
+
+ Ok(Frame::new(AVFrame { inner: f }))
+ }
+
+ fn filter_type(
+ &self,
+ args: &[Val],
+ kwargs: &BTreeMap<String, Val>,
+ ) -> Result<FrameType, Error> {
+ let width = match kwargs.get("width").unwrap() {
+ Val::Int(i) => *i,
+ _ => panic!("Expected int"),
+ };
+
+ let height = match kwargs.get("height").unwrap() {
+ Val::Int(i) => *i,
+ _ => panic!("Expected int"),
+ };
+
+ let format = match kwargs.get("format").unwrap() {
+ Val::String(s) => {
+ let format_cstr = CString::new(s.as_str()).unwrap();
+ let format = unsafe { ffi::av_get_pix_fmt(format_cstr.as_ptr()) };
+ if format == ffi::AVPixelFormat_AV_PIX_FMT_NONE {
+ return Err(Error::InvalidFilterArgValue(
+ s.clone(),
+ "Invalid pixel format".to_string(),
+ ));
+ }
+ format
+ }
+ _ => panic!("Expected string"),
+ };
+
+ for input in args {
+ match input {
+ Val::FrameType(_) => {}
+ _ => return Err(Error::MissingFilterArg),
+ }
+ }
+
+ Ok(FrameType {
+ width: width as usize,
+ height: height as usize,
+ format,
+ })
+ }
+}
+
+pub struct VStack {}
+impl super::Filter for VStack {
+ fn filter(
+ &self,
+ args: &[Val],
+ kwargs: &BTreeMap<String, Val>,
+ ) -> Result<Frame, crate::dve::Error> {
+ let width = match kwargs.get("width").unwrap() {
+ Val::Int(i) => *i,
+ _ => panic!("Expected int"),
+ };
+
+ let height = match kwargs.get("height").unwrap() {
+ Val::Int(i) => *i,
+ _ => panic!("Expected int"),
+ };
+
+ let format = match kwargs.get("format").unwrap() {
+ Val::String(s) => {
+ let format_cstr = CString::new(s.as_str()).unwrap();
+ let format = unsafe { ffi::av_get_pix_fmt(format_cstr.as_ptr()) };
+ if format == ffi::AVPixelFormat_AV_PIX_FMT_NONE {
+ return Err(Error::InvalidFilterArgValue(
+ s.clone(),
+ "Invalid pixel format".to_string(),
+ ));
+ }
+ format
+ }
+ _ => panic!("Expected string"),
+ };
+
+ // create output frame
+ let f = unsafe { ffi::av_frame_alloc() };
+ if f.is_null() {
+ panic!("ERROR could not allocate frame");
+ }
+
+ unsafe {
+ (*f).width = width as i32;
+ (*f).height = height as i32;
+ (*f).format = format;
+
+ if ffi::av_frame_get_buffer(f, 0) < 0 {
+ panic!("ERROR could not allocate frame data");
+ }
+
+ let draw: *mut drawutils::FFDrawContext =
+ ffi::av_calloc(1, std::mem::size_of::<drawutils::FFDrawContext>())
+ as *mut drawutils::FFDrawContext;
+
+ if draw.is_null() {
+ panic!("ERROR could not allocate draw context");
+ }
+
+ let ret = drawutils::ff_draw_init(draw, format, 0);
+ if ret < 0 {
+ panic!("ERROR could not initialize draw context");
+ }
+
+ let color_rgba = [0u8, 0u8, 0u8, 255u8];
+ let color: *mut drawutils::FFDrawColor =
+ ffi::av_calloc(1, std::mem::size_of::<drawutils::FFDrawColor>())
+ as *mut drawutils::FFDrawColor;
+ if color.is_null() {
+ panic!("ERROR could not allocate color");
+ }
+
+ drawutils::ff_draw_color(draw, color, color_rgba.as_ptr());
+
+ // fill with black
+ drawutils::ff_fill_rectangle(
+ draw,
+ color,
+ &mut (*f).data as *mut *mut u8,
+ &mut (*f).linesize as *mut i32,
+ 0,
+ 0,
+ width as i32,
+ height as i32,
+ );
+
+ ffi::av_free(color as *mut std::ffi::c_void);
+ ffi::av_free(draw as *mut std::ffi::c_void);
+ }
+
+ let input_frames: Vec<&Frame> = args
+ .iter()
+ .map(|arg| match arg {
+ Val::Frame(f) => f,
+ _ => panic!("Expected frame"),
+ })
+ .collect();
+
+ let each_frame_height = height / input_frames.len() as i64;
+
+ for (i, frame) in input_frames.iter().enumerate() {
+ let new_width = (frame.width as f64 / frame.height as f64 * each_frame_height as f64)
+ .round() as i64;
+
+ let mut temp_frame = unsafe { ffi::av_frame_alloc() };
+ if temp_frame.is_null() {
+ panic!("ERROR could not allocate frame");
+ }
+
+ unsafe {
+ (*temp_frame).width = new_width as i32;
+ (*temp_frame).height = each_frame_height as i32;
+ (*temp_frame).format = format;
+
+ if ffi::av_frame_get_buffer(temp_frame, 0) < 0 {
+ panic!("ERROR could not allocate frame data");
+ }
+ }
+
+ let sws_ctx = unsafe {
+ ffi::sws_getContext(
+ frame.width,
+ frame.height,
+ frame.format,
+ new_width as i32,
+ each_frame_height as i32,
+ format,
+ ffi::SWS_BICUBIC as i32,
+ std::ptr::null_mut(),
+ std::ptr::null_mut(),
+ std::ptr::null_mut(),
+ )
+ };
+
+ unsafe {
+ ffi::sws_scale(
+ sws_ctx,
+ (*frame.inner.inner).data.as_ptr() as *const *const u8,
+ (*frame.inner.inner).linesize.as_ptr(),
+ 0,
+ frame.height,
+ (*temp_frame).data.as_mut_ptr(),
+ (*temp_frame).linesize.as_mut_ptr(),
+ );
+ }
+
+ // Try to keep the image horizontally centered
+ let dst_x = (width - new_width) / 2;
+
+ let draw: *mut drawutils::FFDrawContext = unsafe {
+ ffi::av_calloc(1, std::mem::size_of::<drawutils::FFDrawContext>())
+ as *mut drawutils::FFDrawContext
+ };
+ if draw.is_null() {
+ panic!("ERROR could not allocate draw context");
+ }
+ let ret = unsafe { drawutils::ff_draw_init(draw, format, 0) };
+ if ret < 0 {
+ panic!("ERROR could not initialize draw context");
+ }
+
+ // use ff_copy_rectangle2 to copy temp_frame to f
+ unsafe {
+ drawutils::ff_copy_rectangle2(
+ draw,
+ &mut (*f).data as *mut *mut u8,
+ &mut (*f).linesize as *mut i32,
+ &mut (*temp_frame).data as *mut *mut u8,
+ &mut (*temp_frame).linesize as *mut i32,
+ dst_x as i32,
+ i as i32 * each_frame_height as i32,
+ 0,
+ 0,
+ new_width as i32,
+ each_frame_height as i32,
+ )
+ };
+
+ unsafe {
+ ffi::av_frame_free(&mut temp_frame);
+ ffi::sws_freeContext(sws_ctx);
+ ffi::av_free(draw as *mut std::ffi::c_void);
+ }
+ }
+
+ Ok(Frame::new(AVFrame { inner: f }))
+ }
+
+ fn filter_type(
+ &self,
+ args: &[Val],
+ kwargs: &BTreeMap<String, Val>,
+ ) -> Result<FrameType, Error> {
+ let width = match kwargs.get("width").unwrap() {
+ Val::Int(i) => *i,
+ _ => panic!("Expected int"),
+ };
+
+ let height = match kwargs.get("height").unwrap() {
+ Val::Int(i) => *i,
+ _ => panic!("Expected int"),
+ };
+
+ let format = match kwargs.get("format").unwrap() {
+ Val::String(s) => {
+ let format_cstr = CString::new(s.as_str()).unwrap();
+ let format = unsafe { ffi::av_get_pix_fmt(format_cstr.as_ptr()) };
+ if format == ffi::AVPixelFormat_AV_PIX_FMT_NONE {
+ return Err(Error::InvalidFilterArgValue(
+ s.clone(),
+ "Invalid pixel format".to_string(),
+ ));
+ }
+ format
+ }
+ _ => panic!("Expected string"),
+ };
+
+ for input in args {
+ match input {
+ Val::FrameType(_) => {}
+ _ => return Err(Error::MissingFilterArg),
+ }
+ }
+
+ Ok(FrameType {
+ width: width as usize,
+ height: height as usize,
+ format,
+ })
+ }
+}
+pub struct DrawText {}
+impl super::Filter for DrawText {
+ fn filter(
+ &self,
+ args: &[Val],
+ kwargs: &BTreeMap<String, Val>,
+ ) -> Result<Frame, crate::dve::Error> {
+ assert!(args.len() == 1);
+
+ let input_frame = match &args[0] {
+ Val::Frame(f) => f,
+ _ => panic!("Expected frame"),
+ };
+
+ let text = match kwargs.get("text").unwrap() {
+ Val::String(s) => s,
+ _ => panic!("Expected string"),
+ };
+
+ let x = match kwargs.get("x").unwrap() {
+ Val::Int(i) => *i,
+ _ => panic!("Expected int"),
+ };
+ let y = match kwargs.get("y").unwrap() {
+ Val::Int(i) => *i,
+ _ => panic!("Expected int"),
+ };
+
+ let size = match kwargs.get("size") {
+ Some(Val::Int(i)) => *i,
+ _ => 20,
+ };
+ let scale = size as f64 / 20.0;
+
+ let filter = |mat: &mut Mat| {
+ let color = opencv::core::Scalar::new(255.0, 255.0, 255.0, 0.0);
+ let font_face = opencv::imgproc::FONT_HERSHEY_SIMPLEX;
+ let font_scale = scale;
+ let thickness = scale as i32 * 2;
+ let line_type = opencv::imgproc::LINE_8;
+ let bottom_left_origin = false;
+
+ opencv::imgproc::put_text(
+ mat,
+ text,
+ Point::new(x as i32, y as i32),
+ font_face,
+ font_scale,
+ color,
+ thickness,
+ line_type,
+ bottom_left_origin,
+ )
+ .unwrap();
+ };
+
+ opencv_backed_uniframe(input_frame, filter)
+ }
+
+ fn filter_type(
+ &self,
+ args: &[Val],
+ _kwargs: &BTreeMap<String, Val>,
+ ) -> Result<FrameType, Error> {
+ let input_frame = &args[0];
+ match input_frame {
+ Val::FrameType(frame_type) => Ok(frame_type.clone()),
+ _ => Err(Error::MissingFilterArg),
+ }
+ }
+}
+vidformer/filter/builtin/drawutils.rs
+1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388
/// This module reimplements the drawutils.c file from FFmpeg.
+/// We need to reimplement this file because it is not exposed in the FFmpeg Rust bindings.
+///
+/// The goal is to allow `ffi::` to be replaced with `drawutils::` and maintain API compatibility.
+/// The implementation is based on the original C code from FFmpeg and bindgen and cleaned up with manual/ChatGPT updates.
+use rusty_ffmpeg::ffi;
+
+const MAX_PLANES: usize = 4;
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub(crate) struct FFDrawContext {
+ pub(crate) desc: *const ffi::AVPixFmtDescriptor,
+ pub(crate) format: ffi::AVPixelFormat,
+ pub(crate) nb_planes: ::std::os::raw::c_uint,
+ pub(crate) pixelstep: [::std::os::raw::c_int; MAX_PLANES],
+ pub(crate) hsub: [u8; MAX_PLANES],
+ pub(crate) vsub: [u8; MAX_PLANES],
+ pub(crate) hsub_max: u8,
+ pub(crate) vsub_max: u8,
+ pub(crate) range: ffi::AVColorRange,
+ pub(crate) flags: ::std::os::raw::c_uint,
+ pub(crate) csp: ffi::AVColorSpace,
+ pub(crate) rgb2yuv: [[f64; 3usize]; 3usize],
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub(crate) struct FFDrawColor {
+ pub(crate) rgba: [u8; 4usize],
+ pub(crate) comp: [FFDrawColor__bindgen_ty_1; 4usize],
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub(crate) union FFDrawColor__bindgen_ty_1 {
+ pub(crate) u32_: [u32; 4usize],
+ pub(crate) u16_: [u16; 8usize],
+ pub(crate) u8_: [u8; 16usize],
+}
+
+pub(crate) unsafe fn ff_draw_init(
+ draw: *mut FFDrawContext,
+ format: ffi::AVPixelFormat,
+ flags: ::std::os::raw::c_uint,
+) -> ::std::os::raw::c_int {
+ ff_draw_init2(
+ draw,
+ format,
+ ffi::AVColorSpace_AVCOL_SPC_UNSPECIFIED,
+ ffi::AVColorRange_AVCOL_RANGE_UNSPECIFIED,
+ flags,
+ )
+}
+
+pub(crate) unsafe fn ff_draw_init2(
+ draw: *mut FFDrawContext,
+ format: ffi::AVPixelFormat,
+ csp: ffi::AVColorSpace,
+ range: ffi::AVColorRange,
+ flags: ::std::os::raw::c_uint,
+) -> ::std::os::raw::c_int {
+ unsafe {
+ let desc = ffi::av_pix_fmt_desc_get(format);
+ if desc.is_null() || (*desc).name.is_null() {
+ return ffi::AVERROR(ffi::EINVAL);
+ }
+ if (*desc).flags & ffi::AV_PIX_FMT_FLAG_BE as u64 != 0 {
+ return ffi::AVERROR(ffi::ENOSYS);
+ }
+ if (*desc).flags
+ & !(ffi::AV_PIX_FMT_FLAG_PLANAR | ffi::AV_PIX_FMT_FLAG_RGB | ffi::AV_PIX_FMT_FLAG_ALPHA)
+ as u64
+ != 0
+ {
+ return ffi::AVERROR(ffi::ENOSYS);
+ }
+
+ let mut csp = csp;
+ if csp == ffi::AVColorSpace_AVCOL_SPC_UNSPECIFIED {
+ csp = if (*desc).flags & ffi::AV_PIX_FMT_FLAG_RGB as u64 != 0 {
+ ffi::AVColorSpace_AVCOL_SPC_RGB
+ } else {
+ ffi::AVColorSpace_AVCOL_SPC_SMPTE170M
+ };
+ }
+
+ let luma = if (*desc).flags & ffi::AV_PIX_FMT_FLAG_RGB as u64 == 0 {
+ ffi::av_csp_luma_coeffs_from_avcsp(csp)
+ } else {
+ std::ptr::null()
+ };
+ if luma.is_null() && (*desc).flags & ffi::AV_PIX_FMT_FLAG_RGB as u64 == 0 {
+ return ffi::AVERROR(ffi::EINVAL);
+ }
+
+ let mut range = range;
+ if range == ffi::AVColorRange_AVCOL_RANGE_UNSPECIFIED {
+ range = match format {
+ ffi::AVPixelFormat_AV_PIX_FMT_YUVJ420P
+ | ffi::AVPixelFormat_AV_PIX_FMT_YUVJ422P
+ | ffi::AVPixelFormat_AV_PIX_FMT_YUVJ444P
+ | ffi::AVPixelFormat_AV_PIX_FMT_YUVJ411P
+ | ffi::AVPixelFormat_AV_PIX_FMT_YUVJ440P
+ | _ if csp == ffi::AVColorSpace_AVCOL_SPC_RGB => ffi::AVColorRange_AVCOL_RANGE_JPEG,
+ _ => ffi::AVColorRange_AVCOL_RANGE_MPEG,
+ };
+ }
+
+ if range != ffi::AVColorRange_AVCOL_RANGE_JPEG
+ && range != ffi::AVColorRange_AVCOL_RANGE_MPEG
+ {
+ return ffi::AVERROR(ffi::EINVAL);
+ }
+
+ let mut nb_planes = 0;
+ let mut pixelstep = [0i32; MAX_PLANES];
+ let mut depthb = 0;
+
+ for i in 0..(*desc).nb_components {
+ let c = &(*desc).comp[i as usize];
+ if c.depth < 8 || c.depth > 16 {
+ return ffi::AVERROR(ffi::ENOSYS);
+ }
+ if c.plane >= MAX_PLANES as i32 {
+ return ffi::AVERROR(ffi::ENOSYS);
+ }
+ if c.shift != 0 && (c.shift + c.depth) & 0x7 != 0 {
+ return ffi::AVERROR(ffi::ENOSYS);
+ }
+
+ let db = (c.depth + 7) / 8;
+ if depthb != 0 && depthb != db {
+ return ffi::AVERROR(ffi::ENOSYS);
+ }
+ depthb = db;
+ if db * (c.offset + 1) as i32 > 16 {
+ return ffi::AVERROR(ffi::ENOSYS);
+ }
+ if c.offset as i32 % db != 0 {
+ return ffi::AVERROR(ffi::ENOSYS);
+ }
+ if pixelstep[c.plane as usize] != 0 && pixelstep[c.plane as usize] != c.step as i32 {
+ return ffi::AVERROR(ffi::ENOSYS);
+ }
+ pixelstep[c.plane as usize] = c.step as i32;
+ if pixelstep[c.plane as usize] >= 8 {
+ return ffi::AVERROR(ffi::ENOSYS);
+ }
+ nb_planes = nb_planes.max((c.plane + 1) as u32);
+ }
+
+ std::ptr::write(
+ draw,
+ FFDrawContext {
+ desc,
+ format,
+ nb_planes,
+ range,
+ csp,
+ flags,
+ pixelstep,
+ hsub: [(*desc).log2_chroma_w; 4],
+ vsub: [(*desc).log2_chroma_h; 4],
+ hsub_max: (*desc).log2_chroma_w,
+ vsub_max: (*desc).log2_chroma_h,
+ rgb2yuv: [[0.0; 3]; 3],
+ },
+ );
+
+ if !luma.is_null() {
+ ff_fill_rgb2yuv_table(luma.as_ref().unwrap(), &mut (*draw).rgb2yuv);
+ }
+
+ 0
+ }
+}
+
+fn ff_fill_rgb2yuv_table(coeffs: &ffi::AVLumaCoefficients, rgb2yuv: &mut [[f64; 3usize]; 3usize]) {
+ let cr = ffi::av_q2d(coeffs.cr);
+ let cg = ffi::av_q2d(coeffs.cg);
+ let cb = ffi::av_q2d(coeffs.cb);
+
+ // Inline the ycgco matrix
+ if cr == 0.25 && cg == 0.5 && cb == 0.25 {
+ *rgb2yuv = [[0.25, 0.5, 0.25], [-0.25, 0.5, -0.25], [0.5, 0.0, -0.5]];
+ return;
+ }
+ // Inline the gbr matrix
+ else if cr == 1.0 && cg == 1.0 && cb == 1.0 {
+ *rgb2yuv = [[0.0, 1.0, 0.0], [0.0, -0.5, 0.5], [0.5, -0.5, 0.0]];
+ return;
+ }
+
+ rgb2yuv[0][0] = cr;
+ rgb2yuv[0][1] = cg;
+ rgb2yuv[0][2] = cb;
+
+ let bscale = 0.5 / (cb - 1.0);
+ let rscale = 0.5 / (cr - 1.0);
+
+ rgb2yuv[1][0] = bscale * cr;
+ rgb2yuv[1][1] = bscale * cg;
+ rgb2yuv[1][2] = 0.5;
+
+ rgb2yuv[2][0] = 0.5;
+ rgb2yuv[2][1] = rscale * cg;
+ rgb2yuv[2][2] = rscale * cb;
+}
+
+pub(crate) unsafe fn ff_draw_color(
+ draw: *mut FFDrawContext,
+ color: *mut FFDrawColor,
+ rgba: *const u8,
+) {
+ unsafe {
+ let draw = &*draw;
+ let color = &mut *color;
+ let desc = &*draw.desc;
+
+ let mut yuvad = [0.0; 4];
+ let mut rgbad = [0.0; 4];
+
+ // Copy rgba to color->rgba if they are not the same
+ if rgba != color.rgba.as_ptr() {
+ std::ptr::copy_nonoverlapping(rgba, color.rgba.as_mut_ptr(), 4);
+ }
+
+ // Initialize color->comp to zero
+ std::ptr::write_bytes(color.comp.as_mut_ptr(), 0, color.comp.len());
+
+ // Normalize RGBA values to the [0, 1] range
+ for i in 0..4 {
+ rgbad[i] = color.rgba[i] as f64 / 255.0;
+ }
+
+ // Convert RGB to YUV if necessary
+ if desc.flags & ffi::AV_PIX_FMT_FLAG_RGB as u64 != 0 {
+ yuvad[..3].copy_from_slice(&rgbad[..3]);
+ } else {
+ ff_matrix_mul_3x3_vec(&mut yuvad, &rgbad, &draw.rgb2yuv);
+ }
+
+ // Alpha channel
+ yuvad[3] = rgbad[3];
+
+ // Adjust YUV values according to the color range
+ for i in 0..3 {
+ let chroma = (desc.flags & ffi::AV_PIX_FMT_FLAG_RGB as u64 == 0) && i > 0;
+ if draw.range == ffi::AVColorRange_AVCOL_RANGE_MPEG {
+ yuvad[i] *= if chroma { 224.0 / 255.0 } else { 219.0 / 255.0 };
+ yuvad[i] += if chroma { 128.0 / 255.0 } else { 16.0 / 255.0 };
+ } else if chroma {
+ yuvad[i] += 0.5;
+ }
+ }
+
+ // Handle grayscale formats
+ if desc.nb_components <= 2 {
+ yuvad[1] = yuvad[3];
+ }
+
+ // Pack the YUV values into the color->comp array
+ for i in 0..desc.nb_components as usize {
+ let val = (yuvad[i] * ((1 << (desc.comp[i].depth + desc.comp[i].shift)) - 1) as f64
+ + 0.5)
+ .round() as u32;
+
+ if desc.comp[i].depth > 8 {
+ color.comp[desc.comp[i].plane as usize].u16_[desc.comp[i].offset as usize / 2] =
+ val as u16;
+ } else {
+ color.comp[desc.comp[i].plane as usize].u8_[desc.comp[i].offset as usize] =
+ val as u8;
+ }
+ }
+ }
+}
+
+fn ff_matrix_mul_3x3_vec(dst: &mut [f64; 4], src: &[f64; 4], mat: &[[f64; 3usize]; 3usize]) {
+ for i in 0..3 {
+ dst[i] = mat[i][0] * src[0] + mat[i][1] * src[1] + mat[i][2] * src[2];
+ }
+}
+
+fn pointer_at(
+ draw: &FFDrawContext,
+ data: &[*mut u8],
+ linesize: &[::std::os::raw::c_int],
+ plane: usize,
+ x: ::std::os::raw::c_int,
+ y: ::std::os::raw::c_int,
+) -> *mut u8 {
+ unsafe {
+ data[plane].offset(
+ ((y >> draw.vsub[plane]) * linesize[plane]
+ + (x >> draw.hsub[plane]) * draw.pixelstep[plane]) as isize,
+ )
+ }
+}
+
+pub(crate) unsafe fn ff_copy_rectangle2(
+ draw: *mut FFDrawContext,
+ dst: *mut *mut u8,
+ dst_linesize: *mut ::std::os::raw::c_int,
+ src: *mut *mut u8,
+ src_linesize: *mut ::std::os::raw::c_int,
+ dst_x: ::std::os::raw::c_int,
+ dst_y: ::std::os::raw::c_int,
+ src_x: ::std::os::raw::c_int,
+ src_y: ::std::os::raw::c_int,
+ w: ::std::os::raw::c_int,
+ h: ::std::os::raw::c_int,
+) {
+ unsafe {
+ let draw = &*draw;
+ let dst = std::slice::from_raw_parts_mut(dst, draw.nb_planes as usize);
+ let dst_linesize = std::slice::from_raw_parts_mut(dst_linesize, draw.nb_planes as usize);
+ let src = std::slice::from_raw_parts_mut(src, draw.nb_planes as usize);
+ let src_linesize = std::slice::from_raw_parts_mut(src_linesize, draw.nb_planes as usize);
+
+ for plane in 0..draw.nb_planes as usize {
+ let mut p = pointer_at(draw, src, src_linesize, plane, src_x, src_y);
+ let mut q = pointer_at(draw, dst, dst_linesize, plane, dst_x, dst_y);
+ let wp =
+ ((w + (1 << draw.hsub[plane]) - 1) >> draw.hsub[plane]) * draw.pixelstep[plane];
+ let hp = (h + (1 << draw.vsub[plane]) - 1) >> draw.vsub[plane];
+
+ for _ in 0..hp {
+ std::ptr::copy_nonoverlapping(p, q, wp as usize);
+ p = p.offset(src_linesize[plane] as isize);
+ q = q.offset(dst_linesize[plane] as isize);
+ }
+ }
+ }
+}
+
+pub(crate) unsafe fn ff_fill_rectangle(
+ draw: *mut FFDrawContext,
+ color: *mut FFDrawColor,
+ dst: *mut *mut u8,
+ dst_linesize: *mut ::std::os::raw::c_int,
+ dst_x: ::std::os::raw::c_int,
+ dst_y: ::std::os::raw::c_int,
+ w: ::std::os::raw::c_int,
+ h: ::std::os::raw::c_int,
+) {
+ unsafe {
+ let draw = &*draw;
+ let color = &mut *color;
+ let dst = std::slice::from_raw_parts_mut(dst, draw.nb_planes as usize);
+ let dst_linesize = std::slice::from_raw_parts_mut(dst_linesize, draw.nb_planes as usize);
+
+ for plane in 0..draw.nb_planes as usize {
+ let p0 = pointer_at(draw, dst, dst_linesize, plane, dst_x, dst_y);
+ let wp = ((w + (1 << draw.hsub[plane]) - 1) >> draw.hsub[plane]) as usize;
+ let hp = ((h + (1 << draw.vsub[plane]) - 1) >> draw.vsub[plane]) as usize;
+ if hp == 0 {
+ return;
+ }
+ let mut p = p0;
+
+ // Handle big-endian systems with depth > 8
+ if cfg!(target_endian = "big") && draw.desc.as_ref().unwrap().comp[0].depth > 8 {
+ for x in 0..(draw.pixelstep[plane] / 2) as usize {
+ color.comp[plane].u16_[x] = color.comp[plane].u16_[x].swap_bytes();
+ }
+ }
+
+ // Copy the first line from color
+ for _ in 0..wp {
+ std::ptr::copy_nonoverlapping(
+ color.comp[plane].u8_.as_ptr(),
+ p,
+ draw.pixelstep[plane] as usize,
+ );
+ p = p.offset(draw.pixelstep[plane] as isize);
+ }
+
+ // Copy the rest of the lines from the first line
+ let wp_bytes = (wp * draw.pixelstep[plane] as usize) as isize;
+ p = p0.offset(dst_linesize[plane] as isize);
+ for _ in 1..hp {
+ std::ptr::copy_nonoverlapping(p0, p, wp_bytes as usize);
+ p = p.offset(dst_linesize[plane] as isize);
+ }
+ }
+ }
+}
+vidformer/filter/builtin/ipc.rs
+1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192
use crate::dve::Error;
+use crate::filter::*;
+use std::collections::BTreeMap;
+use std::io::Read;
+use std::io::Write;
+
+/// Filter over IPC Socket
+///
+/// This filter sends requests to a filter server over a Unix socket.
+/// TODO: Wire protocol documentation
+pub struct IPC {
+ pub(crate) socket: String,
+ pub(crate) func: String,
+ pub(crate) state: parking_lot::Mutex<IPCFilterState>,
+}
+
+impl IPC {
+ pub fn new(socket: String, func: String) -> Result<Self, Error> {
+ let stream = std::os::unix::net::UnixStream::connect(&socket).map_err(|e| {
+ Error::FilterInternalError(format!(
+ "Failed to connect to IPC socket {}: {:?}",
+ &socket, e
+ ))
+ })?;
+
+ log::info!("Connected to IPC socket {}", &socket);
+ Ok(Self {
+ socket,
+ func,
+ state: parking_lot::Mutex::new(IPCFilterState { stream }),
+ })
+ }
+
+ pub fn via_map(config: &BTreeMap<String, String>) -> Result<Self, Error> {
+ let socket = config
+ .get("socket")
+ .ok_or_else(|| Error::Unknown("Missing 'socket' key".to_string()))?;
+
+ let func = config
+ .get("func")
+ .ok_or_else(|| Error::Unknown("Missing 'func' key".to_string()))?;
+
+ Self::new(socket.clone(), func.clone())
+ }
+}
+
+pub(crate) struct IPCFilterState {
+ pub(crate) stream: std::os::unix::net::UnixStream,
+}
+
+impl IPCFilterState {
+ pub(crate) fn rpc(&mut self, req: &[u8]) -> Result<Vec<u8>, Error> {
+ let req_len: u32 = req
+ .len()
+ .try_into()
+ .map_err(|_| Error::FilterInternalError("IPC request too large".to_string()))?;
+ self.stream.write_all(&req_len.to_be_bytes()).map_err(|e| {
+ Error::FilterInternalError(format!("Failed to write IPC request length: {:?}", e))
+ })?;
+ self.stream.write_all(req).map_err(|e| {
+ Error::FilterInternalError(format!("Failed to write IPC request: {:?}", e))
+ })?;
+ self.stream.flush().map_err(|e| {
+ Error::FilterInternalError(format!("Failed to flush IPC request: {:?}", e))
+ })?;
+
+ let mut response_len_bytes = [0u8; 4];
+ self.stream
+ .read_exact(&mut response_len_bytes)
+ .map_err(|e| {
+ Error::FilterInternalError(format!("Failed to read IPC response length: {:?}", e))
+ })?;
+ let response_len = u32::from_be_bytes(response_len_bytes);
+ let mut response_bytes = vec![0u8; response_len as usize];
+ self.stream.read_exact(&mut response_bytes).map_err(|e| {
+ Error::FilterInternalError(format!("Failed to read IPC response: {:?}", e))
+ })?;
+ Ok(response_bytes)
+ }
+}
+
+#[derive(Debug, serde::Serialize)]
+pub(crate) struct IPCFilterRequest {
+ pub(crate) func: String,
+ pub(crate) op: &'static str,
+ pub(crate) args: Vec<Val>,
+ pub(crate) kwargs: BTreeMap<String, Val>,
+}
+
+#[derive(Debug, serde::Deserialize)]
+pub(crate) struct IPCFilterResponse {
+ pub(crate) frame: Frame,
+}
+
+#[derive(Debug, serde::Serialize)]
+pub(crate) struct IPCFilterTypeRequest {
+ pub(crate) func: String,
+ pub(crate) op: &'static str,
+ pub(crate) args: Vec<Val>,
+ pub(crate) kwargs: BTreeMap<String, Val>,
+}
+
+#[derive(Debug, serde::Deserialize)]
+pub(crate) struct IPCFilterTypeResponse {
+ pub(crate) frame_type: FrameType,
+}
+
+impl crate::filter::Filter for IPC {
+ fn filter(
+ &self,
+ args: &[Val],
+ kwargs: &BTreeMap<String, Val>,
+ ) -> Result<Frame, crate::dve::Error> {
+ let request = IPCFilterRequest {
+ func: self.func.clone(),
+ op: "filter",
+ args: args.to_vec(),
+ kwargs: kwargs.clone(),
+ };
+ let req_bytes = rmp_serde::to_vec_named(&request).map_err(|e| {
+ Error::FilterInternalError(format!("Failed to serialize IPC request: {:?}", e))
+ })?;
+
+ let mut state = self.state.lock();
+ let response_bytes = state.rpc(&req_bytes)?;
+ drop(state);
+
+ let response: IPCFilterResponse = rmp_serde::from_slice(&response_bytes).map_err(|e| {
+ Error::FilterInternalError(format!(
+ "Failed to deserialize filter IPC response from {}: {:?}",
+ self.socket, e
+ ))
+ })?;
+
+ Ok(response.frame)
+ }
+
+ fn filter_type(
+ &self,
+ args: &[Val],
+ kwargs: &BTreeMap<String, Val>,
+ ) -> Result<FrameType, Error> {
+ for (i, arg) in args.iter().enumerate() {
+ if let Val::FrameType(ft) = arg {
+ if ft.format != ffi::AVPixelFormat_AV_PIX_FMT_RGB24 {
+ return Err(Error::FilterInternalError(format!(
+ "Unsupported pixel format {} in argument {}",
+ crate::util::pixel_fmt_str(ft.format),
+ i
+ )));
+ }
+ }
+ }
+
+ for (key, val) in kwargs.iter() {
+ if let Val::FrameType(ft) = val {
+ if ft.format != ffi::AVPixelFormat_AV_PIX_FMT_RGB24 {
+ return Err(Error::FilterInternalError(format!(
+ "Unsupported pixel format {:?} in keyword argument {}",
+ crate::util::pixel_fmt_str(ft.format),
+ key
+ )));
+ }
+ }
+ }
+
+ let request = IPCFilterTypeRequest {
+ func: self.func.clone(),
+ op: "filter_type",
+ args: args.to_vec(),
+ kwargs: kwargs.clone(),
+ };
+ let req_bytes = rmp_serde::to_vec_named(&request).map_err(|e| {
+ Error::FilterInternalError(format!("Failed to serialize IPC request: {:?}", e))
+ })?;
+
+ let mut state: parking_lot::lock_api::MutexGuard<parking_lot::RawMutex, IPCFilterState> =
+ self.state.lock();
+ let response_bytes = state.rpc(&req_bytes)?;
+ drop(state);
+
+ let response: IPCFilterTypeResponse =
+ rmp_serde::from_slice(&response_bytes).map_err(|e| {
+ Error::FilterInternalError(format!(
+ "Failed to deserialize filter_type IPC response from {}: {:?}",
+ self.socket, e
+ ))
+ })?;
+
+ Ok(response.frame_type)
+ }
+}
+vidformer/filter/cv2.rs
+1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +441 +442 +443 +444 +445 +446 +447 +448 +449 +450 +451 +452 +453 +454 +455 +456 +457 +458 +459 +460 +461 +462 +463 +464 +465 +466 +467 +468 +469 +470 +471 +472 +473 +474 +475 +476 +477 +478 +479 +480 +481 +482 +483 +484 +485 +486 +487 +488 +489 +490 +491 +492 +493 +494 +495 +496 +497 +498 +499 +500 +501 +502 +503 +504 +505 +506 +507 +508 +509 +510 +511 +512 +513 +514 +515 +516 +517 +518 +519 +520 +521 +522 +523 +524 +525 +526 +527 +528 +529 +530 +531 +532 +533 +534 +535 +536 +537 +538 +539 +540 +541 +542 +543 +544 +545 +546 +547 +548 +549 +550 +551 +552 +553 +554 +555 +556 +557 +558 +559 +560 +561 +562 +563 +564 +565 +566 +567 +568 +569 +570 +571 +572 +573 +574 +575 +576 +577 +578 +579 +580 +581 +582 +583 +584 +585 +586 +587 +588 +589 +590 +591 +592 +593 +594 +595 +596 +597 +598 +599 +600 +601 +602 +603 +604 +605 +606 +607 +608 +609 +610 +611 +612 +613 +614 +615 +616 +617 +618 +619 +620 +621 +622 +623 +624 +625 +626 +627 +628 +629 +630 +631 +632 +633 +634 +635 +636 +637 +638 +639 +640 +641 +642 +643 +644 +645 +646 +647 +648 +649 +650 +651 +652 +653 +654 +655 +656 +657 +658 +659 +660 +661 +662 +663 +664 +665 +666 +667 +668 +669 +670 +671 +672 +673 +674 +675 +676 +677 +678 +679 +680 +681 +682 +683 +684 +685 +686 +687 +688 +689 +690 +691 +692 +693 +694 +695 +696 +697 +698 +699 +700 +701 +702 +703 +704 +705 +706 +707 +708 +709 +710 +711 +712 +713 +714 +715 +716 +717 +718 +719 +720 +721 +722 +723 +724 +725 +726 +727 +728 +729 +730 +731 +732 +733 +734 +735 +736 +737 +738 +739 +740 +741 +742 +743 +744 +745 +746 +747 +748 +749 +750 +751 +752 +753 +754 +755 +756 +757 +758 +759 +760 +761 +762 +763 +764 +765 +766 +767 +768 +769 +770 +771 +772 +773 +774 +775 +776 +777 +778 +779 +780 +781 +782 +783 +784 +785 +786 +787 +788 +789 +790 +791 +792 +793 +794 +795 +796 +797 +798 +799 +800 +801 +802 +803 +804 +805 +806 +807 +808 +809 +810 +811 +812 +813 +814 +815 +816 +817 +818 +819 +820 +821 +822 +823 +824 +825 +826 +827 +828 +829 +830 +831 +832 +833 +834 +835 +836 +837 +838 +839 +840 +841 +842 +843 +844 +845 +846 +847 +848 +849 +850 +851 +852 +853 +854 +855 +856 +857 +858 +859 +860 +861 +862 +863 +864 +865 +866 +867 +868 +869 +870 +871 +872 +873 +874 +875 +876 +877 +878 +879 +880 +881 +882 +883 +884 +885 +886 +887 +888 +889 +890 +891 +892 +893 +894 +895 +896 +897 +898 +899 +900 +901 +902 +903 +904 +905 +906 +907 +908 +909 +910 +911 +912 +913 +914 +915 +916 +917 +918 +919 +920 +921 +922 +923 +924 +925 +926 +927 +928 +929 +930 +931 +932 +933 +934 +935 +936 +937 +938 +939 +940 +941 +942 +943 +944 +945 +946 +947 +948 +949 +950 +951 +952 +953 +954 +955 +956 +957 +958 +959 +960 +961 +962 +963 +964 +965 +966 +967 +968 +969 +970 +971 +972 +973 +974 +975 +976 +977 +978 +979 +980 +981 +982 +983 +984 +985 +986 +987 +988 +989 +990 +991 +992 +993 +994 +995 +996 +997 +998 +999 +1000 +1001 +1002 +1003 +1004 +1005 +1006 +1007 +1008 +1009 +1010 +1011 +1012 +1013 +1014 +1015 +1016 +1017 +1018 +1019 +1020 +1021 +1022 +1023 +1024 +1025 +1026 +1027 +1028 +1029 +1030 +1031 +1032 +1033 +1034 +1035 +1036 +1037 +1038 +1039 +1040 +1041 +1042 +1043 +1044 +1045 +1046 +1047 +1048 +1049 +1050 +1051 +1052 +1053 +1054 +1055 +1056 +1057 +1058 +1059 +1060 +1061 +1062 +1063 +1064 +1065 +1066 +1067 +1068 +1069 +1070 +1071 +1072 +1073 +1074 +1075 +1076 +1077 +1078 +1079 +1080 +1081 +1082 +1083 +1084 +1085 +1086 +1087 +1088 +1089 +1090 +1091 +1092 +1093 +1094 +1095 +1096 +1097 +1098 +1099
//! vidformer cv2 filters
+
+use crate::dve;
+use crate::dve::AVFrame;
+use crate::filter;
+use crate::filter::Val;
+use crate::filter::*;
+use filter::filter_utils::*;
+use opencv::imgproc;
+use opencv::prelude::MatTrait;
+use rusty_ffmpeg::ffi;
+use std::collections::BTreeMap;
+
+/// vidformer cv2 filters
+pub fn filters() -> BTreeMap<String, Box<dyn filter::Filter>> {
+ let mut filters: BTreeMap<String, Box<dyn filter::Filter>> = BTreeMap::new();
+ filters.insert("cv2.rectangle".to_string(), Box::new(Rectangle {}));
+ filters.insert("cv2.putText".to_string(), Box::new(PutText {}));
+ filters.insert("cv2.arrowedLine".to_string(), Box::new(ArrowedLine {}));
+ filters.insert("cv2.line".to_string(), Box::new(Line {}));
+ filters.insert("cv2.circle".to_string(), Box::new(Circle {}));
+ filters.insert("cv2.setTo".to_string(), Box::new(SetTo {}));
+ filters.insert("cv2.addWeighted".to_string(), Box::new(AddWeighted {}));
+ filters
+}
+
+pub struct Rectangle {}
+
+struct RectangleArgs {
+ img: filter_utils::FrameArg,
+ pt1: (i32, i32),
+ pt2: (i32, i32),
+ color: [f64; 4],
+ thickness: i32,
+ linetype: i32,
+ shift: i32,
+}
+
+impl Rectangle {
+ fn args(
+ args: &[filter::Val],
+ kwargs: &BTreeMap<std::string::String, filter::Val>,
+ ) -> Result<RectangleArgs, String> {
+ let signature = filter_utils::FunctionSignature {
+ parameters: vec![
+ Parameter::Positional { name: "img" },
+ Parameter::Positional { name: "pt1" },
+ Parameter::Positional { name: "pt2" },
+ Parameter::Positional { name: "color" },
+ Parameter::PositionalOptional {
+ name: "thickness",
+ default_value: Val::Int(1),
+ },
+ Parameter::PositionalOptional {
+ name: "lineType",
+ default_value: Val::Int(8),
+ },
+ Parameter::PositionalOptional {
+ name: "shift",
+ default_value: Val::Int(0),
+ },
+ ],
+ };
+
+ let kwargs = kwargs.clone();
+ let args = args.to_vec();
+ let parsed_args = filter_utils::parse_arguments(&signature, args, kwargs)?;
+
+ let img = match parsed_args.get("img") {
+ Some(Val::Frame(frame)) => filter_utils::FrameArg::Frame(frame.clone()),
+ Some(Val::FrameType(frame_type)) => {
+ filter_utils::FrameArg::FrameType(frame_type.clone())
+ }
+ x => {
+ dbg! {x};
+ return Err("Expected 'img' to be a Frame".into());
+ }
+ };
+
+ // pt1 is a list of two integers
+ let pt1 = filter_utils::get_point(&parsed_args, "pt1")?;
+
+ // pt2 is a list of two integers
+ let pt2 = filter_utils::get_point(&parsed_args, "pt2")?;
+
+ // color is a list of four floats
+ let color = filter_utils::get_color(&parsed_args)?;
+
+ // thickness is an integer
+ let thickness = match parsed_args.get("thickness") {
+ Some(Val::Int(value)) => *value as i32,
+ _ => return Err("Expected 'thickness' to be an integer".into()),
+ };
+
+ // lineType is an integer
+ let linetype = match parsed_args.get("lineType") {
+ Some(Val::Int(value)) => *value as i32,
+ _ => return Err("Expected 'lineType' to be an integer".into()),
+ };
+
+ // shift is an integer
+ let shift = match parsed_args.get("shift") {
+ Some(Val::Int(value)) => *value as i32,
+ _ => return Err("Expected 'shift' to be an integer".into()),
+ };
+
+ Ok(RectangleArgs {
+ img,
+ pt1,
+ pt2,
+ color,
+ thickness,
+ linetype,
+ shift,
+ })
+ }
+}
+
+impl filter::Filter for Rectangle {
+ fn filter(
+ &self,
+ args: &[filter::Val],
+ kwargs: &BTreeMap<std::string::String, filter::Val>,
+ ) -> std::result::Result<filter::Frame, dve::Error> {
+ let opts: RectangleArgs = match Self::args(args, kwargs) {
+ Ok(args) => args,
+ Err(err) => return Err(dve::Error::AVError(err)),
+ };
+
+ let img = opts.img.unwrap_frame();
+ let (width, height) = (img.width, img.height);
+ debug_assert_eq!(img.format, ffi::AVPixelFormat_AV_PIX_FMT_RGB24);
+
+ let mut mat = filter_utils::frame_to_mat_rgb24(&img, width, height);
+
+ let pt1 = opencv::core::Point::new(opts.pt1.0, opts.pt1.1);
+ let pt2 = opencv::core::Point::new(opts.pt2.0, opts.pt2.1);
+
+ let color =
+ opencv::core::Scalar::new(opts.color[0], opts.color[1], opts.color[2], opts.color[3]);
+
+ imgproc::rectangle_points(
+ &mut mat,
+ pt1,
+ pt2,
+ color,
+ opts.thickness,
+ opts.linetype,
+ opts.shift,
+ )
+ .unwrap();
+
+ let f = match filter_utils::mat_to_frame_rgb24(mat, width, height) {
+ Ok(value) => value,
+ Err(value) => return value,
+ };
+
+ Ok(filter::Frame::new(AVFrame { inner: f }))
+ }
+
+ fn filter_type(
+ &self,
+ args: &[filter::Val],
+ kwargs: &BTreeMap<std::string::String, filter::Val>,
+ ) -> std::result::Result<filter::FrameType, dve::Error> {
+ let opts: RectangleArgs = match Self::args(args, kwargs) {
+ Ok(args) => args,
+ Err(err) => return Err(dve::Error::AVError(err)),
+ };
+
+ if opts.img.unwrap_frame_type().format != ffi::AVPixelFormat_AV_PIX_FMT_RGB24 {
+ return Err(dve::Error::AVError("Expected RGB24 frame".into()));
+ }
+
+ Ok(opts.img.unwrap_frame_type())
+ }
+}
+
+pub struct PutText {}
+
+struct PutTextArgs {
+ img: filter_utils::FrameArg,
+ text: String,
+ org: (i32, i32),
+ font_face: i32,
+ font_scale: f64,
+ color: [f64; 4],
+ thickness: i32,
+ linetype: i32,
+ bottom_left_origin: bool,
+}
+
+impl PutText {
+ fn args(
+ args: &[filter::Val],
+ kwargs: &BTreeMap<std::string::String, filter::Val>,
+ ) -> Result<PutTextArgs, String> {
+ let signature = filter_utils::FunctionSignature {
+ parameters: vec![
+ Parameter::Positional { name: "img" },
+ Parameter::Positional { name: "text" },
+ Parameter::Positional { name: "org" },
+ Parameter::Positional { name: "fontFace" },
+ Parameter::Positional { name: "fontScale" },
+ Parameter::Positional { name: "color" },
+ Parameter::PositionalOptional {
+ name: "thickness",
+ default_value: Val::Int(1),
+ },
+ Parameter::PositionalOptional {
+ name: "lineType",
+ default_value: Val::Int(8),
+ },
+ Parameter::PositionalOptional {
+ name: "bottomLeftOrigin",
+ default_value: Val::Bool(false),
+ },
+ ],
+ };
+
+ let kwargs = kwargs.clone();
+ let args: Vec<Val> = args.to_vec();
+ let parsed_args = filter_utils::parse_arguments(&signature, args, kwargs)?;
+
+ let img = match parsed_args.get("img") {
+ Some(Val::Frame(frame)) => filter_utils::FrameArg::Frame(frame.clone()),
+ Some(Val::FrameType(frame_type)) => {
+ filter_utils::FrameArg::FrameType(frame_type.clone())
+ }
+ x => {
+ dbg! {x};
+ return Err("Expected 'img' to be a Frame".into());
+ }
+ };
+
+ // text is a string
+ let text = match parsed_args.get("text") {
+ Some(Val::String(value)) => value.clone(),
+ _ => return Err("Expected 'text' to be a string".into()),
+ };
+
+ // org is a list of two integers
+ let org = filter_utils::get_point(&parsed_args, "org")?;
+
+ // fontFace is an integer
+ let font_face = match parsed_args.get("fontFace") {
+ Some(Val::Int(value)) => *value as i32,
+ _ => return Err("Expected 'fontFace' to be an integer".into()),
+ };
+
+ // fontScale is a float
+ let font_scale = match parsed_args.get("fontScale") {
+ Some(Val::Float(value)) => *value,
+ _ => return Err("Expected 'fontScale' to be a float".into()),
+ };
+
+ // color is a list of four floats
+ let color = filter_utils::get_color(&parsed_args)?;
+
+ // thickness is an integer
+ let thickness = match parsed_args.get("thickness") {
+ Some(Val::Int(value)) => *value as i32,
+ _ => return Err("Expected 'thickness' to be an integer".into()),
+ };
+
+ // lineType is an integer
+ let linetype = match parsed_args.get("lineType") {
+ Some(Val::Int(value)) => *value as i32,
+ _ => return Err("Expected 'lineType' to be an integer".into()),
+ };
+
+ // bottomLeftOrigin is a boolean
+ let bottom_left_origin = match parsed_args.get("bottomLeftOrigin") {
+ Some(Val::Bool(value)) => *value,
+ _ => return Err("Expected 'bottomLeftOrigin' to be a boolean".into()),
+ };
+
+ Ok(PutTextArgs {
+ img,
+ text,
+ org,
+ font_face,
+ font_scale,
+ color,
+ thickness,
+ linetype,
+ bottom_left_origin,
+ })
+ }
+}
+
+impl filter::Filter for PutText {
+ fn filter(
+ &self,
+ args: &[filter::Val],
+ kwargs: &BTreeMap<std::string::String, filter::Val>,
+ ) -> std::result::Result<filter::Frame, dve::Error> {
+ let opts: PutTextArgs = match Self::args(args, kwargs) {
+ Ok(args) => args,
+ Err(err) => return Err(dve::Error::AVError(err)),
+ };
+
+ let img = opts.img.unwrap_frame();
+ let (width, height) = (img.width, img.height);
+ debug_assert_eq!(img.format, ffi::AVPixelFormat_AV_PIX_FMT_RGB24);
+
+ let mut mat = filter_utils::frame_to_mat_rgb24(&img, width, height);
+
+ let org = opencv::core::Point::new(opts.org.0, opts.org.1);
+ let color =
+ opencv::core::Scalar::new(opts.color[0], opts.color[1], opts.color[2], opts.color[3]);
+
+ imgproc::put_text(
+ &mut mat,
+ &opts.text,
+ org,
+ opts.font_face,
+ opts.font_scale,
+ color,
+ opts.thickness,
+ opts.linetype,
+ opts.bottom_left_origin,
+ )
+ .unwrap();
+
+ let f = match filter_utils::mat_to_frame_rgb24(mat, width, height) {
+ Ok(value) => value,
+ Err(value) => return value,
+ };
+
+ Ok(filter::Frame::new(AVFrame { inner: f }))
+ }
+
+ fn filter_type(
+ &self,
+ args: &[filter::Val],
+ kwargs: &BTreeMap<std::string::String, filter::Val>,
+ ) -> std::result::Result<filter::FrameType, dve::Error> {
+ let opts: PutTextArgs = match Self::args(args, kwargs) {
+ Ok(args) => args,
+ Err(err) => return Err(dve::Error::AVError(err)),
+ };
+
+ if opts.img.unwrap_frame_type().format != ffi::AVPixelFormat_AV_PIX_FMT_RGB24 {
+ return Err(dve::Error::AVError("Expected RGB24 frame".into()));
+ }
+
+ Ok(opts.img.unwrap_frame_type())
+ }
+}
+
+pub struct ArrowedLine {}
+
+struct ArrowedLineArgs {
+ img: FrameArg,
+ pt1: (i32, i32),
+ pt2: (i32, i32),
+ color: [f64; 4],
+ thickness: i32,
+ linetype: i32,
+ shift: i32,
+ tip_length: f64,
+}
+
+impl ArrowedLine {
+ fn args(
+ args: &[filter::Val],
+ kwargs: &BTreeMap<std::string::String, filter::Val>,
+ ) -> Result<ArrowedLineArgs, String> {
+ let signature = FunctionSignature {
+ parameters: vec![
+ Parameter::Positional { name: "img" },
+ Parameter::Positional { name: "pt1" },
+ Parameter::Positional { name: "pt2" },
+ Parameter::Positional { name: "color" },
+ Parameter::PositionalOptional {
+ name: "thickness",
+ default_value: Val::Int(1),
+ },
+ Parameter::PositionalOptional {
+ name: "lineType",
+ default_value: Val::Int(8),
+ },
+ Parameter::PositionalOptional {
+ name: "shift",
+ default_value: Val::Int(0),
+ },
+ Parameter::PositionalOptional {
+ name: "tipLength",
+ default_value: Val::Float(0.1),
+ },
+ ],
+ };
+
+ let kwargs = kwargs.clone();
+ let args = args.to_vec();
+ let parsed_args = parse_arguments(&signature, args, kwargs)?;
+
+ let img = match parsed_args.get("img") {
+ Some(Val::Frame(frame)) => FrameArg::Frame(frame.clone()),
+ Some(Val::FrameType(frame_type)) => FrameArg::FrameType(frame_type.clone()),
+ x => {
+ dbg! {x};
+ return Err("Expected 'img' to be a Frame".into());
+ }
+ };
+
+ // pt1 is a list of two integers
+ let pt1 = get_point(&parsed_args, "pt1")?;
+
+ // pt2 is a list of two integers
+ let pt2 = get_point(&parsed_args, "pt2")?;
+
+ // color is a list of four floats
+ let color = get_color(&parsed_args)?;
+
+ // thickness is an integer
+ let thickness = match parsed_args.get("thickness") {
+ Some(Val::Int(value)) => *value as i32,
+ _ => return Err("Expected 'thickness' to be an integer".into()),
+ };
+
+ // lineType is an integer
+ let linetype = match parsed_args.get("lineType") {
+ Some(Val::Int(value)) => *value as i32,
+ _ => return Err("Expected 'lineType' to be an integer".into()),
+ };
+
+ // shift is an integer
+ let shift = match parsed_args.get("shift") {
+ Some(Val::Int(value)) => *value as i32,
+ _ => return Err("Expected 'shift' to be an integer".into()),
+ };
+
+ // tipLength is a float
+ let tip_length = match parsed_args.get("tipLength") {
+ Some(Val::Float(value)) => *value,
+ _ => return Err("Expected 'tipLength' to be a float".into()),
+ };
+
+ Ok(ArrowedLineArgs {
+ img,
+ pt1,
+ pt2,
+ color,
+ thickness,
+ linetype,
+ shift,
+ tip_length,
+ })
+ }
+}
+
+impl filter::Filter for ArrowedLine {
+ fn filter(
+ &self,
+ args: &[filter::Val],
+ kwargs: &BTreeMap<std::string::String, filter::Val>,
+ ) -> std::result::Result<filter::Frame, dve::Error> {
+ let opts: ArrowedLineArgs = match Self::args(args, kwargs) {
+ Ok(args) => args,
+ Err(err) => return Err(dve::Error::AVError(err)),
+ };
+
+ let img = opts.img.unwrap_frame();
+ let (width, height) = (img.width, img.height);
+ debug_assert_eq!(img.format, ffi::AVPixelFormat_AV_PIX_FMT_RGB24);
+
+ let mut mat = frame_to_mat_rgb24(&img, width, height);
+
+ let pt1 = opencv::core::Point::new(opts.pt1.0, opts.pt1.1);
+ let pt2 = opencv::core::Point::new(opts.pt2.0, opts.pt2.1);
+ let color =
+ opencv::core::Scalar::new(opts.color[0], opts.color[1], opts.color[2], opts.color[3]);
+
+ imgproc::arrowed_line(
+ &mut mat,
+ pt1,
+ pt2,
+ color,
+ opts.thickness,
+ opts.linetype,
+ opts.shift,
+ opts.tip_length,
+ )
+ .unwrap();
+
+ let f = match mat_to_frame_rgb24(mat, width, height) {
+ Ok(value) => value,
+ Err(value) => return value,
+ };
+
+ Ok(filter::Frame::new(AVFrame { inner: f }))
+ }
+
+ fn filter_type(
+ &self,
+ args: &[filter::Val],
+ kwargs: &BTreeMap<std::string::String, filter::Val>,
+ ) -> std::result::Result<filter::FrameType, dve::Error> {
+ let opts: ArrowedLineArgs = match Self::args(args, kwargs) {
+ Ok(args) => args,
+ Err(err) => return Err(dve::Error::AVError(err)),
+ };
+
+ if opts.img.unwrap_frame_type().format != ffi::AVPixelFormat_AV_PIX_FMT_RGB24 {
+ return Err(dve::Error::AVError("Expected RGB24 frame".into()));
+ }
+
+ Ok(opts.img.unwrap_frame_type())
+ }
+}
+
+pub struct Line {}
+
+struct LineArgs {
+ img: FrameArg,
+ pt1: (i32, i32),
+ pt2: (i32, i32),
+ color: [f64; 4],
+ thickness: i32,
+ linetype: i32,
+ shift: i32,
+}
+
+impl Line {
+ fn args(
+ args: &[filter::Val],
+ kwargs: &BTreeMap<std::string::String, filter::Val>,
+ ) -> Result<LineArgs, String> {
+ let signature = FunctionSignature {
+ parameters: vec![
+ Parameter::Positional { name: "img" },
+ Parameter::Positional { name: "pt1" },
+ Parameter::Positional { name: "pt2" },
+ Parameter::Positional { name: "color" },
+ Parameter::PositionalOptional {
+ name: "thickness",
+ default_value: Val::Int(1),
+ },
+ Parameter::PositionalOptional {
+ name: "lineType",
+ default_value: Val::Int(8),
+ },
+ Parameter::PositionalOptional {
+ name: "shift",
+ default_value: Val::Int(0),
+ },
+ ],
+ };
+
+ let kwargs = kwargs.clone();
+ let args = args.to_vec();
+ let parsed_args = parse_arguments(&signature, args, kwargs)?;
+
+ let img = match parsed_args.get("img") {
+ Some(Val::Frame(frame)) => FrameArg::Frame(frame.clone()),
+ Some(Val::FrameType(frame_type)) => FrameArg::FrameType(frame_type.clone()),
+ x => {
+ dbg! {x};
+ return Err("Expected 'img' to be a Frame".into());
+ }
+ };
+
+ // pt1 is a list of two integers
+ let pt1 = get_point(&parsed_args, "pt1")?;
+
+ // pt2 is a list of two integers
+ let pt2 = get_point(&parsed_args, "pt2")?;
+
+ // color is a list of four floats
+ let color = get_color(&parsed_args)?;
+
+ // thickness is an integer
+ let thickness = match parsed_args.get("thickness") {
+ Some(Val::Int(value)) => *value as i32,
+ _ => return Err("Expected 'thickness' to be an integer".into()),
+ };
+
+ // lineType is an integer
+ let linetype = match parsed_args.get("lineType") {
+ Some(Val::Int(value)) => *value as i32,
+ _ => return Err("Expected 'lineType' to be an integer".into()),
+ };
+
+ // shift is an integer
+ let shift = match parsed_args.get("shift") {
+ Some(Val::Int(value)) => *value as i32,
+ _ => return Err("Expected 'shift' to be an integer".into()),
+ };
+
+ Ok(LineArgs {
+ img,
+ pt1,
+ pt2,
+ color,
+ thickness,
+ linetype,
+ shift,
+ })
+ }
+}
+
+impl filter::Filter for Line {
+ fn filter(
+ &self,
+ args: &[filter::Val],
+ kwargs: &BTreeMap<std::string::String, filter::Val>,
+ ) -> std::result::Result<filter::Frame, dve::Error> {
+ let opts: LineArgs = match Self::args(args, kwargs) {
+ Ok(args) => args,
+ Err(err) => return Err(dve::Error::AVError(err)),
+ };
+
+ let img = opts.img.unwrap_frame();
+ let (width, height) = (img.width, img.height);
+ debug_assert_eq!(img.format, ffi::AVPixelFormat_AV_PIX_FMT_RGB24);
+
+ let mut mat = filter_utils::frame_to_mat_rgb24(&img, width, height);
+
+ let pt1 = opencv::core::Point::new(opts.pt1.0, opts.pt1.1);
+ let pt2 = opencv::core::Point::new(opts.pt2.0, opts.pt2.1);
+ let color =
+ opencv::core::Scalar::new(opts.color[0], opts.color[1], opts.color[2], opts.color[3]);
+
+ imgproc::line(
+ &mut mat,
+ pt1,
+ pt2,
+ color,
+ opts.thickness,
+ opts.linetype,
+ opts.shift,
+ )
+ .unwrap();
+
+ let f = match filter_utils::mat_to_frame_rgb24(mat, width, height) {
+ Ok(value) => value,
+ Err(value) => return value,
+ };
+
+ Ok(filter::Frame::new(AVFrame { inner: f }))
+ }
+
+ fn filter_type(
+ &self,
+ args: &[filter::Val],
+ kwargs: &BTreeMap<std::string::String, filter::Val>,
+ ) -> std::result::Result<filter::FrameType, dve::Error> {
+ let opts: LineArgs = match Self::args(args, kwargs) {
+ Ok(args) => args,
+ Err(err) => return Err(dve::Error::AVError(err)),
+ };
+
+ if opts.img.unwrap_frame_type().format != ffi::AVPixelFormat_AV_PIX_FMT_RGB24 {
+ return Err(dve::Error::AVError("Expected RGB24 frame".into()));
+ }
+
+ Ok(opts.img.unwrap_frame_type())
+ }
+}
+
+pub struct Circle {}
+
+struct CircleArgs {
+ img: filter_utils::FrameArg,
+ center: (i32, i32),
+ radius: i32,
+ color: [f64; 4],
+ thickness: i32,
+ linetype: i32,
+ shift: i32,
+}
+
+impl Circle {
+ fn args(
+ args: &[filter::Val],
+ kwargs: &BTreeMap<std::string::String, filter::Val>,
+ ) -> Result<CircleArgs, String> {
+ let signature = filter_utils::FunctionSignature {
+ parameters: vec![
+ Parameter::Positional { name: "img" },
+ Parameter::Positional { name: "center" },
+ Parameter::Positional { name: "radius" },
+ Parameter::Positional { name: "color" },
+ Parameter::PositionalOptional {
+ name: "thickness",
+ default_value: Val::Int(1),
+ },
+ Parameter::PositionalOptional {
+ name: "lineType",
+ default_value: Val::Int(8),
+ },
+ Parameter::PositionalOptional {
+ name: "shift",
+ default_value: Val::Int(0),
+ },
+ ],
+ };
+
+ let kwargs = kwargs.clone();
+ let args = args.to_vec();
+ let parsed_args = filter_utils::parse_arguments(&signature, args, kwargs)?;
+
+ let img = match parsed_args.get("img") {
+ Some(Val::Frame(frame)) => filter_utils::FrameArg::Frame(frame.clone()),
+ Some(Val::FrameType(frame_type)) => {
+ filter_utils::FrameArg::FrameType(frame_type.clone())
+ }
+ x => {
+ dbg! {x};
+ return Err("Expected 'img' to be a Frame".into());
+ }
+ };
+
+ // center is a list of two integers
+ let center = filter_utils::get_point(&parsed_args, "center")?;
+
+ // radius is an integer
+ let radius = match parsed_args.get("radius") {
+ Some(Val::Int(value)) => *value as i32,
+ _ => return Err("Expected 'radius' to be an integer".into()),
+ };
+
+ // color is a list of four floats
+ let color = filter_utils::get_color(&parsed_args)?;
+
+ // thickness is an integer
+ let thickness = match parsed_args.get("thickness") {
+ Some(Val::Int(value)) => *value as i32,
+ _ => return Err("Expected 'thickness' to be an integer".into()),
+ };
+
+ // lineType is an integer
+ let linetype = match parsed_args.get("lineType") {
+ Some(Val::Int(value)) => *value as i32,
+ _ => return Err("Expected 'lineType' to be an integer".into()),
+ };
+
+ // shift is an integer
+ let shift = match parsed_args.get("shift") {
+ Some(Val::Int(value)) => *value as i32,
+ _ => return Err("Expected 'shift' to be an integer".into()),
+ };
+
+ Ok(CircleArgs {
+ img,
+ center,
+ radius,
+ color,
+ thickness,
+ linetype,
+ shift,
+ })
+ }
+}
+
+impl filter::Filter for Circle {
+ fn filter(
+ &self,
+ args: &[filter::Val],
+ kwargs: &BTreeMap<std::string::String, filter::Val>,
+ ) -> std::result::Result<filter::Frame, dve::Error> {
+ let opts: CircleArgs = match Self::args(args, kwargs) {
+ Ok(args) => args,
+ Err(err) => return Err(dve::Error::AVError(err)),
+ };
+
+ let img = opts.img.unwrap_frame();
+ let (width, height) = (img.width, img.height);
+ debug_assert_eq!(img.format, ffi::AVPixelFormat_AV_PIX_FMT_RGB24);
+
+ let mut mat = filter_utils::frame_to_mat_rgb24(&img, width, height);
+
+ let center = opencv::core::Point::new(opts.center.0, opts.center.1);
+ let color =
+ opencv::core::Scalar::new(opts.color[0], opts.color[1], opts.color[2], opts.color[3]);
+
+ imgproc::circle(
+ &mut mat,
+ center,
+ opts.radius,
+ color,
+ opts.thickness,
+ opts.linetype,
+ opts.shift,
+ )
+ .unwrap();
+
+ let f = match filter_utils::mat_to_frame_rgb24(mat, width, height) {
+ Ok(value) => value,
+ Err(value) => return value,
+ };
+
+ Ok(filter::Frame::new(AVFrame { inner: f }))
+ }
+
+ fn filter_type(
+ &self,
+ args: &[filter::Val],
+ kwargs: &BTreeMap<std::string::String, filter::Val>,
+ ) -> std::result::Result<filter::FrameType, dve::Error> {
+ let opts: CircleArgs = match Self::args(args, kwargs) {
+ Ok(args) => args,
+ Err(err) => return Err(dve::Error::AVError(err)),
+ };
+
+ if opts.img.unwrap_frame_type().format != ffi::AVPixelFormat_AV_PIX_FMT_RGB24 {
+ return Err(dve::Error::AVError("Expected RGB24 frame".into()));
+ }
+
+ Ok(opts.img.unwrap_frame_type())
+ }
+}
+
+pub struct SetTo {}
+
+struct SetToArgs {
+ img: filter_utils::FrameArg,
+ color: [f64; 4],
+ mask: filter_utils::FrameArg,
+}
+
+impl SetTo {
+ fn args(
+ args: &[Val],
+ kwargs: &BTreeMap<std::string::String, Val>,
+ ) -> Result<SetToArgs, String> {
+ let signature = filter_utils::FunctionSignature {
+ parameters: vec![
+ Parameter::Positional { name: "img" },
+ Parameter::Positional { name: "color" },
+ Parameter::Positional { name: "mask" },
+ ],
+ };
+
+ let kwargs = kwargs.clone();
+ let args = args.to_vec();
+ let parsed_args = filter_utils::parse_arguments(&signature, args, kwargs)?;
+
+ let img = match parsed_args.get("img") {
+ Some(Val::Frame(frame)) => filter_utils::FrameArg::Frame(frame.clone()),
+ Some(Val::FrameType(frame_type)) => {
+ filter_utils::FrameArg::FrameType(frame_type.clone())
+ }
+ x => {
+ dbg! {x};
+ return Err("Expected 'img' to be a Frame".into());
+ }
+ };
+
+ let color = filter_utils::get_color(&parsed_args)?;
+
+ let mask = match parsed_args.get("mask") {
+ Some(Val::Frame(frame)) => filter_utils::FrameArg::Frame(frame.clone()),
+ Some(Val::FrameType(frame_type)) => {
+ filter_utils::FrameArg::FrameType(frame_type.clone())
+ }
+ x => {
+ dbg! {x};
+ return Err("Expected 'mask' to be a Frame".into());
+ }
+ };
+
+ Ok(SetToArgs { img, mask, color })
+ }
+}
+
+impl Filter for SetTo {
+ fn filter(
+ &self,
+ args: &[Val],
+ kwargs: &BTreeMap<std::string::String, Val>,
+ ) -> std::result::Result<Frame, crate::dve::Error> {
+ let opts: SetToArgs = match Self::args(args, kwargs) {
+ Ok(args) => args,
+ Err(err) => return Err(crate::dve::Error::AVError(err)),
+ };
+
+ let img = opts.img.unwrap_frame();
+ let mask = opts.mask.unwrap_frame();
+
+ let mut img_mat = filter_utils::frame_to_mat_rgb24(&img, img.width, img.height);
+ let mask_mat = filter_utils::frame_to_mat_gray8(&mask, mask.width, mask.height);
+
+ let color =
+ opencv::core::Scalar::new(opts.color[0], opts.color[1], opts.color[2], opts.color[3]);
+
+ // set all pixels in img_mat to color where mask_mat is not zero
+ img_mat.set_to(&color, &mask_mat).unwrap();
+
+ let f = match filter_utils::mat_to_frame_rgb24(img_mat, img.width, img.height) {
+ Ok(value) => value,
+ Err(value) => return value,
+ };
+
+ Ok(Frame::new(AVFrame { inner: f }))
+ }
+
+ fn filter_type(
+ &self,
+ args: &[Val],
+ kwargs: &BTreeMap<std::string::String, Val>,
+ ) -> std::result::Result<FrameType, crate::dve::Error> {
+ let opts: SetToArgs = match Self::args(args, kwargs) {
+ Ok(args) => args,
+ Err(err) => return Err(crate::dve::Error::AVError(err)),
+ };
+
+ // check img is RGB24
+ if opts.img.unwrap_frame_type().format != ffi::AVPixelFormat_AV_PIX_FMT_RGB24 {
+ return Err(crate::dve::Error::FilterInternalError(
+ "Expected img to be an RGB24 frame".into(),
+ ));
+ }
+
+ // check mask is grayscale
+ if opts.mask.unwrap_frame_type().format != ffi::AVPixelFormat_AV_PIX_FMT_GRAY8 {
+ return Err(crate::dve::Error::FilterInternalError(
+ "Expected mask to be a grayscale frame".into(),
+ ));
+ }
+
+ // check mask is same size as img
+ if opts.img.unwrap_frame_type().width != opts.mask.unwrap_frame_type().width
+ || opts.img.unwrap_frame_type().height != opts.mask.unwrap_frame_type().height
+ {
+ return Err(crate::dve::Error::FilterInternalError(
+ "Expected mask to be the same size as img".into(),
+ ));
+ }
+
+ Ok(opts.img.unwrap_frame_type())
+ }
+}
+
+pub struct AddWeighted {}
+
+struct AddWeightedArgs {
+ src1: filter_utils::FrameArg,
+ alpha: f64,
+ src2: filter_utils::FrameArg,
+ beta: f64,
+ gamma: f64,
+}
+
+impl AddWeighted {
+ fn args(
+ args: &[Val],
+ kwargs: &BTreeMap<std::string::String, Val>,
+ ) -> Result<AddWeightedArgs, String> {
+ let signature = filter_utils::FunctionSignature {
+ parameters: vec![
+ Parameter::Positional { name: "src1" },
+ Parameter::Positional { name: "alpha" },
+ Parameter::Positional { name: "src2" },
+ Parameter::Positional { name: "beta" },
+ Parameter::Positional { name: "gamma" },
+ ],
+ };
+
+ let kwargs = kwargs.clone();
+ let args = args.to_vec();
+ let parsed_args = filter_utils::parse_arguments(&signature, args, kwargs)?;
+
+ let src1 = match parsed_args.get("src1") {
+ Some(Val::Frame(frame)) => filter_utils::FrameArg::Frame(frame.clone()),
+ Some(Val::FrameType(frame_type)) => {
+ filter_utils::FrameArg::FrameType(frame_type.clone())
+ }
+ x => {
+ dbg! {x};
+ return Err("Expected 'src1' to be a Frame".into());
+ }
+ };
+
+ let alpha = match parsed_args.get("alpha") {
+ Some(Val::Float(value)) => *value,
+ _ => return Err("Expected 'alpha' to be a float".into()),
+ };
+
+ let src2 = match parsed_args.get("src2") {
+ Some(Val::Frame(frame)) => filter_utils::FrameArg::Frame(frame.clone()),
+ Some(Val::FrameType(frame_type)) => {
+ filter_utils::FrameArg::FrameType(frame_type.clone())
+ }
+ x => {
+ dbg! {x};
+ return Err("Expected 'src2' to be a Frame".into());
+ }
+ };
+
+ let beta = match parsed_args.get("beta") {
+ Some(Val::Float(value)) => *value,
+ _ => return Err("Expected 'beta' to be a float".into()),
+ };
+
+ let gamma = match parsed_args.get("gamma") {
+ Some(Val::Float(value)) => *value,
+ _ => return Err("Expected 'gamma' to be a float".into()),
+ };
+
+ Ok(AddWeightedArgs {
+ src1,
+ alpha,
+ src2,
+ beta,
+ gamma,
+ })
+ }
+}
+
+impl Filter for AddWeighted {
+ fn filter(
+ &self,
+ args: &[Val],
+ kwargs: &BTreeMap<std::string::String, Val>,
+ ) -> std::result::Result<Frame, crate::dve::Error> {
+ let opts: AddWeightedArgs = match Self::args(args, kwargs) {
+ Ok(args) => args,
+ Err(err) => return Err(crate::dve::Error::AVError(err)),
+ };
+
+ let src1 = opts.src1.unwrap_frame();
+ let src2 = opts.src2.unwrap_frame();
+
+ let (width, height) = (src1.width, src1.height);
+ debug_assert_eq!(src1.format, ffi::AVPixelFormat_AV_PIX_FMT_RGB24);
+ debug_assert_eq!(src2.format, ffi::AVPixelFormat_AV_PIX_FMT_RGB24);
+
+ let src1_mat = filter_utils::frame_to_mat_rgb24(&src1, width, height);
+ let src2_mat = filter_utils::frame_to_mat_rgb24(&src2, width, height);
+
+ let mut out_mat = opencv::core::Mat::new_nd_with_default(
+ &[height, width, 3],
+ opencv::core::CV_8UC3,
+ opencv::core::Scalar::all(0.0),
+ )
+ .unwrap();
+
+ opencv::core::add_weighted(
+ &src1_mat,
+ opts.alpha,
+ &src2_mat,
+ opts.beta,
+ opts.gamma,
+ &mut out_mat,
+ -1,
+ )
+ .unwrap();
+
+ assert_eq!(out_mat.rows(), { height });
+ assert_eq!(out_mat.cols(), { width });
+ assert_eq!(out_mat.channels(), 3);
+
+ let f = match filter_utils::mat_to_frame_rgb24(out_mat, width, height) {
+ Ok(value) => value,
+ Err(value) => return value,
+ };
+
+ Ok(Frame::new(AVFrame { inner: f }))
+ }
+
+ fn filter_type(
+ &self,
+ args: &[Val],
+ kwargs: &BTreeMap<std::string::String, Val>,
+ ) -> std::result::Result<FrameType, crate::dve::Error> {
+ let opts: AddWeightedArgs = match Self::args(args, kwargs) {
+ Ok(args) => args,
+ Err(err) => return Err(crate::dve::Error::AVError(err)),
+ };
+
+ // check src1 is RGB24
+ if opts.src1.unwrap_frame_type().format != ffi::AVPixelFormat_AV_PIX_FMT_RGB24 {
+ return Err(crate::dve::Error::FilterInternalError(
+ "Expected src1 to be an RGB24 frame".into(),
+ ));
+ }
+
+ // check src2 is RGB24
+ if opts.src2.unwrap_frame_type().format != ffi::AVPixelFormat_AV_PIX_FMT_RGB24 {
+ return Err(crate::dve::Error::FilterInternalError(
+ "Expected src2 to be an RGB24 frame".into(),
+ ));
+ }
+
+ // check src1 and src2 are the same size
+ if opts.src1.unwrap_frame_type().width != opts.src2.unwrap_frame_type().width
+ || opts.src1.unwrap_frame_type().height != opts.src2.unwrap_frame_type().height
+ {
+ return Err(crate::dve::Error::FilterInternalError(
+ "Expected src1 and src2 to be the same size".into(),
+ ));
+ }
+
+ Ok(opts.src1.unwrap_frame_type())
+ }
+}
+vidformer/filter/filter_utils.rs
+1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387
use opencv::core::MatTrait;
+
+use super::*;
+use std::collections::BTreeMap;
+
+use super::Val;
+
+#[derive(Clone, Debug)]
+pub(crate) enum Parameter {
+ Positional {
+ name: &'static str,
+ },
+ PositionalOptional {
+ name: &'static str,
+ default_value: Val,
+ },
+ // VarArgs {
+ // name: &'static str,
+ // },
+ // KeywordOnly {
+ // name: &'static str,
+ // },
+ // KeywordOnlyOptional {
+ // name: &'static str,
+ // default_value: Val,
+ // },
+ // KwArgs {
+ // name: &'static str,
+ // },
+}
+
+pub(crate) struct FunctionSignature {
+ pub(crate) parameters: Vec<Parameter>,
+}
+
+pub(crate) fn parse_arguments(
+ signature: &FunctionSignature,
+ args: Vec<Val>,
+ mut kwargs: std::collections::BTreeMap<String, Val>,
+) -> Result<std::collections::BTreeMap<&'static str, Val>, String> {
+ let mut parsed_args: BTreeMap<&'static str, Val> = std::collections::BTreeMap::new();
+ let mut arg_iter = args.into_iter();
+ // let mut varargs = Vec::new();
+ // let mut keyword_only: bool = false;
+
+ for param in &signature.parameters {
+ match param {
+ Parameter::Positional { name } => {
+ // assert!(
+ // !keyword_only,
+ // "Positional argument after keyword-only argument"
+ // );
+ if let Some(val) = arg_iter.next() {
+ parsed_args.insert(name, val);
+ } else if let Some(val) = kwargs.remove(*name) {
+ parsed_args.insert(name, val);
+ } else {
+ return Err(format!("Missing required positional argument '{}'", name));
+ }
+ }
+ Parameter::PositionalOptional {
+ name,
+ default_value,
+ } => {
+ // assert!(
+ // !keyword_only,
+ // "PositionalOptional argument after keyword-only argument"
+ // );
+ if let Some(val) = arg_iter.next() {
+ parsed_args.insert(name, val);
+ } else if let Some(val) = kwargs.remove(*name) {
+ parsed_args.insert(name, val);
+ } else {
+ parsed_args.insert(name, default_value.clone());
+ }
+ } // Parameter::VarArgs { name } => {
+ // assert!(
+ // !keyword_only,
+ // "VarArgs argument after keyword-only argument"
+ // );
+ // for val in arg_iter.by_ref() {
+ // varargs.push(val);
+ // }
+ // parsed_args.insert(name, Val::List(varargs.clone()));
+ // keyword_only = true; // Everything after *args is keyword-only
+ // }
+ // Parameter::KeywordOnly { name } => {
+ // if let Some(val) = kwargs.remove(*name) {
+ // parsed_args.insert(name, val);
+ // } else {
+ // return Err(format!("Missing required keyword-only argument '{}'", name));
+ // }
+ // }
+ // Parameter::KeywordOnlyOptional {
+ // name,
+ // default_value,
+ // } => {
+ // if let Some(val) = kwargs.remove(*name) {
+ // parsed_args.insert(name, val);
+ // } else {
+ // parsed_args.insert(name, default_value.clone());
+ // }
+ // }
+ // Parameter::KwArgs { name: _ } => {
+ // todo!()
+ // }
+ }
+ }
+
+ // Check for any remaining positional arguments
+ if arg_iter.next().is_some() {
+ return Err("Too many positional arguments".into());
+ }
+
+ // Check for any unexpected keyword arguments
+ if !kwargs.is_empty() {
+ return Err(format!(
+ "Got unexpected keyword arguments: {:?}",
+ kwargs.keys()
+ ));
+ }
+
+ Ok(parsed_args)
+}
+
+pub(crate) fn get_color(parsed_args: &BTreeMap<&'static str, Val>) -> Result<[f64; 4], String> {
+ let color = match parsed_args.get("color") {
+ Some(Val::List(list)) => {
+ if list.len() != 4 {
+ return Err("Expected 'color' to be a list of four floats".into());
+ }
+ match (
+ list[0].clone(),
+ list[1].clone(),
+ list[2].clone(),
+ list[3].clone(),
+ ) {
+ (Val::Float(r), Val::Float(g), Val::Float(b), Val::Float(a)) => [r, g, b, a],
+ _ => return Err("Expected 'color' to be a list of four floats".into()),
+ }
+ }
+ _ => return Err("Expected 'color' to be a list of four floats".into()),
+ };
+ Ok(color)
+}
+
+pub(crate) fn get_point(
+ parsed_args: &BTreeMap<&'static str, Val>,
+ key: &str,
+) -> Result<(i32, i32), String> {
+ let pt = match parsed_args.get(key) {
+ Some(Val::List(list)) => {
+ if list.len() != 2 {
+ return Err(format!("Expected '{key}' to be a list of two integers"));
+ }
+ match (list[0].clone(), list[1].clone()) {
+ (Val::Int(x), Val::Int(y)) => (x as i32, y as i32),
+ _ => return Err(format!("Expected '{key}' to be a list of two integers")),
+ }
+ }
+ _ => return Err(format!("Expected '{key}' to be a list of two integers")),
+ };
+ Ok(pt)
+}
+
+pub(crate) enum FrameArg {
+ Frame(Frame),
+ FrameType(FrameType),
+}
+
+impl FrameArg {
+ pub(crate) fn unwrap_frame_type(&self) -> FrameType {
+ match self {
+ FrameArg::Frame(_frame) => panic!(),
+ FrameArg::FrameType(frame_type) => frame_type.clone(),
+ }
+ }
+
+ pub(crate) fn unwrap_frame(&self) -> Frame {
+ match self {
+ FrameArg::Frame(frame) => frame.clone(),
+ FrameArg::FrameType(_frame_type) => panic!(),
+ }
+ }
+}
+
+pub(crate) fn mat_to_frame_rgb24(
+ mat: opencv::prelude::Mat,
+ width: i32,
+ height: i32,
+) -> Result<*mut ffi::AVFrame, Result<Frame, crate::dve::Error>> {
+ let f = unsafe { ffi::av_frame_alloc() };
+ if f.is_null() {
+ return Err(Err(crate::dve::Error::AVError(
+ "Failed to allocate frame".into(),
+ )));
+ }
+
+ debug_assert_eq!(mat.elem_size().unwrap(), 3);
+ debug_assert_eq!(mat.channels(), 3);
+ debug_assert_eq!(mat.size().unwrap().height, height);
+ debug_assert_eq!(mat.size().unwrap().width, width);
+ unsafe {
+ (*f).width = width;
+ (*f).height = height;
+ (*f).format = ffi::AVPixelFormat_AV_PIX_FMT_RGB24;
+
+ if ffi::av_frame_get_buffer(f, 0) < 0 {
+ panic!("ERROR could not allocate frame data");
+ }
+ }
+
+ if unsafe { (*f).linesize[0] } == width * 3 {
+ // no padding, just copy the data
+ unsafe {
+ let src = mat.data();
+ let dst = (*f).data[0];
+ std::ptr::copy_nonoverlapping(src, dst, width as usize * height as usize * 3);
+ }
+ } else {
+ // there is padding, copy line by line
+ debug_assert!(unsafe { (*f).linesize[0] } > width * 3);
+ unsafe {
+ let mut src = mat.data();
+ let mut dst = (*f).data[0];
+ for _ in 0..height {
+ std::ptr::copy_nonoverlapping(src, dst, width as usize * 3);
+ src = src.add((*f).linesize[0] as usize);
+ dst = dst.add(width as usize * 3);
+ }
+ }
+ }
+ Ok(f)
+}
+
+pub(crate) fn frame_to_mat_rgb24(img: &Frame, width: i32, height: i32) -> opencv::prelude::Mat {
+ debug_assert!(img.format == ffi::AVPixelFormat_AV_PIX_FMT_RGB24);
+ debug_assert_eq!(img.height, height);
+ debug_assert_eq!(img.width, width);
+ debug_assert_eq!(
+ unsafe { (*(img.inner.inner)).format },
+ ffi::AVPixelFormat_AV_PIX_FMT_RGB24
+ );
+ debug_assert_eq!(unsafe { (*(img.inner.inner)).width }, width);
+ debug_assert_eq!(unsafe { (*(img.inner.inner)).height }, height);
+
+ let img: ffi::AVFrame = unsafe { *img.inner.inner };
+
+ let mut mat =
+ unsafe { opencv::core::Mat::new_rows_cols(height, width, opencv::core::CV_8UC3) }.unwrap();
+
+ debug_assert!(mat.elem_size().unwrap() == 3);
+ debug_assert!(mat.channels() == 3);
+ debug_assert!(mat.size().unwrap().height == height);
+ debug_assert!(mat.size().unwrap().width == width);
+ debug_assert!(mat.is_continuous());
+
+ if img.linesize[0] == width * 3 {
+ // no padding, just copy the data
+ unsafe {
+ let src = img.data[0];
+ let dst = mat.data_mut();
+ std::ptr::copy_nonoverlapping(src, dst, width as usize * height as usize * 3);
+ }
+ } else {
+ // there is padding, copy line by line
+ debug_assert!(img.linesize[0] > width * 3);
+ unsafe {
+ let mut src = img.data[0];
+ let mut dst = mat.data_mut();
+ for _ in 0..height {
+ std::ptr::copy_nonoverlapping(src, dst, width as usize * 3);
+ src = src.add(img.linesize[0] as usize);
+ dst = dst.add(width as usize * 3);
+ }
+ }
+ }
+
+ mat
+}
+
+pub(crate) fn frame_to_mat_gray8(img: &Frame, width: i32, height: i32) -> opencv::prelude::Mat {
+ debug_assert!(img.format == ffi::AVPixelFormat_AV_PIX_FMT_GRAY8);
+ debug_assert_eq!(img.height, height);
+ debug_assert_eq!(img.width, width);
+ debug_assert_eq!(
+ unsafe { (*(img.inner.inner)).format },
+ ffi::AVPixelFormat_AV_PIX_FMT_GRAY8
+ );
+ debug_assert_eq!(unsafe { (*(img.inner.inner)).width }, width);
+ debug_assert_eq!(unsafe { (*(img.inner.inner)).height }, height);
+
+ let img: ffi::AVFrame = unsafe { *img.inner.inner };
+
+ let mut mat =
+ unsafe { opencv::core::Mat::new_rows_cols(height, width, opencv::core::CV_8UC1) }.unwrap();
+
+ debug_assert!(mat.elem_size().unwrap() == 1);
+ debug_assert!(mat.channels() == 1);
+ debug_assert!(mat.size().unwrap().height == height);
+ debug_assert!(mat.size().unwrap().width == width);
+ debug_assert!(mat.is_continuous());
+
+ if img.linesize[0] == width {
+ // no padding, just copy the data
+ unsafe {
+ let src = img.data[0];
+ let dst = mat.data_mut();
+ std::ptr::copy_nonoverlapping(src, dst, width as usize * height as usize);
+ }
+ } else {
+ // there is padding, copy line by line
+ debug_assert!(img.linesize[0] > width);
+ unsafe {
+ let mut src = img.data[0];
+ let mut dst = mat.data_mut();
+ for _ in 0..height {
+ std::ptr::copy_nonoverlapping(src, dst, width as usize);
+ src = src.add(img.linesize[0] as usize);
+ dst = dst.add(width as usize);
+ }
+ }
+ }
+
+ mat
+}
+
+#[cfg(test)]
+mod tests {
+ use opencv::core::Scalar;
+ use opencv::prelude::Mat;
+ use opencv::prelude::MatTraitConst;
+ use rusty_ffmpeg::ffi;
+
+ #[test]
+ fn test_packed_layout_rgb24() {
+ // we do some sharing of buffers between libav and opencv so we need to make sure that
+ // the layout of the data is the same
+
+ let num_planes =
+ unsafe { ffi::av_pix_fmt_count_planes(ffi::AVPixelFormat_AV_PIX_FMT_RGB24) };
+ assert_eq!(num_planes, 1);
+
+ let width = 1920;
+ let height = 1080;
+ let size = (width as usize) * (height as usize) * 3;
+
+ let frame_encoded_size_all_planes = unsafe {
+ ffi::av_image_get_buffer_size(ffi::AVPixelFormat_AV_PIX_FMT_RGB24, width, height, 1)
+ };
+
+ assert_eq!(size, frame_encoded_size_all_planes as usize);
+
+ // make sure mat data buffer is the same size as the frame buffer
+ let color = Scalar::new(255.0, 0.0, 0.0, 0.0);
+ let mat =
+ Mat::new_rows_cols_with_default(height, width, opencv::core::CV_8UC3, color).unwrap();
+
+ assert_eq!(size, mat.total() * mat.elem_size().unwrap());
+ assert!(mat.is_continuous());
+ }
+
+ #[test]
+ fn test_packed_layout_gray8() {
+ let num_planes =
+ unsafe { ffi::av_pix_fmt_count_planes(ffi::AVPixelFormat_AV_PIX_FMT_GRAY8) };
+ assert_eq!(num_planes, 1);
+
+ let width = 1920;
+ let height = 1080;
+ let size = (width as usize) * (height as usize);
+
+ let frame_encoded_size_all_planes = unsafe {
+ ffi::av_image_get_buffer_size(ffi::AVPixelFormat_AV_PIX_FMT_GRAY8, width, height, 1)
+ };
+
+ assert_eq!(size, frame_encoded_size_all_planes as usize);
+
+ // make sure mat data buffer is the same size as the frame buffer
+ let color = Scalar::new(255.0, 0.0, 0.0, 0.0);
+ let mat =
+ Mat::new_rows_cols_with_default(height, width, opencv::core::CV_8UC1, color).unwrap();
+
+ assert_eq!(size, mat.total() * mat.elem_size().unwrap());
+ assert!(mat.is_continuous());
+ }
+}
+vidformer/lib.rs
//! [vidformer](https://github.com/ixlab/vidformer) is a core video synthesis/transformation library.
+//! It handles the movement, control flow, and processing of video and conventional (non-video) data.
+//!
+//! **Quick links:**
+//! * [📦 Crates.io](https://crates.io/crates/vidformer)
+//! * [📘 Documentation](https://ixlab.github.io/vidformer/vidformer/)
+//! * [🧑💻 Source Code](https://github.com/ixlab/vidformer/tree/main/vidformer/)
+
+pub mod array;
+pub mod filter;
+pub mod service;
+pub mod sir;
+pub mod source;
+pub mod spec;
+
+pub(crate) mod av;
+mod dve;
+mod pool;
+mod util;
+
+pub use dve::{
+ create_spec_hls, run, validate, Config, Context, EncoderConfig, Error, Range, RangeTsFormat,
+ Stats,
+};
+pub use util::{codecs, init, CodecDescriptor};
+vidformer/pool.rs
+1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415
use crate::dve::IFrameRef;
+use crate::dve::{AVFrame, Config, Context, SourceRef};
+use std::fmt::Debug;
+use std::{
+ collections::{BTreeMap, BTreeSet},
+ sync::Arc,
+};
+
+const F_NOT_USED: usize = usize::MAX;
+
+pub(crate) struct Pool {
+ done_gens_recent: BTreeSet<usize>,
+ done_gens_past: usize, // If a generation is less than this it is done
+ next_gen: usize,
+ members: BTreeMap<IFrameRef, Arc<AVFrame>>,
+ pub(crate) decoders: BTreeMap<String, crate::dve::DecoderState>,
+ pub(crate) finished_unjoined_decoders: BTreeSet<String>,
+ pub(crate) terminate_decoders: bool,
+
+ iframes_per_oframe: Vec<BTreeSet<IFrameRef>>,
+ iframe_refs_in_out_idx: BTreeMap<IFrameRef, BTreeSet<usize>>,
+ dve_context: Arc<Context>,
+ dve_config: Arc<Config>,
+}
+
+impl Pool {
+ pub(crate) fn new(
+ iframes_per_oframe: Vec<BTreeSet<IFrameRef>>,
+ iframe_refs_in_out_idx: BTreeMap<IFrameRef, BTreeSet<usize>>,
+ dve_context: Arc<Context>,
+ dve_config: Arc<Config>,
+ ) -> Result<Self, crate::Error> {
+ if dve_config.decode_pool_size == 0 {
+ return Err(crate::Error::ConfigError(
+ "decode_pool_size must be greater than 0".to_string(),
+ ));
+ }
+
+ let mut out = Pool {
+ done_gens_recent: BTreeSet::new(),
+ done_gens_past: 0,
+ next_gen: 0,
+ members: BTreeMap::new(),
+ decoders: BTreeMap::new(),
+ finished_unjoined_decoders: BTreeSet::new(),
+ terminate_decoders: false,
+ iframes_per_oframe,
+ iframe_refs_in_out_idx,
+ dve_context,
+ dve_config,
+ };
+ while out.plan_gen() {}
+ Ok(out)
+ }
+
+ fn next_needed_gen(&self, frame: &IFrameRef) -> usize {
+ let frame_uses = match self.iframe_refs_in_out_idx.get(frame) {
+ Some(uses) => uses,
+ None => return F_NOT_USED,
+ };
+ // TODO: We could throw a binary search in here to speed up cases where there are many uses of a frame, such as a watermark image
+ for frame_use_gen in frame_uses {
+ if frame_use_gen >= &self.done_gens_past
+ && !self.done_gens_recent.contains(frame_use_gen)
+ {
+ return *frame_use_gen;
+ }
+ }
+ F_NOT_USED
+ }
+
+ fn decoder_next_needed_gen(&self, decoder_id: &str) -> usize {
+ let decoder = self.decoders.get(decoder_id).unwrap();
+ let mut next_needed_gen = F_NOT_USED;
+ for frame in &decoder.future_frames {
+ let frame_next_needed = self.next_needed_gen(&IFrameRef {
+ sourceref: decoder.source.clone(),
+ pts: *frame,
+ });
+ if frame_next_needed < next_needed_gen {
+ next_needed_gen = frame_next_needed;
+ }
+ }
+ next_needed_gen
+ }
+
+ fn frame_gop(&self, frame: &IFrameRef) -> usize {
+ let source = self.dve_context.sources.get(&frame.sourceref).unwrap();
+ debug_assert!(source.ts.binary_search(&frame.pts).is_ok());
+ match source.keys.binary_search(&frame.pts) {
+ Ok(i) => i,
+ Err(i) => i - 1, // i is the index of the first element greater than frame.pts
+ }
+ }
+
+ pub(crate) fn new_decoder_gop(&self) -> Option<(SourceRef, usize)> {
+ debug_assert!(self.decoders.len() <= self.dve_config.decoders);
+ if self.decoders.len() == self.dve_config.decoders {
+ return None;
+ }
+ let need_set = self
+ .need_set()
+ .into_iter()
+ .cloned()
+ .collect::<BTreeSet<_>>();
+ let future_set: BTreeSet<IFrameRef> = self.future_set();
+ let basis_frames: BTreeSet<IFrameRef> = need_set
+ .difference(&self.members.keys().cloned().collect())
+ .cloned()
+ .collect::<BTreeSet<_>>()
+ .difference(&future_set)
+ .cloned()
+ .collect();
+
+ if !basis_frames.is_empty() {
+ let mut iter = basis_frames.iter();
+ let mut soonest_needed_basis_frame = iter.next().unwrap();
+ let mut soonest_needed_basis_frame_next_needed =
+ self.next_needed_gen(soonest_needed_basis_frame);
+
+ for frame in iter {
+ let candidate_frame_next_needed = self.next_needed_gen(frame);
+ if candidate_frame_next_needed < soonest_needed_basis_frame_next_needed {
+ soonest_needed_basis_frame = frame;
+ soonest_needed_basis_frame_next_needed = candidate_frame_next_needed;
+ }
+ }
+
+ let gop_id = self.frame_gop(soonest_needed_basis_frame);
+ Some((soonest_needed_basis_frame.sourceref.clone(), gop_id))
+ } else {
+ None
+ }
+ }
+
+ fn eviction_set(
+ &self,
+ size: usize,
+ next_need_set: &BTreeSet<IFrameRef>,
+ ) -> BTreeSet<IFrameRef> {
+ struct FrameEvictionCandidate<'b> {
+ needed_gen: usize,
+ frame_ts: &'b IFrameRef,
+ }
+ impl Ord for FrameEvictionCandidate<'_> {
+ fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+ self.needed_gen.cmp(&other.needed_gen)
+ }
+ }
+ impl PartialOrd for FrameEvictionCandidate<'_> {
+ fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+ Some(self.cmp(other))
+ }
+ }
+ impl Eq for FrameEvictionCandidate<'_> {}
+ impl PartialEq for FrameEvictionCandidate<'_> {
+ fn eq(&self, other: &Self) -> bool {
+ self.needed_gen == other.needed_gen
+ }
+ }
+
+ let mut heap = std::collections::BinaryHeap::new();
+ for frame_ts in self.members.keys() {
+ if !next_need_set.contains(frame_ts) {
+ heap.push(FrameEvictionCandidate {
+ needed_gen: self.next_needed_gen(frame_ts),
+ frame_ts,
+ });
+ }
+ }
+
+ debug_assert!(heap.len() >= size);
+ let mut out = BTreeSet::new();
+ for _ in 0..size {
+ let evicted = heap.pop().unwrap();
+ out.insert(evicted.frame_ts.clone());
+ }
+ out
+ }
+
+ pub(crate) fn should_stall(&self, decoder_id: &str) -> bool {
+ // Is there a frame in the need set which is not in the members set but is in our future set?
+ // If not, stall
+
+ let decoder = self.decoders.get(decoder_id).unwrap();
+
+ let need_set = self
+ .need_set()
+ .into_iter()
+ .cloned()
+ .collect::<BTreeSet<_>>();
+ let dec_future_set = decoder.future_iframerefs();
+ let members_set = self.members.keys().cloned().collect::<BTreeSet<_>>();
+
+ let missing_frames = need_set
+ .difference(&members_set)
+ .cloned()
+ .collect::<BTreeSet<_>>();
+
+ missing_frames.intersection(&dec_future_set).count() == 0
+ }
+
+ pub(crate) fn decoded(&mut self, decoder_id: &str, frame: IFrameRef, avframe: Arc<AVFrame>) {
+ debug_assert!(self.members.len() <= self.dve_config.decode_pool_size);
+ debug_assert!(!self.should_stall(decoder_id));
+
+ if self.members.contains_key(&frame) {
+ // Frame already present
+ return;
+ }
+
+ let need_set: BTreeSet<IFrameRef> = self.need_set().into_iter().cloned().collect();
+
+ if need_set.contains(&frame) || self.members.len() < self.dve_config.decode_pool_size {
+ // If the pool is full evict a cache frame
+ if self.members.len() == self.dve_config.decode_pool_size {
+ let evict_set = self.eviction_set(1, &need_set);
+ debug_assert_eq!(evict_set.len(), 1);
+ for frame_ts in evict_set {
+ self.members.remove(&frame_ts);
+ }
+ }
+ self.members.insert(frame, avframe);
+ } else {
+ // See if we can evict a frame to make room
+ let f_next_need = self.next_needed_gen(&frame);
+ if f_next_need < F_NOT_USED {
+ let mut least_needed_pool_frame: Option<IFrameRef> = None;
+ let mut least_needed_pool_frame_next_needed = F_NOT_USED;
+
+ for pool_frame in self.members.keys() {
+ if !need_set.contains(pool_frame) {
+ if least_needed_pool_frame.is_some() {
+ let pool_frame_next_needed = self.next_needed_gen(pool_frame);
+ if pool_frame_next_needed > least_needed_pool_frame_next_needed {
+ least_needed_pool_frame = Some(pool_frame.clone());
+ least_needed_pool_frame_next_needed = pool_frame_next_needed;
+ }
+ } else {
+ least_needed_pool_frame = Some(pool_frame.clone());
+ least_needed_pool_frame_next_needed = self.next_needed_gen(pool_frame);
+ }
+ }
+ }
+
+ if f_next_need < least_needed_pool_frame_next_needed {
+ log::info!("Evicting frame {:?} (needed in gen {}) for sooner-needed frame {:?} (needed in gen {})", least_needed_pool_frame, least_needed_pool_frame_next_needed, frame, f_next_need);
+ self.members.remove(&least_needed_pool_frame.unwrap());
+ self.members.insert(frame, avframe);
+ }
+ }
+ }
+
+ debug_assert!(self.members.len() <= self.dve_config.decode_pool_size);
+ }
+
+ pub(crate) fn should_decoder_abandon(&self, decoder_id: &str) -> bool {
+ if self.decoders.len() < self.dve_config.decoders || !self.should_stall(decoder_id) {
+ return false;
+ }
+
+ let dec_next_needed_gen = self.decoder_next_needed_gen(decoder_id);
+
+ // check that there is a frame we should create a new decoder for
+ let mut found_sooner_basis_frame = false;
+ let future_set = self.future_set();
+ for frame in self.need_set() {
+ if self.members.contains_key(frame) || future_set.contains(frame) {
+ continue;
+ }
+ let frame_next_needed_gen = self.next_needed_gen(frame);
+ if frame_next_needed_gen < dec_next_needed_gen {
+ found_sooner_basis_frame = true;
+ break;
+ }
+ }
+ if !found_sooner_basis_frame {
+ return false;
+ }
+
+ // check if all other decoders have a lower or equal next needed gen
+ // aka make sure this is the least-soonest-needed decoder
+ for other_decoder_id in self.decoders.keys() {
+ if other_decoder_id == decoder_id {
+ continue;
+ }
+ let other_dec_next_needed_gen = self.decoder_next_needed_gen(other_decoder_id);
+ if other_dec_next_needed_gen > dec_next_needed_gen {
+ return false;
+ }
+ }
+
+ true
+ }
+
+ pub(crate) fn future_set(&self) -> BTreeSet<IFrameRef> {
+ let mut out = BTreeSet::new();
+ for decoder in self.decoders.values() {
+ out.extend(decoder.future_frames.iter().map(|t| IFrameRef {
+ sourceref: decoder.source.clone(),
+ pts: *t,
+ }));
+ }
+ out
+ }
+
+ fn plan_gen(&mut self) -> bool {
+ debug_assert!(self.next_gen <= self.iframes_per_oframe.len());
+ if self.next_gen == self.iframes_per_oframe.len() {
+ return false;
+ }
+
+ let number_of_active_gens =
+ self.next_gen - self.done_gens_past - self.done_gens_recent.len();
+ debug_assert_eq!(number_of_active_gens, self.active_gens().len());
+ if number_of_active_gens >= self.dve_config.decoder_view {
+ return false;
+ }
+
+ let mut next_need_set: BTreeSet<IFrameRef> =
+ { self.need_set().iter().map(|a| (*a).clone()).collect() };
+ next_need_set.extend(
+ self.iframes_per_oframe[self.next_gen]
+ .iter()
+ .map(|a| (*a).clone()),
+ );
+
+ if next_need_set.len() > self.dve_config.decode_pool_size {
+ // not enough space in the pool even with evictions
+ return false;
+ }
+
+ // Enough space, but check if we need to evict some frames first
+ let current_members = self.members.keys().map(|a| (*a).clone()).collect();
+ let next_need_set_union_current_members: BTreeSet<_> =
+ next_need_set.union(¤t_members).cloned().collect();
+ if next_need_set_union_current_members.len() > self.dve_config.decode_pool_size {
+ let needed_evictions =
+ next_need_set_union_current_members.len() - self.dve_config.decode_pool_size;
+ let evict_set = self.eviction_set(needed_evictions, &next_need_set);
+ debug_assert!(evict_set.len() == needed_evictions);
+ for frame_ts in evict_set {
+ debug_assert!(!next_need_set.contains(&frame_ts));
+ self.members.remove(&frame_ts);
+ }
+ }
+ self.next_gen += 1;
+ true
+ }
+
+ pub(crate) fn active_gens(&self) -> BTreeSet<usize> {
+ let mut out = BTreeSet::new();
+ for g in self.done_gens_past..self.next_gen {
+ if !self.done_gens_recent.contains(&g) {
+ out.insert(g);
+ }
+ }
+ out
+ }
+
+ pub(crate) fn finish_gen(&mut self, gen: usize) {
+ debug_assert!(self.active_gens().contains(&gen));
+
+ // update the done_gens
+ self.done_gens_recent.insert(gen);
+ loop {
+ match self.done_gens_recent.first() {
+ Some(&first) if first == self.done_gens_past => {
+ self.done_gens_recent.remove(&first);
+ self.done_gens_past += 1;
+ }
+ _ => break,
+ }
+ }
+
+ // plan future gens
+ while self.plan_gen() {}
+ }
+
+ pub(crate) fn is_gen_ready(&self, gen: usize) -> bool {
+ debug_assert!(self.active_gens().contains(&gen));
+
+ self.iframes_per_oframe[gen]
+ .iter()
+ .all(|dep_frame| self.members.contains_key(dep_frame))
+ }
+
+ pub(crate) fn get_ready_gen_frames(&self, gen: usize) -> BTreeMap<IFrameRef, Arc<AVFrame>> {
+ debug_assert!(self.is_gen_ready(gen));
+ self.iframes_per_oframe[gen]
+ .iter()
+ .map(|iframeref| (iframeref.clone(), self.members[iframeref].clone()))
+ .collect()
+ }
+
+ pub(crate) fn need_set(&self) -> BTreeSet<&IFrameRef> {
+ let mut out = BTreeSet::new();
+ for gen in self.active_gens() {
+ out.extend(self.iframes_per_oframe[gen].iter());
+ }
+ out
+ }
+}
+
+impl Debug for Pool {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ f.debug_struct("Pool")
+ .field("done_gens_recent", &self.done_gens_recent)
+ .field("done_gens_past", &self.done_gens_past)
+ .field("next_gen", &self.next_gen)
+ .field("members", &self.members.keys().collect::<Vec<_>>())
+ .field("decoders", &self.decoders.keys().collect::<Vec<_>>())
+ .finish()
+ }
+}
+vidformer/service.rs
+1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77
//! Services provide access to media storage.
+
+use std::str::FromStr;
+
+#[derive(Debug, serde::Deserialize, serde::Serialize, Clone)]
+pub struct Service {
+ pub(crate) service: String,
+ pub(crate) config: std::collections::HashMap<String, String>,
+}
+
+impl Service {
+ pub fn new(service: String, config: std::collections::HashMap<String, String>) -> Self {
+ Service { service, config }
+ }
+}
+
+impl Default for Service {
+ fn default() -> Self {
+ let working_dir = std::env::current_dir()
+ .unwrap()
+ .to_str()
+ .unwrap()
+ .to_string();
+ let mut map = std::collections::HashMap::new();
+ map.insert("root".to_string(), working_dir);
+
+ Service {
+ service: "fs".to_string(),
+ config: map,
+ }
+ }
+}
+
+impl Service {
+ pub(crate) fn operator(&self) -> Result<opendal::Operator, crate::Error> {
+ let op = {
+ let scheme = match opendal::Scheme::from_str(&self.service) {
+ Ok(scheme) => scheme,
+ Err(_) => {
+ return Err(crate::Error::AVError(format!(
+ "unsupported service `{}`",
+ self.service
+ )));
+ }
+ };
+ let map = self.config.clone();
+ match opendal::Operator::via_iter(scheme, map) {
+ Ok(op) => op,
+ Err(_) => {
+ return Err(crate::Error::AVError(format!(
+ "failed to instantiate service {} with config {:?}",
+ self.service, self.config
+ )));
+ }
+ }
+ };
+
+ Ok(op)
+ }
+
+ pub(crate) fn blocking_operator(
+ &self,
+ io_runtime: &tokio::runtime::Handle,
+ ) -> Result<opendal::BlockingOperator, crate::Error> {
+ let op = self.operator()?;
+
+ let bop = if op.info().full_capability().blocking {
+ op.blocking()
+ } else {
+ let _x = io_runtime.enter();
+ op.layer(opendal::layers::BlockingLayer::create().unwrap())
+ .blocking()
+ };
+
+ Ok(bop)
+ }
+}
+vidformer/sir.rs
+1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221
//! Spec Intermediate Representation
+//!
+//! The SIR is a high-level representation of constructing a video frame from source frames and data.
+//! This is the primary interface between specs and the rest of the system.
+
+use crate::dve::Range;
+use num_rational::Rational64;
+use std::collections::BTreeMap;
+use std::collections::BTreeSet;
+use std::fmt;
+use std::fmt::Display;
+use std::fmt::Formatter;
+
+#[derive(Ord, PartialOrd, PartialEq, Eq, Debug, serde::Deserialize, serde::Serialize, Clone)]
+pub enum IndexConst {
+ ILoc(usize),
+ T(Rational64),
+}
+
+#[derive(Ord, PartialOrd, PartialEq, Eq, Debug, serde::Deserialize, serde::Serialize, Clone)]
+pub struct FrameSource {
+ pub(crate) video: String,
+ pub(crate) index: IndexConst,
+}
+
+impl FrameSource {
+ pub fn new(video: String, index: IndexConst) -> Self {
+ FrameSource { video, index }
+ }
+
+ pub fn video(&self) -> &str {
+ &self.video
+ }
+
+ pub fn index(&self) -> &IndexConst {
+ &self.index
+ }
+}
+
+#[derive(Debug, serde::Deserialize, serde::Serialize, Clone)]
+pub struct FilterExpr {
+ pub name: String,
+ pub args: Vec<Expr>,
+ pub kwargs: BTreeMap<String, Expr>,
+}
+
+#[derive(Debug, serde::Deserialize, serde::Serialize, Clone)]
+pub enum Expr {
+ Frame(FrameExpr),
+ Data(DataExpr),
+}
+
+impl Display for Expr {
+ fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+ match self {
+ Expr::Frame(frame) => write!(f, "{}", frame),
+ Expr::Data(data) => write!(f, "{}", data),
+ }
+ }
+}
+
+impl Expr {
+ pub(crate) fn add_deps<'a>(&'a self, deps: &mut BTreeSet<&'a FrameSource>) {
+ match self {
+ Expr::Frame(frame) => {
+ frame.add_deps(deps);
+ }
+ Expr::Data(_) => {}
+ }
+ }
+}
+
+#[derive(Debug, serde::Deserialize, serde::Serialize, Clone)]
+
+pub enum DataExpr {
+ Bool(bool),
+ Int(i64),
+ String(String),
+ Bytes(Vec<u8>),
+ ArrayRef(String, IndexConst),
+ Float(f64),
+ List(Vec<DataExpr>),
+}
+
+impl Display for DataExpr {
+ fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+ match self {
+ DataExpr::Bool(b) => write!(f, "{}", b),
+ DataExpr::Int(i) => write!(f, "{}", i),
+ DataExpr::String(s) => write!(f, "\"{}\"", s),
+ DataExpr::Bytes(b) => write!(f, "<{} bytes>", b.len()),
+ DataExpr::Float(n) => write!(f, "{}", n),
+ DataExpr::ArrayRef(name, IndexConst::ILoc(i)) => write!(f, "{}.iloc[{}]", name, i),
+ DataExpr::ArrayRef(name, IndexConst::T(t)) => write!(f, "{}[{}]", name, t),
+ DataExpr::List(list) => {
+ write!(f, "[")?;
+ for (idx, item) in list.iter().enumerate() {
+ write!(f, "{}", item)?;
+ if idx < list.len() - 1 {
+ write!(f, ", ")?;
+ }
+ }
+ write!(f, "]")
+ }
+ }
+ }
+}
+
+#[derive(Debug, serde::Deserialize, serde::Serialize, Clone)]
+pub enum FrameExpr {
+ Source(FrameSource),
+ Filter(FilterExpr),
+}
+
+impl Display for FrameExpr {
+ fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+ match self {
+ FrameExpr::Source(src) => {
+ write!(f, "{}{}", src.video, src.index)
+ }
+ FrameExpr::Filter(filter) => {
+ write!(f, "{}(", filter.name)?;
+ for arg in &filter.args {
+ write!(f, "{}, ", arg)?;
+ }
+ for (k, v) in &filter.kwargs {
+ write!(f, "{}={}, ", k, v)?;
+ }
+ write!(f, ")")
+ }
+ }
+ }
+}
+
+impl Display for IndexConst {
+ fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+ match self {
+ IndexConst::ILoc(i) => write!(f, ".iloc[{}]", i),
+ IndexConst::T(t) => write!(f, "[{}]", t),
+ }
+ }
+}
+
+impl FrameExpr {
+ pub(crate) fn add_deps<'a>(&'a self, deps: &mut BTreeSet<&'a FrameSource>) {
+ match self {
+ FrameExpr::Source(src) => {
+ deps.insert(src);
+ }
+ FrameExpr::Filter(filter) => {
+ for arg in &filter.args {
+ arg.add_deps(deps);
+ }
+ for arg in filter.kwargs.values() {
+ arg.add_deps(deps);
+ }
+ }
+ }
+ }
+}
+
+pub(crate) struct ProcessSpan {
+ pub(crate) ts: Vec<Rational64>,
+ pub(crate) frames: Vec<FrameExpr>,
+ pub(crate) output_ts_offset: Option<Rational64>,
+}
+
+pub(crate) fn spec_domain(
+ spec: &dyn crate::spec::Spec,
+ context: &crate::dve::Context,
+) -> Vec<Rational64> {
+ spec.domain(&context.spec_ctx())
+}
+
+impl ProcessSpan {
+ pub(crate) fn create(
+ spec: &dyn crate::spec::Spec,
+ context: &crate::dve::Context,
+ range: &Option<Range>,
+ ) -> Self {
+ let spec_ctx = context.spec_ctx();
+
+ let mut ts = spec.domain(&spec_ctx);
+ ts.sort();
+ let ts = ts;
+
+ let mut range_start_ts = None;
+ let ts = match range {
+ Some(range_config) => {
+ assert!(ts.binary_search(&range_config.start).is_ok());
+ assert!(ts.binary_search(&range_config.end).is_ok());
+ if matches!(
+ range_config.ts_format,
+ crate::dve::RangeTsFormat::SegmentLocal
+ ) {
+ range_start_ts = Some(range_config.start);
+ }
+ ts.into_iter()
+ .filter(|t: &num_rational::Ratio<i64>| {
+ t >= &range_config.start && t <= &range_config.end
+ })
+ .collect()
+ }
+ None => ts,
+ };
+
+ // TODO: parallelize?
+ let mut frames = Vec::with_capacity(ts.len());
+ for t in &ts {
+ frames.push(spec.render(&spec_ctx, t));
+ }
+
+ // TODO: Data-dependent optimizations somewhere here?
+
+ ProcessSpan {
+ ts,
+ frames,
+ output_ts_offset: range_start_ts,
+ }
+ }
+}
+vidformer/source.rs
+1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285
use log::*;
+use num_rational::Rational64;
+use rusty_ffmpeg::ffi;
+use serde::{Deserialize, Serialize};
+use std::collections::BTreeSet;
+use std::ffi::CStr;
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct SourceFileMeta {
+ streams: Vec<SourceVideoStreamMeta>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct SourceVideoStreamMeta {
+ pub name: String,
+ pub file_path: String,
+ pub stream_idx: usize,
+ pub service: crate::service::Service,
+ pub file_size: u64,
+ pub resolution: (usize, usize),
+ pub codec: String,
+ pub pix_fmt: String,
+ pub ts: Vec<Rational64>,
+ pub keys: Vec<Rational64>,
+}
+
+pub fn create_profile_file(streams: &[SourceVideoStreamMeta]) -> SourceFileMeta {
+ let streams = streams.to_vec();
+ SourceFileMeta { streams }
+}
+
+impl SourceVideoStreamMeta {
+ pub fn profile(
+ source_name: &str,
+ vid_path: &str,
+ stream: usize,
+ service: &crate::service::Service,
+ ) -> Result<Self, crate::dve::Error> {
+ let io_runtime = tokio::runtime::Builder::new_multi_thread()
+ .worker_threads(1)
+ .enable_all()
+ .build()
+ .unwrap();
+
+ let file_size = {
+ let op = service.blocking_operator(io_runtime.handle())?;
+ let file_stat = op.stat(vid_path);
+
+ let file_stat = match file_stat {
+ Ok(stat) => stat,
+ Err(e) if e.kind() == opendal::ErrorKind::NotFound => {
+ return Err(crate::dve::Error::IOError(format!(
+ "File `{}` not found",
+ vid_path
+ )));
+ }
+ Err(e) => {
+ return Err(crate::dve::Error::AVError(format!(
+ "Failed to stat file {}: {}",
+ vid_path, e
+ )));
+ }
+ };
+
+ assert!(file_stat.is_file());
+ file_stat.content_length()
+ };
+
+ let mut demuxer = crate::av::demuxer::Demuxer::new(
+ vid_path,
+ stream,
+ service,
+ file_size,
+ io_runtime.handle(),
+ )?;
+
+ let codec_name = unsafe {
+ CStr::from_ptr(ffi::avcodec_get_name(
+ (*((*demuxer.stream).codecpar)).codec_id,
+ ))
+ .to_str()
+ .unwrap()
+ .to_string()
+ };
+
+ let resolution = unsafe {
+ (
+ (*((*demuxer.stream).codecpar)).width as usize,
+ (*((*demuxer.stream).codecpar)).height as usize,
+ )
+ };
+
+ let time_base = crate::util::avrat_to_rat(unsafe { &(*demuxer.stream).time_base });
+
+ let pix_fmt = unsafe { (*((*demuxer.stream).codecpar)).format };
+ let pix_fmt_name = unsafe {
+ CStr::from_ptr(ffi::av_get_pix_fmt_name(pix_fmt))
+ .to_str()
+ .unwrap()
+ .to_string()
+ };
+
+ let packet = unsafe { ffi::av_packet_alloc().as_mut() }
+ .expect("failed to allocated memory for AVPacket");
+
+ let mut pts_array = Vec::new();
+ let mut key_array = Vec::new();
+
+ while demuxer.read_packet(packet).is_some() {
+ debug_assert!(packet.flags as u32 & ffi::AV_PKT_FLAG_CORRUPT == 0);
+ trace!(
+ "AVPacket [pts {}, dts {}, duration {}, stream {}, key={}]",
+ packet.pts,
+ packet.dts,
+ packet.duration,
+ packet.stream_index,
+ packet.flags as u32 & ffi::AV_PKT_FLAG_KEY != 0
+ );
+
+ // make sure the first frame is a keyframe
+ if pts_array.is_empty() && packet.flags as u32 & ffi::AV_PKT_FLAG_KEY == 0 {
+ return Err(crate::dve::Error::AVError(
+ "First frame is not a keyframe".to_string(),
+ ));
+ }
+
+ // make sure a keyframe is always the new max pts
+ if packet.flags as u32 & ffi::AV_PKT_FLAG_KEY != 0
+ && !pts_array.is_empty()
+ && packet.pts <= pts_array[pts_array.len() - 1]
+ {
+ return Err(crate::dve::Error::AVError(format!(
+ "Keyframe pts {} is not past the most recent frame {}",
+ packet.pts,
+ pts_array[pts_array.len() - 1]
+ )));
+ }
+
+ // make sure a non-keyframe is always past the most recent keyframe
+ if packet.flags as u32 & ffi::AV_PKT_FLAG_KEY == 0
+ && !key_array.is_empty()
+ && packet.pts <= key_array[key_array.len() - 1]
+ {
+ return Err(crate::dve::Error::AVError(format!(
+ "Non-keyframe pts {} is not past the most recent keyframe {}",
+ packet.pts,
+ key_array[key_array.len() - 1]
+ )));
+ }
+
+ match pts_array.binary_search(&packet.pts) {
+ Ok(_) => {
+ return Err(crate::dve::Error::AVError(format!(
+ "Duplicate pts {}",
+ packet.pts
+ )));
+ }
+ Err(idx) => {
+ pts_array.insert(idx, packet.pts);
+ }
+ }
+ if packet.flags as u32 & ffi::AV_PKT_FLAG_KEY != 0 {
+ assert!(key_array.is_empty() || key_array[key_array.len() - 1] < packet.pts); // keyframes should always go in order
+ key_array.push(packet.pts);
+ }
+
+ unsafe { ffi::av_packet_unref(packet) };
+ }
+
+ unsafe {
+ ffi::av_packet_free(&mut (packet as *mut _));
+ }
+ demuxer.close();
+
+ let pts_array = pts_array
+ .iter()
+ .map(|&x| Rational64::new(x, 1) * time_base)
+ .collect();
+
+ let key_array: Vec<Rational64> = key_array
+ .iter()
+ .map(|&x| Rational64::new(x, 1) * time_base)
+ .collect();
+
+ Ok(SourceVideoStreamMeta {
+ name: source_name.to_string(),
+ codec: codec_name,
+ stream_idx: stream,
+ service: service.clone(),
+ file_size,
+ resolution,
+ pix_fmt: pix_fmt_name,
+ ts: pts_array,
+ keys: key_array,
+ file_path: vid_path.to_string(),
+ })
+ }
+
+ pub fn validate(
+ source_name: &str,
+ vid_path: &str,
+ stream: usize,
+ service: &crate::service::Service,
+ ) {
+ let io_runtime = tokio::runtime::Builder::new_multi_thread()
+ .worker_threads(1)
+ .enable_all()
+ .build()
+ .unwrap();
+
+ // First profile
+ let source_profile =
+ SourceVideoStreamMeta::profile(source_name, vid_path, stream, service).unwrap();
+
+ // Do a full decode
+ {
+ let mut decoded_frames = 0;
+ let mut framesource = crate::av::framesource::FrameSource::new(
+ vid_path,
+ stream,
+ &0.into(),
+ service,
+ source_profile.file_size,
+ io_runtime.handle(),
+ )
+ .unwrap();
+ while framesource.next_frame().unwrap().is_some() {
+ decoded_frames += 1;
+ }
+ assert_eq!(decoded_frames, source_profile.ts.len());
+ }
+
+ // Decode each GOP individually, check we see expected behavior
+ {
+ let mut decoded_frames = 0;
+ for (i, key) in source_profile.keys.iter().enumerate() {
+ let mut framesource = crate::av::framesource::FrameSource::new(
+ vid_path,
+ stream,
+ key,
+ service,
+ source_profile.file_size,
+ io_runtime.handle(),
+ )
+ .unwrap();
+
+ let mut expected_frame_ts: BTreeSet<&Rational64> =
+ source_profile.gop_times(i).iter().collect();
+ let mut first_frame = true;
+
+ while framesource.next_frame().unwrap().is_some() {
+ decoded_frames += 1;
+ let ts = Rational64::new(unsafe { (*framesource.frame).pts }, 1)
+ * framesource.time_base();
+
+ if first_frame {
+ assert_eq!(ts, *key);
+ first_frame = false;
+ }
+
+ assert!(expected_frame_ts.remove(&ts));
+ if expected_frame_ts.is_empty() {
+ break;
+ }
+ }
+
+ assert!(expected_frame_ts.is_empty());
+ }
+
+ assert_eq!(decoded_frames, source_profile.ts.len());
+ }
+ }
+
+ fn gop_times(&self, gop: usize) -> &[Rational64] {
+ debug_assert!(gop < self.keys.len());
+ let start_i = self.ts.binary_search(&self.keys[gop]).unwrap();
+ let end_i = if gop == self.keys.len() - 1 {
+ self.ts.len()
+ } else {
+ self.ts.binary_search(&self.keys[gop + 1]).unwrap()
+ };
+
+ &self.ts[start_i..end_i]
+ }
+}
+vidformer/spec.rs
+1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76
//! Specs declarativly define an edited video.
+//!
+//! A spec defines an output video (as a logical time-indexed array).
+//! It creates this array by defining its domain (the set of times at which the spec is defined) and a function that maps each time to a frame.
+//! The frame is represented as an [`FrameExpr`] expression.
+//!
+//! Specs are stateless and immutable. They are intended to be smaller than just storing the entire output video as an array.
+//! Additionally, this generic spec interface allows the general case of a video-editing DSL, as done in V2V, while allowing for whatever language the use case needs.
+
+use crate::sir::FrameExpr;
+use num_rational::Rational64;
+
+/// A trait for providing information to a spec during runtime
+pub trait SpecContext {}
+
+/// A trait for a spec
+///
+/// A spec defines a video from a sequence of transformations.
+/// A [`SpecContext`] is provided for information about the available source videos and arrays.
+pub trait Spec: Sync + Send {
+ /// Returns the domain of the spec.
+ ///
+ /// The domain is the set of times at which the spec is defined.
+ /// Each time corresponds to a single output frame at that timestamp.
+ ///
+ /// The output must:
+ /// - Be sorted in ascending order
+ /// - Contain no duplicate values
+ /// - Begin with 0
+ fn domain(&self, context: &dyn SpecContext) -> Vec<Rational64>;
+
+ /// Returns the "logically" rendered frame at a given time.
+ ///
+ /// This function should assume that the time is in the domain of the spec.
+ fn render(&self, context: &dyn SpecContext, t: &Rational64) -> FrameExpr;
+}
+
+pub(crate) fn get_framerate(spec: &dyn Spec) -> usize {
+ // TODO: Not all framerates are widely supported in HLS. We should probably add a check for that.
+
+ let context = crate::dve::EmptySpecCtx;
+ let frame_times = spec.domain(&context);
+
+ let mut frame_deltas = frame_times.windows(2).map(|w| w[1] - w[0]);
+
+ // Default to 30fps if there's only one frame. Not ideal, but framerate doesn't matter in that case.
+ // We don't want a user to try one frame and it break on them.
+ // TODO: Error on this case?
+ let first_delta = frame_deltas.next().unwrap_or(Rational64::new(1, 30));
+
+ assert!(frame_deltas.all(|d| d == first_delta));
+ assert_eq!(*first_delta.numer(), 1, "Frame rate must be an integer");
+
+ *first_delta.denom() as usize
+}
+
+/// A spec backed by a JSON file
+#[derive(Debug, serde::Deserialize, serde::Serialize)]
+pub struct JsonSpec {
+ pub frames: Vec<(Rational64, FrameExpr)>,
+}
+
+impl Spec for JsonSpec {
+ fn domain(&self, _context: &dyn SpecContext) -> Vec<Rational64> {
+ self.frames.iter().map(|(t, _)| *t).collect()
+ }
+
+ fn render(&self, _context: &dyn SpecContext, t: &Rational64) -> FrameExpr {
+ let index = self
+ .frames
+ .binary_search_by(|(t2, _)| t2.partial_cmp(t).unwrap())
+ .unwrap();
+
+ self.frames[index].1.clone()
+ }
+}
+vidformer/util.rs
+1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114
use num_rational::Rational64;
+use rusty_ffmpeg::ffi;
+use std::ffi::CStr;
+use std::ffi::CString;
+
+pub(crate) fn avrat_to_rat(avr: &ffi::AVRational) -> Rational64 {
+ Rational64::new(avr.num as i64, avr.den as i64)
+}
+
+pub(crate) fn rat_to_avrat(rat: &Rational64) -> ffi::AVRational {
+ ffi::AVRational {
+ num: *rat.numer() as i32,
+ den: *rat.denom() as i32,
+ }
+}
+
+pub fn rand_uuid() -> String {
+ uuid::Uuid::new_v4().to_string()
+}
+
+/// Instantiate FFmpeg logging
+pub fn init() {
+ unsafe {
+ // TODO: Should be WARNING, but it keeps throwing sws warnings
+ ffi::av_log_set_level(ffi::AV_LOG_ERROR as i32);
+ }
+}
+
+#[derive(Debug)]
+pub struct CodecDescriptor {
+ pub name: String,
+ pub long_name: String,
+ pub format_id_pretty_name: String,
+ pub has_decoder: bool,
+ pub has_encoder: bool,
+}
+
+/// List all available codecs
+pub fn codecs() -> Vec<CodecDescriptor> {
+ let mut out = Vec::new();
+ unsafe {
+ let mut codec: *const ffi::AVCodecDescriptor = std::ptr::null();
+ while {
+ codec = ffi::avcodec_descriptor_next(codec);
+ !codec.is_null()
+ } {
+ let codec = &*codec;
+ if codec.type_ != ffi::AVMediaType_AVMEDIA_TYPE_VIDEO {
+ continue;
+ }
+
+ let name = CString::new(CStr::from_ptr(codec.name).to_bytes()).unwrap();
+ let long_name = CString::new(CStr::from_ptr(codec.long_name).to_bytes()).unwrap();
+ let id = codec.id;
+ let format_id_pretty_name = ffi::avcodec_get_name(id);
+ let format_id_pretty_name =
+ CString::new(CStr::from_ptr(format_id_pretty_name).to_bytes()).unwrap();
+
+ let has_decoder = !ffi::avcodec_find_decoder(id).is_null();
+ let has_encoder = !ffi::avcodec_find_encoder(id).is_null();
+
+ out.push(CodecDescriptor {
+ name: name.to_str().unwrap().to_string(),
+ long_name: long_name.to_str().unwrap().to_string(),
+ format_id_pretty_name: format_id_pretty_name.to_str().unwrap().to_string(),
+ has_decoder,
+ has_encoder,
+ });
+ }
+ }
+
+ out
+}
+
+pub(crate) fn fmt_av_codec(format: &ffi::AVCodec) -> String {
+ let name = CString::new(unsafe { CStr::from_ptr(format.name) }.to_bytes()).unwrap();
+ let long_name = CString::new(unsafe { CStr::from_ptr(format.long_name) }.to_bytes()).unwrap();
+ let id = format.id;
+ let format_id_pretty_name = unsafe {
+ let format_id_pretty_name = ffi::avcodec_get_name(id);
+ CString::new(CStr::from_ptr(format_id_pretty_name).to_bytes()).unwrap()
+ };
+ format!(
+ "{}/{}/{}",
+ name.to_str().unwrap(),
+ long_name.to_str().unwrap(),
+ format_id_pretty_name.to_str().unwrap()
+ )
+}
+
+pub(crate) fn pixel_fmt_str_to_av_pix_fmt(s: &str) -> Result<ffi::AVPixelFormat, String> {
+ let s = CString::new(s).unwrap();
+ let fmt = unsafe { ffi::av_get_pix_fmt(s.as_ptr()) };
+ if fmt == ffi::AVPixelFormat_AV_PIX_FMT_NONE {
+ Err(format!("Invalid pixel format: {}", s.to_str().unwrap()))
+ } else {
+ Ok(fmt)
+ }
+}
+
+pub(crate) fn pixel_fmt_str(n: i32) -> &'static str {
+ unsafe {
+ let fmt = ffi::av_get_pix_fmt_name(n);
+ CStr::from_ptr(fmt).to_str().unwrap()
+ }
+}
+
+pub(crate) fn av_strerror(err: i32) -> String {
+ let mut buf = [0u8; 1024];
+ unsafe {
+ ffi::av_strerror(err, buf.as_mut_ptr() as *mut _, buf.len());
+ }
+ String::from_utf8_lossy(&buf).to_string()
+}
+"+searchState.loadingText+"
";searchState.showResults(search)},descShards:new Map(),loadDesc:async function({descShard,descIndex}){if(descShard.promise===null){descShard.promise=new Promise((resolve,reject)=>{descShard.resolve=resolve;const ds=descShard;const fname=`${ds.crate}-desc-${ds.shard}-`;const url=resourcePath(`search.desc/${descShard.crate}/${fname}`,".js",);loadScript(url,reject)})}const list=await descShard.promise;return list[descIndex]},loadedDescShard:function(crate,shard,data){this.descShards.get(crate)[shard].resolve(data.split("\n"))},};const toggleAllDocsId="toggle-all-docs";let savedHash="";function handleHashes(ev){if(ev!==null&&searchState.isDisplayed()&&ev.newURL){switchDisplayedElement(null);const hash=ev.newURL.slice(ev.newURL.indexOf("#")+1);if(browserSupportsHistoryApi()){history.replaceState(null,"",getNakedUrl()+window.location.search+"#"+hash)}const elem=document.getElementById(hash);if(elem){elem.scrollIntoView()}}const pageId=window.location.hash.replace(/^#/,"");if(savedHash!==pageId){savedHash=pageId;if(pageId!==""){expandSection(pageId)}}if(savedHash.startsWith("impl-")){const splitAt=savedHash.indexOf("/");if(splitAt!==-1){const implId=savedHash.slice(0,splitAt);const assocId=savedHash.slice(splitAt+1);const implElems=document.querySelectorAll(`details > summary > section[id^="${implId}"]`,);onEachLazy(implElems,implElem=>{const numbered=/^(.+?)-([0-9]+)$/.exec(implElem.id);if(implElem.id!==implId&&(!numbered||numbered[1]!==implId)){return false}return onEachLazy(implElem.parentElement.parentElement.querySelectorAll(`[id^="${assocId}"]`),item=>{const numbered=/^(.+?)-([0-9]+)$/.exec(item.id);if(item.id===assocId||(numbered&&numbered[1]===assocId)){openParentDetails(item);item.scrollIntoView();setTimeout(()=>{window.location.replace("#"+item.id)},0);return true}},)})}}}function onHashChange(ev){hideSidebar();handleHashes(ev)}function openParentDetails(elem){while(elem){if(elem.tagName==="DETAILS"){elem.open=true}elem=elem.parentNode}}function expandSection(id){openParentDetails(document.getElementById(id))}function handleEscape(ev){searchState.clearInputTimeout();searchState.hideResults();ev.preventDefault();searchState.defocus();window.hideAllModals(true)}function handleShortcut(ev){const disableShortcuts=getSettingValue("disable-shortcuts")==="true";if(ev.ctrlKey||ev.altKey||ev.metaKey||disableShortcuts){return}if(document.activeElement.tagName==="INPUT"&&document.activeElement.type!=="checkbox"&&document.activeElement.type!=="radio"){switch(getVirtualKey(ev)){case"Escape":handleEscape(ev);break}}else{switch(getVirtualKey(ev)){case"Escape":handleEscape(ev);break;case"s":case"S":case"/":ev.preventDefault();searchState.focus();break;case"+":ev.preventDefault();expandAllDocs();break;case"-":ev.preventDefault();collapseAllDocs();break;case"?":showHelp();break;default:break}}}document.addEventListener("keypress",handleShortcut);document.addEventListener("keydown",handleShortcut);function addSidebarItems(){if(!window.SIDEBAR_ITEMS){return}const sidebar=document.getElementById("rustdoc-modnav");function block(shortty,id,longty){const filtered=window.SIDEBAR_ITEMS[shortty];if(!filtered){return}const modpath=hasClass(document.querySelector(".rustdoc"),"mod")?"../":"";const h3=document.createElement("h3");h3.innerHTML=`${longty}`;const ul=document.createElement("ul");ul.className="block "+shortty;for(const name of filtered){let path;if(shortty==="mod"){path=`${modpath}${name}/index.html`}else{path=`${modpath}${shortty}.${name}.html`}let current_page=document.location.href.toString();if(current_page.endsWith("/")){current_page+="index.html"}const link=document.createElement("a");link.href=path;link.textContent=name;const li=document.createElement("li");if(link.href===current_page){li.classList.add("current")}li.appendChild(link);ul.appendChild(li)}sidebar.appendChild(h3);sidebar.appendChild(ul)}if(sidebar){block("primitive","primitives","Primitive Types");block("mod","modules","Modules");block("macro","macros","Macros");block("struct","structs","Structs");block("enum","enums","Enums");block("constant","constants","Constants");block("static","static","Statics");block("trait","traits","Traits");block("fn","functions","Functions");block("type","types","Type Aliases");block("union","unions","Unions");block("foreigntype","foreign-types","Foreign Types");block("keyword","keywords","Keywords");block("attr","attributes","Attribute Macros");block("derive","derives","Derive Macros");block("traitalias","trait-aliases","Trait Aliases")}}window.register_implementors=imp=>{const implementors=document.getElementById("implementors-list");const synthetic_implementors=document.getElementById("synthetic-implementors-list");const inlined_types=new Set();const TEXT_IDX=0;const SYNTHETIC_IDX=1;const TYPES_IDX=2;if(synthetic_implementors){onEachLazy(synthetic_implementors.getElementsByClassName("impl"),el=>{const aliases=el.getAttribute("data-aliases");if(!aliases){return}aliases.split(",").forEach(alias=>{inlined_types.add(alias)})})}let currentNbImpls=implementors.getElementsByClassName("impl").length;const traitName=document.querySelector(".main-heading h1 > .trait").textContent;const baseIdName="impl-"+traitName+"-";const libs=Object.getOwnPropertyNames(imp);const script=document.querySelector("script[data-ignore-extern-crates]");const ignoreExternCrates=new Set((script?script.getAttribute("data-ignore-extern-crates"):"").split(","),);for(const lib of libs){if(lib===window.currentCrate||ignoreExternCrates.has(lib)){continue}const structs=imp[lib];struct_loop:for(const struct of structs){const list=struct[SYNTHETIC_IDX]?synthetic_implementors:implementors;if(struct[SYNTHETIC_IDX]){for(const struct_type of struct[TYPES_IDX]){if(inlined_types.has(struct_type)){continue struct_loop}inlined_types.add(struct_type)}}const code=document.createElement("h3");code.innerHTML=struct[TEXT_IDX];addClass(code,"code-header");onEachLazy(code.getElementsByTagName("a"),elem=>{const href=elem.getAttribute("href");if(href&&!href.startsWith("#")&&!/^(?:[a-z+]+:)?\/\//.test(href)){elem.setAttribute("href",window.rootPath+href)}});const currentId=baseIdName+currentNbImpls;const anchor=document.createElement("a");anchor.href="#"+currentId;addClass(anchor,"anchor");const display=document.createElement("div");display.id=currentId;addClass(display,"impl");display.appendChild(anchor);display.appendChild(code);list.appendChild(display);currentNbImpls+=1}}};if(window.pending_implementors){window.register_implementors(window.pending_implementors)}window.register_type_impls=imp=>{if(!imp||!imp[window.currentCrate]){return}window.pending_type_impls=null;const idMap=new Map();let implementations=document.getElementById("implementations-list");let trait_implementations=document.getElementById("trait-implementations-list");let trait_implementations_header=document.getElementById("trait-implementations");const script=document.querySelector("script[data-self-path]");const selfPath=script?script.getAttribute("data-self-path"):null;const mainContent=document.querySelector("#main-content");const sidebarSection=document.querySelector(".sidebar section");let methods=document.querySelector(".sidebar .block.method");let associatedTypes=document.querySelector(".sidebar .block.associatedtype");let associatedConstants=document.querySelector(".sidebar .block.associatedconstant");let sidebarTraitList=document.querySelector(".sidebar .block.trait-implementation");for(const impList of imp[window.currentCrate]){const types=impList.slice(2);const text=impList[0];const isTrait=impList[1]!==0;const traitName=impList[1];if(types.indexOf(selfPath)===-1){continue}let outputList=isTrait?trait_implementations:implementations;if(outputList===null){const outputListName=isTrait?"Trait Implementations":"Implementations";const outputListId=isTrait?"trait-implementations-list":"implementations-list";const outputListHeaderId=isTrait?"trait-implementations":"implementations";const outputListHeader=document.createElement("h2");outputListHeader.id=outputListHeaderId;outputListHeader.innerText=outputListName;outputList=document.createElement("div");outputList.id=outputListId;if(isTrait){const link=document.createElement("a");link.href=`#${outputListHeaderId}`;link.innerText="Trait Implementations";const h=document.createElement("h3");h.appendChild(link);trait_implementations=outputList;trait_implementations_header=outputListHeader;sidebarSection.appendChild(h);sidebarTraitList=document.createElement("ul");sidebarTraitList.className="block trait-implementation";sidebarSection.appendChild(sidebarTraitList);mainContent.appendChild(outputListHeader);mainContent.appendChild(outputList)}else{implementations=outputList;if(trait_implementations){mainContent.insertBefore(outputListHeader,trait_implementations_header);mainContent.insertBefore(outputList,trait_implementations_header)}else{const mainContent=document.querySelector("#main-content");mainContent.appendChild(outputListHeader);mainContent.appendChild(outputList)}}}const template=document.createElement("template");template.innerHTML=text;onEachLazy(template.content.querySelectorAll("a"),elem=>{const href=elem.getAttribute("href");if(href&&!href.startsWith("#")&&!/^(?:[a-z+]+:)?\/\//.test(href)){elem.setAttribute("href",window.rootPath+href)}});onEachLazy(template.content.querySelectorAll("[id]"),el=>{let i=0;if(idMap.has(el.id)){i=idMap.get(el.id)}else if(document.getElementById(el.id)){i=1;while(document.getElementById(`${el.id}-${2 * i}`)){i=2*i}while(document.getElementById(`${el.id}-${i}`)){i+=1}}if(i!==0){const oldHref=`#${el.id}`;const newHref=`#${el.id}-${i}`;el.id=`${el.id}-${i}`;onEachLazy(template.content.querySelectorAll("a[href]"),link=>{if(link.getAttribute("href")===oldHref){link.href=newHref}})}idMap.set(el.id,i+1)});const templateAssocItems=template.content.querySelectorAll("section.tymethod, "+"section.method, section.associatedtype, section.associatedconstant");if(isTrait){const li=document.createElement("li");const a=document.createElement("a");a.href=`#${template.content.querySelector(".impl").id}`;a.textContent=traitName;li.appendChild(a);sidebarTraitList.append(li)}else{onEachLazy(templateAssocItems,item=>{let block=hasClass(item,"associatedtype")?associatedTypes:(hasClass(item,"associatedconstant")?associatedConstants:(methods));if(!block){const blockTitle=hasClass(item,"associatedtype")?"Associated Types":(hasClass(item,"associatedconstant")?"Associated Constants":("Methods"));const blockClass=hasClass(item,"associatedtype")?"associatedtype":(hasClass(item,"associatedconstant")?"associatedconstant":("method"));const blockHeader=document.createElement("h3");const blockLink=document.createElement("a");blockLink.href="#implementations";blockLink.innerText=blockTitle;blockHeader.appendChild(blockLink);block=document.createElement("ul");block.className=`block ${blockClass}`;const insertionReference=methods||sidebarTraitList;if(insertionReference){const insertionReferenceH=insertionReference.previousElementSibling;sidebarSection.insertBefore(blockHeader,insertionReferenceH);sidebarSection.insertBefore(block,insertionReferenceH)}else{sidebarSection.appendChild(blockHeader);sidebarSection.appendChild(block)}if(hasClass(item,"associatedtype")){associatedTypes=block}else if(hasClass(item,"associatedconstant")){associatedConstants=block}else{methods=block}}const li=document.createElement("li");const a=document.createElement("a");a.innerText=item.id.split("-")[0].split(".")[1];a.href=`#${item.id}`;li.appendChild(a);block.appendChild(li)})}outputList.appendChild(template.content)}for(const list of[methods,associatedTypes,associatedConstants,sidebarTraitList]){if(!list){continue}const newChildren=Array.prototype.slice.call(list.children);newChildren.sort((a,b)=>{const aI=a.innerText;const bI=b.innerText;return aI"+window.NOTABLE_TRAITS[notable_ty]+"
"}else{if(e.getAttribute("title")!==null){e.setAttribute("data-title",e.getAttribute("title"));e.removeAttribute("title")}if(e.getAttribute("data-title")!==null){const titleContent=document.createElement("div");titleContent.className="content";titleContent.appendChild(document.createTextNode(e.getAttribute("data-title")));wrapper.appendChild(titleContent)}}wrapper.className="tooltip popover";const focusCatcher=document.createElement("div");focusCatcher.setAttribute("tabindex","0");focusCatcher.onfocus=hideTooltip;wrapper.appendChild(focusCatcher);const pos=e.getBoundingClientRect();wrapper.style.top=(pos.top+window.scrollY+pos.height)+"px";wrapper.style.left=0;wrapper.style.right="auto";wrapper.style.visibility="hidden";document.body.appendChild(wrapper);const wrapperPos=wrapper.getBoundingClientRect();const finalPos=pos.left+window.scrollX-wrapperPos.width+24;if(finalPos>0){wrapper.style.left=finalPos+"px"}else{wrapper.style.setProperty("--popover-arrow-offset",(wrapperPos.right-pos.right+4)+"px",)}wrapper.style.visibility="";window.CURRENT_TOOLTIP_ELEMENT=wrapper;window.CURRENT_TOOLTIP_ELEMENT.TOOLTIP_BASE=e;clearTooltipHoverTimeout(window.CURRENT_TOOLTIP_ELEMENT);wrapper.onpointerenter=ev=>{if(ev.pointerType!=="mouse"){return}clearTooltipHoverTimeout(e)};wrapper.onpointerleave=ev=>{if(ev.pointerType!=="mouse"){return}if(!e.TOOLTIP_FORCE_VISIBLE&&!e.contains(ev.relatedTarget)){setTooltipHoverTimeout(e,false);addClass(wrapper,"fade-out")}}}function setTooltipHoverTimeout(element,show){clearTooltipHoverTimeout(element);if(!show&&!window.CURRENT_TOOLTIP_ELEMENT){return}if(show&&window.CURRENT_TOOLTIP_ELEMENT){return}if(window.CURRENT_TOOLTIP_ELEMENT&&window.CURRENT_TOOLTIP_ELEMENT.TOOLTIP_BASE!==element){return}element.TOOLTIP_HOVER_TIMEOUT=setTimeout(()=>{if(show){showTooltip(element)}else if(!element.TOOLTIP_FORCE_VISIBLE){hideTooltip(false)}},show?window.RUSTDOC_TOOLTIP_HOVER_MS:window.RUSTDOC_TOOLTIP_HOVER_EXIT_MS)}function clearTooltipHoverTimeout(element){if(element.TOOLTIP_HOVER_TIMEOUT!==undefined){removeClass(window.CURRENT_TOOLTIP_ELEMENT,"fade-out");clearTimeout(element.TOOLTIP_HOVER_TIMEOUT);delete element.TOOLTIP_HOVER_TIMEOUT}}function tooltipBlurHandler(event){if(window.CURRENT_TOOLTIP_ELEMENT&&!window.CURRENT_TOOLTIP_ELEMENT.contains(document.activeElement)&&!window.CURRENT_TOOLTIP_ELEMENT.contains(event.relatedTarget)&&!window.CURRENT_TOOLTIP_ELEMENT.TOOLTIP_BASE.contains(document.activeElement)&&!window.CURRENT_TOOLTIP_ELEMENT.TOOLTIP_BASE.contains(event.relatedTarget)){setTimeout(()=>hideTooltip(false),0)}}function hideTooltip(focus){if(window.CURRENT_TOOLTIP_ELEMENT){if(window.CURRENT_TOOLTIP_ELEMENT.TOOLTIP_BASE.TOOLTIP_FORCE_VISIBLE){if(focus){window.CURRENT_TOOLTIP_ELEMENT.TOOLTIP_BASE.focus()}window.CURRENT_TOOLTIP_ELEMENT.TOOLTIP_BASE.TOOLTIP_FORCE_VISIBLE=false}document.body.removeChild(window.CURRENT_TOOLTIP_ELEMENT);clearTooltipHoverTimeout(window.CURRENT_TOOLTIP_ELEMENT);window.CURRENT_TOOLTIP_ELEMENT=null}}onEachLazy(document.getElementsByClassName("tooltip"),e=>{e.onclick=()=>{e.TOOLTIP_FORCE_VISIBLE=e.TOOLTIP_FORCE_VISIBLE?false:true;if(window.CURRENT_TOOLTIP_ELEMENT&&!e.TOOLTIP_FORCE_VISIBLE){hideTooltip(true)}else{showTooltip(e);window.CURRENT_TOOLTIP_ELEMENT.setAttribute("tabindex","0");window.CURRENT_TOOLTIP_ELEMENT.focus();window.CURRENT_TOOLTIP_ELEMENT.onblur=tooltipBlurHandler}return false};e.onpointerenter=ev=>{if(ev.pointerType!=="mouse"){return}setTooltipHoverTimeout(e,true)};e.onpointermove=ev=>{if(ev.pointerType!=="mouse"){return}setTooltipHoverTimeout(e,true)};e.onpointerleave=ev=>{if(ev.pointerType!=="mouse"){return}if(!e.TOOLTIP_FORCE_VISIBLE&&window.CURRENT_TOOLTIP_ELEMENT&&!window.CURRENT_TOOLTIP_ELEMENT.contains(ev.relatedTarget)){setTooltipHoverTimeout(e,false);addClass(window.CURRENT_TOOLTIP_ELEMENT,"fade-out")}}});const sidebar_menu_toggle=document.getElementsByClassName("sidebar-menu-toggle")[0];if(sidebar_menu_toggle){sidebar_menu_toggle.addEventListener("click",()=>{const sidebar=document.getElementsByClassName("sidebar")[0];if(!hasClass(sidebar,"shown")){showSidebar()}else{hideSidebar()}})}function helpBlurHandler(event){if(!getHelpButton().contains(document.activeElement)&&!getHelpButton().contains(event.relatedTarget)&&!getSettingsButton().contains(document.activeElement)&&!getSettingsButton().contains(event.relatedTarget)){window.hidePopoverMenus()}}function buildHelpMenu(){const book_info=document.createElement("span");const channel=getVar("channel");book_info.className="top";book_info.innerHTML=`You can find more information in \
+the rustdoc book.`;const shortcuts=[["?","Show this help dialog"],["S / /","Focus the search field"],["↑","Move up in search results"],["↓","Move down in search results"],["← / →","Switch result tab (when results focused)"],["⏎","Go to active search result"],["+","Expand all sections"],["-","Collapse all sections"],].map(x=>"Keyboard Shortcuts
- "+shortcuts+"
fn:) to \
+ restrict the search to a given item kind.","Accepted kinds are: fn, mod, struct, \
+ enum, trait, type, macro, \
+ and const.","Search functions by type signature (e.g., vec -> usize or \
+ -> vec or String, enum:Cow -> bool)","You can look for items with an exact name by putting double quotes around \
+ your request: \"string\"","Look for functions that accept or return \
+ slices and \
+ arrays by writing \
+ square brackets (e.g., -> [u8] or [] -> Option)","Look for items inside another one by searching for a path: vec::Vec",].map(x=>""+x+"
").join("");const div_infos=document.createElement("div");addClass(div_infos,"infos");div_infos.innerHTML="Search Tricks
"+infos;const rustdoc_version=document.createElement("span");rustdoc_version.className="bottom";const rustdoc_version_code=document.createElement("code");rustdoc_version_code.innerText="rustdoc "+getVar("rustdoc-version");rustdoc_version.appendChild(rustdoc_version_code);const container=document.createElement("div");if(!isHelpPage){container.className="popover"}container.id="help";container.style.display="none";const side_by_side=document.createElement("div");side_by_side.className="side-by-side";side_by_side.appendChild(div_shortcuts);side_by_side.appendChild(div_infos);container.appendChild(book_info);container.appendChild(side_by_side);container.appendChild(rustdoc_version);if(isHelpPage){const help_section=document.createElement("section");help_section.appendChild(container);document.getElementById("main-content").appendChild(help_section);container.style.display="block"}else{const help_button=getHelpButton();help_button.appendChild(container);container.onblur=helpBlurHandler;help_button.onblur=helpBlurHandler;help_button.children[0].onblur=helpBlurHandler}return container}window.hideAllModals=switchFocus=>{hideSidebar();window.hidePopoverMenus();hideTooltip(switchFocus)};window.hidePopoverMenus=()=>{onEachLazy(document.querySelectorAll("rustdoc-toolbar .popover"),elem=>{elem.style.display="none"});const button=getHelpButton();if(button){removeClass(button,"help-open")}};function getHelpMenu(buildNeeded){let menu=getHelpButton().querySelector(".popover");if(!menu&&buildNeeded){menu=buildHelpMenu()}return menu}function showHelp(){const button=getHelpButton();addClass(button,"help-open");button.querySelector("a").focus();const menu=getHelpMenu(true);if(menu.style.display==="none"){window.hideAllModals();menu.style.display=""}}const helpLink=document.querySelector(`#${HELP_BUTTON_ID} > a`);if(isHelpPage){buildHelpMenu()}else if(helpLink){helpLink.addEventListener("click",event=>{if(!helpLink.contains(helpLink)||event.ctrlKey||event.altKey||event.metaKey){return}event.preventDefault();const menu=getHelpMenu(true);const shouldShowHelp=menu.style.display==="none";if(shouldShowHelp){showHelp()}else{window.hidePopoverMenus()}})}setMobileTopbar();addSidebarItems();addSidebarCrates();onHashChange(null);window.addEventListener("hashchange",onHashChange);searchState.setup()}());(function(){const SIDEBAR_MIN=100;const SIDEBAR_MAX=500;const RUSTDOC_MOBILE_BREAKPOINT=700;const BODY_MIN=400;const SIDEBAR_VANISH_THRESHOLD=SIDEBAR_MIN/2;const sidebarButton=document.getElementById("sidebar-button");if(sidebarButton){sidebarButton.addEventListener("click",e=>{removeClass(document.documentElement,"hide-sidebar");updateLocalStorage("hide-sidebar","false");if(document.querySelector(".rustdoc.src")){window.rustdocToggleSrcSidebar()}e.preventDefault()})}let currentPointerId=null;let desiredSidebarSize=null;let pendingSidebarResizingFrame=false;const resizer=document.querySelector(".sidebar-resizer");const sidebar=document.querySelector(".sidebar");if(!resizer||!sidebar){return}const isSrcPage=hasClass(document.body,"src");function hideSidebar(){if(isSrcPage){window.rustdocCloseSourceSidebar();updateLocalStorage("src-sidebar-width",null);document.documentElement.style.removeProperty("--src-sidebar-width");sidebar.style.removeProperty("--src-sidebar-width");resizer.style.removeProperty("--src-sidebar-width")}else{addClass(document.documentElement,"hide-sidebar");updateLocalStorage("hide-sidebar","true");updateLocalStorage("desktop-sidebar-width",null);document.documentElement.style.removeProperty("--desktop-sidebar-width");sidebar.style.removeProperty("--desktop-sidebar-width");resizer.style.removeProperty("--desktop-sidebar-width")}}function showSidebar(){if(isSrcPage){window.rustdocShowSourceSidebar()}else{removeClass(document.documentElement,"hide-sidebar");updateLocalStorage("hide-sidebar","false")}}function changeSidebarSize(size){if(isSrcPage){updateLocalStorage("src-sidebar-width",size);sidebar.style.setProperty("--src-sidebar-width",size+"px");resizer.style.setProperty("--src-sidebar-width",size+"px")}else{updateLocalStorage("desktop-sidebar-width",size);sidebar.style.setProperty("--desktop-sidebar-width",size+"px");resizer.style.setProperty("--desktop-sidebar-width",size+"px")}}function isSidebarHidden(){return isSrcPage?!hasClass(document.documentElement,"src-sidebar-expanded"):hasClass(document.documentElement,"hide-sidebar")}function resize(e){if(currentPointerId===null||currentPointerId!==e.pointerId){return}e.preventDefault();const pos=e.clientX-3;if(pos\
+${item.alias} - see \
+
`}resultName.insertAdjacentHTML("beforeend",`${alias}\
+${item.displayPath}${name}\
+
`);const description=document.createElement("div");description.className="desc";description.insertAdjacentHTML("beforeend",item.desc);link.appendChild(description);output.appendChild(link)}}else if(query.error===null){output.className="search-failed"+extraClass;output.innerHTML="No results :("+"Try on DuckDuckGo?
"+"Or try looking in one of these:
- The Rust Reference "+" for technical details about the language.
- Rust By "+"Example for expository code examples.
- The Rust Book for "+"introductions to language features and the language itself.
- Docs.rs for documentation of crates released on"+" crates.io.
in
"}let output=`"+"
\
+
`;if(results.query.error!==null){const error=results.query.error;error.forEach((value,index)=>{value=value.split("<").join("<").split(">").join(">");if(index%2!==0){error[index]=`Results
${crates}${value.replaceAll(" ", " ")}`}else{error[index]=value}});output+=`Query parser error: "${error.join("")}".
`;output+=""+makeTabHeader(0,"In Names",ret_others[1])+"
";currentTab=0}else if(results.query.foundElems<=1&&results.query.returned.length===0){output+=""+makeTabHeader(0,"In Names",ret_others[1])+makeTabHeader(1,"In Parameters",ret_in_args[1])+makeTabHeader(2,"In Return Types",ret_returned[1])+"
"}else{const signatureTabTitle=results.query.elems.length===0?"In Function Return Types":results.query.returned.length===0?"In Function Parameters":"In Function Signatures";output+=""+makeTabHeader(0,signatureTabTitle,ret_others[1])+"
";currentTab=0}if(results.query.correction!==null){const orig=results.query.returned.length>0?results.query.returned[0].name:results.query.elems[0].name;output+=""+`Type "${orig}" not found. `+"Showing results for closest type name "+`"${results.query.correction}" instead.
`}if(results.query.proposeCorrectionFrom!==null){const orig=results.query.proposeCorrectionFrom;const targ=results.query.proposeCorrectionTo;output+=""+`Type "${orig}" not found and used as generic parameter. `+`Consider searching for "${targ}" instead.
`}const resultsElem=document.createElement("div");resultsElem.id="results";resultsElem.appendChild(ret_others[0]);resultsElem.appendChild(ret_in_args[0]);resultsElem.appendChild(ret_returned[0]);search.innerHTML=output;if(searchState.rustdocToolbar){search.querySelector(".main-heading").appendChild(searchState.rustdocToolbar)}const crateSearch=document.getElementById("crate-search");if(crateSearch){crateSearch.addEventListener("input",updateCrate)}search.appendChild(resultsElem);searchState.showResults(search);const elems=document.getElementById("search-tabs").childNodes;searchState.focusedByTab=[];let i=0;for(const elem of elems){const j=i;elem.onclick=()=>printTab(j);searchState.focusedByTab.push(null);i+=1}printTab(currentTab)}function updateSearchHistory(url){if(!browserSupportsHistoryApi()){return}const params=searchState.getQueryStringParams();if(!history.state&&!params.search){history.pushState(null,"",url)}else{history.replaceState(null,"",url)}}async function search(forced){const query=DocSearch.parseQuery(searchState.input.value.trim());let filterCrates=getFilterCrates();if(!forced&&query.userQuery===currentResults){if(query.userQuery.length>0){putBackSearch()}return}searchState.setLoadingSearch();const params=searchState.getQueryStringParams();if(filterCrates===null&¶ms["filter-crate"]!==undefined){filterCrates=params["filter-crate"]}searchState.title="\""+query.original+"\" Search - Rust";updateSearchHistory(buildUrl(query.original,filterCrates));await showResults(await docSearch.execQuery(query,filterCrates,window.currentCrate),params.go_to_first,filterCrates)}function onSearchSubmit(e){e.preventDefault();searchState.clearInputTimeout();search()}function putBackSearch(){const search_input=searchState.input;if(!searchState.input){return}if(search_input.value!==""&&!searchState.isDisplayed()){searchState.showResults();if(browserSupportsHistoryApi()){history.replaceState(null,"",buildUrl(search_input.value,getFilterCrates()))}document.title=searchState.title}}function registerSearchEvents(){const params=searchState.getQueryStringParams();if(searchState.input.value===""){searchState.input.value=params.search||""}const searchAfter500ms=()=>{searchState.clearInputTimeout();if(searchState.input.value.length===0){searchState.hideResults()}else{searchState.timeout=setTimeout(search,500)}};searchState.input.onkeyup=searchAfter500ms;searchState.input.oninput=searchAfter500ms;document.getElementsByClassName("search-form")[0].onsubmit=onSearchSubmit;searchState.input.onchange=e=>{if(e.target!==document.activeElement){return}searchState.clearInputTimeout();setTimeout(search,0)};searchState.input.onpaste=searchState.input.onchange;searchState.outputElement().addEventListener("keydown",e=>{if(e.altKey||e.ctrlKey||e.shiftKey||e.metaKey){return}if(e.which===38){const previous=document.activeElement.previousElementSibling;if(previous){previous.focus()}else{searchState.focus()}e.preventDefault()}else if(e.which===40){const next=document.activeElement.nextElementSibling;if(next){next.focus()}const rect=document.activeElement.getBoundingClientRect();if(window.innerHeight-rect.bottom";continue}const js_data_name=setting["js_name"];const setting_name=setting["name"];if(setting["options"]!==undefined){output+=`\ +
+
`}else{const checked=setting["default"]===true?" checked":"";output+=`\
+${setting_name}
+ `;onEach(setting["options"],option=>{const checked=option===setting["default"]?" checked":"";const full=`${js_data_name}-${option.replace(/ /g,"-")}`;output+=`\
+ `});output+=`\
+
+\
+ \
+
`}}return output}function buildSettingsPage(){const theme_names=getVar("themes").split(",").filter(t=>t);theme_names.push("light","dark","ayu");const settings=[{"name":"Theme","js_name":"theme","default":"system preference","options":theme_names.concat("system preference"),},{"name":"Preferred light theme","js_name":"preferred-light-theme","default":"light","options":theme_names,},{"name":"Preferred dark theme","js_name":"preferred-dark-theme","default":"dark","options":theme_names,},{"name":"Auto-hide item contents for large items","js_name":"auto-hide-large-items","default":true,},{"name":"Auto-hide item methods' documentation","js_name":"auto-hide-method-docs","default":false,},{"name":"Auto-hide trait implementation documentation","js_name":"auto-hide-trait-implementations","default":false,},{"name":"Directly go to item in search if there is only one result","js_name":"go-to-only-result","default":false,},{"name":"Show line numbers on code examples","js_name":"line-numbers","default":false,},{"name":"Hide persistent navigation bar","js_name":"hide-sidebar","default":false,},{"name":"Hide table of contents","js_name":"hide-toc","default":false,},{"name":"Hide module navigation","js_name":"hide-modnav","default":false,},{"name":"Disable keyboard shortcuts","js_name":"disable-shortcuts","default":false,},];const elementKind=isSettingsPage?"section":"div";const innerHTML=`${buildSettingsPageSections(settings)}
`;const el=document.createElement(elementKind);el.id="settings";if(!isSettingsPage){el.className="popover"}el.innerHTML=innerHTML;if(isSettingsPage){document.getElementById(MAIN_ID).appendChild(el)}else{el.setAttribute("tabindex","-1");getSettingsButton().appendChild(el)}return el}const settingsMenu=buildSettingsPage();function displaySettings(){settingsMenu.style.display="";onEachLazy(settingsMenu.querySelectorAll("input[type='checkbox']"),el=>{const val=getSettingValue(el.id);const checked=val==="true";if(checked!==el.checked&&val!==null){el.checked=checked}})}function settingsBlurHandler(event){if(!getHelpButton().contains(document.activeElement)&&!getHelpButton().contains(event.relatedTarget)&&!getSettingsButton().contains(document.activeElement)&&!getSettingsButton().contains(event.relatedTarget)){window.hidePopoverMenus()}}if(!isSettingsPage){const settingsButton=getSettingsButton();const settingsMenu=document.getElementById("settings");settingsButton.onclick=event=>{if(settingsMenu.contains(event.target)){return}event.preventDefault();const shouldDisplaySettings=settingsMenu.style.display==="none";window.hideAllModals();if(shouldDisplaySettings){displaySettings()}};settingsButton.onblur=settingsBlurHandler;settingsButton.querySelector("a").onblur=settingsBlurHandler;onEachLazy(settingsMenu.querySelectorAll("input"),el=>{el.onblur=settingsBlurHandler});settingsMenu.onblur=settingsBlurHandler}setTimeout(()=>{setEvents(settingsMenu);if(!isSettingsPage){displaySettings()}removeClass(getSettingsButton(),"rotate")},0)})()
\ No newline at end of file
diff --git a/static.files/src-script-e66d777a5a92e9b2.js b/static.files/src-script-e66d777a5a92e9b2.js
new file mode 100644
index 0000000..d0aebb8
--- /dev/null
+++ b/static.files/src-script-e66d777a5a92e9b2.js
@@ -0,0 +1 @@
+"use strict";(function(){const rootPath=getVar("root-path");const NAME_OFFSET=0;const DIRS_OFFSET=1;const FILES_OFFSET=2;const RUSTDOC_MOBILE_BREAKPOINT=700;function closeSidebarIfMobile(){if(window.innerWidth
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/trait.impl/core/clone/trait.Clone.js b/trait.impl/core/clone/trait.Clone.js
new file mode 100644
index 0000000..3147c7d
--- /dev/null
+++ b/trait.impl/core/clone/trait.Clone.js
@@ -0,0 +1,9 @@
+(function() {
+ var implementors = Object.fromEntries([["vidformer",[["impl Clone for RangeTsFormat"],["impl Clone for Val"],["impl Clone for DataExpr"],["impl Clone for Expr"],["impl Clone for FrameExpr"],["impl Clone for IndexConst"],["impl Clone for Frame"],["impl Clone for FrameType"],["impl Clone for Service"],["impl Clone for FilterExpr"],["impl Clone for FrameSource"],["impl Clone for SourceVideoStreamMeta"],["impl Clone for Config"],["impl Clone for EncoderConfig"],["impl Clone for Range"]]]]);
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+})()
+//{"start":57,"fragment_lengths":[4007]}
\ No newline at end of file
diff --git a/trait.impl/core/cmp/trait.Eq.js b/trait.impl/core/cmp/trait.Eq.js
new file mode 100644
index 0000000..415d11b
--- /dev/null
+++ b/trait.impl/core/cmp/trait.Eq.js
@@ -0,0 +1,9 @@
+(function() {
+ var implementors = Object.fromEntries([["vidformer",[["impl Eq for IndexConst"],["impl Eq for FrameType"],["impl Eq for FrameSource"]]]]);
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+})()
+//{"start":57,"fragment_lengths":[792]}
\ No newline at end of file
diff --git a/trait.impl/core/cmp/trait.Ord.js b/trait.impl/core/cmp/trait.Ord.js
new file mode 100644
index 0000000..72a9178
--- /dev/null
+++ b/trait.impl/core/cmp/trait.Ord.js
@@ -0,0 +1,9 @@
+(function() {
+ var implementors = Object.fromEntries([["vidformer",[["impl Ord for IndexConst"],["impl Ord for FrameSource"]]]]);
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+})()
+//{"start":57,"fragment_lengths":[536]}
\ No newline at end of file
diff --git a/trait.impl/core/cmp/trait.PartialEq.js b/trait.impl/core/cmp/trait.PartialEq.js
new file mode 100644
index 0000000..10757f1
--- /dev/null
+++ b/trait.impl/core/cmp/trait.PartialEq.js
@@ -0,0 +1,9 @@
+(function() {
+ var implementors = Object.fromEntries([["vidformer",[["impl PartialEq for IndexConst"],["impl PartialEq for FrameType"],["impl PartialEq for FrameSource"]]]]);
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+})()
+//{"start":57,"fragment_lengths":[855]}
\ No newline at end of file
diff --git a/trait.impl/core/cmp/trait.PartialOrd.js b/trait.impl/core/cmp/trait.PartialOrd.js
new file mode 100644
index 0000000..3723800
--- /dev/null
+++ b/trait.impl/core/cmp/trait.PartialOrd.js
@@ -0,0 +1,9 @@
+(function() {
+ var implementors = Object.fromEntries([["vidformer",[["impl PartialOrd for IndexConst"],["impl PartialOrd for FrameSource"]]]]);
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+})()
+//{"start":57,"fragment_lengths":[578]}
\ No newline at end of file
diff --git a/trait.impl/core/default/trait.Default.js b/trait.impl/core/default/trait.Default.js
new file mode 100644
index 0000000..a6a4975
--- /dev/null
+++ b/trait.impl/core/default/trait.Default.js
@@ -0,0 +1,9 @@
+(function() {
+ var implementors = Object.fromEntries([["vidformer",[["impl Default for Service"]]]]);
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+})()
+//{"start":57,"fragment_lengths":[296]}
\ No newline at end of file
diff --git a/trait.impl/core/error/trait.Error.js b/trait.impl/core/error/trait.Error.js
new file mode 100644
index 0000000..d7e653c
--- /dev/null
+++ b/trait.impl/core/error/trait.Error.js
@@ -0,0 +1,9 @@
+(function() {
+ var implementors = Object.fromEntries([["vidformer",[["impl Error for Error"]]]]);
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+})()
+//{"start":57,"fragment_lengths":[257]}
\ No newline at end of file
diff --git a/trait.impl/core/fmt/trait.Debug.js b/trait.impl/core/fmt/trait.Debug.js
new file mode 100644
index 0000000..282eb93
--- /dev/null
+++ b/trait.impl/core/fmt/trait.Debug.js
@@ -0,0 +1,9 @@
+(function() {
+ var implementors = Object.fromEntries([["vidformer",[["impl Debug for Error"],["impl Debug for Val"],["impl Debug for DataExpr"],["impl Debug for Expr"],["impl Debug for FrameExpr"],["impl Debug for IndexConst"],["impl Debug for JsonArary"],["impl Debug for BoundingBoxBound"],["impl Debug for Frame"],["impl Debug for FrameType"],["impl Debug for Service"],["impl Debug for FilterExpr"],["impl Debug for FrameSource"],["impl Debug for SourceFileMeta"],["impl Debug for SourceVideoStreamMeta"],["impl Debug for JsonSpec"],["impl Debug for CodecDescriptor"],["impl Debug for Config"],["impl Debug for EncoderConfig"],["impl Debug for Stats"]]]]);
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+})()
+//{"start":57,"fragment_lengths":[5325]}
\ No newline at end of file
diff --git a/trait.impl/core/fmt/trait.Display.js b/trait.impl/core/fmt/trait.Display.js
new file mode 100644
index 0000000..00c7d53
--- /dev/null
+++ b/trait.impl/core/fmt/trait.Display.js
@@ -0,0 +1,9 @@
+(function() {
+ var implementors = Object.fromEntries([["vidformer",[["impl Display for Error"],["impl Display for DataExpr"],["impl Display for Expr"],["impl Display for FrameExpr"],["impl Display for IndexConst"]]]]);
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+})()
+//{"start":57,"fragment_lengths":[1304]}
\ No newline at end of file
diff --git a/trait.impl/core/marker/trait.Freeze.js b/trait.impl/core/marker/trait.Freeze.js
new file mode 100644
index 0000000..ee7f6dd
--- /dev/null
+++ b/trait.impl/core/marker/trait.Freeze.js
@@ -0,0 +1,9 @@
+(function() {
+ var implementors = Object.fromEntries([["vidformer",[["impl !Freeze for IPC",1,["vidformer::filter::builtin::ipc::IPC"]],["impl Freeze for Error",1,["vidformer::dve::Error"]],["impl Freeze for RangeTsFormat",1,["vidformer::dve::RangeTsFormat"]],["impl Freeze for Val",1,["vidformer::filter::Val"]],["impl Freeze for DataExpr",1,["vidformer::sir::DataExpr"]],["impl Freeze for Expr",1,["vidformer::sir::Expr"]],["impl Freeze for FrameExpr",1,["vidformer::sir::FrameExpr"]],["impl Freeze for IndexConst",1,["vidformer::sir::IndexConst"]],["impl Freeze for JsonArary",1,["vidformer::array::JsonArary"]],["impl Freeze for Annotate",1,["vidformer::filter::builtin::Annotate"]],["impl Freeze for BoundingBox",1,["vidformer::filter::builtin::BoundingBox"]],["impl Freeze for BoundingBoxBound",1,["vidformer::filter::builtin::BoundingBoxBound"]],["impl Freeze for Box",1,["vidformer::filter::builtin::Box"]],["impl Freeze for DrawBox",1,["vidformer::filter::builtin::DrawBox"]],["impl Freeze for DrawText",1,["vidformer::filter::builtin::DrawText"]],["impl Freeze for HStack",1,["vidformer::filter::builtin::HStack"]],["impl Freeze for InlineMat",1,["vidformer::filter::builtin::InlineMat"]],["impl Freeze for Pad",1,["vidformer::filter::builtin::Pad"]],["impl Freeze for PlaceholderFrame",1,["vidformer::filter::builtin::PlaceholderFrame"]],["impl Freeze for Scale",1,["vidformer::filter::builtin::Scale"]],["impl Freeze for SliceMat",1,["vidformer::filter::builtin::SliceMat"]],["impl Freeze for SliceWriteMat",1,["vidformer::filter::builtin::SliceWriteMat"]],["impl Freeze for VStack",1,["vidformer::filter::builtin::VStack"]],["impl Freeze for AddWeighted",1,["vidformer::filter::cv2::AddWeighted"]],["impl Freeze for ArrowedLine",1,["vidformer::filter::cv2::ArrowedLine"]],["impl Freeze for Circle",1,["vidformer::filter::cv2::Circle"]],["impl Freeze for Line",1,["vidformer::filter::cv2::Line"]],["impl Freeze for PutText",1,["vidformer::filter::cv2::PutText"]],["impl Freeze for Rectangle",1,["vidformer::filter::cv2::Rectangle"]],["impl Freeze for SetTo",1,["vidformer::filter::cv2::SetTo"]],["impl Freeze for Frame",1,["vidformer::filter::Frame"]],["impl Freeze for FrameType",1,["vidformer::filter::FrameType"]],["impl Freeze for Service",1,["vidformer::service::Service"]],["impl Freeze for FilterExpr",1,["vidformer::sir::FilterExpr"]],["impl Freeze for FrameSource",1,["vidformer::sir::FrameSource"]],["impl Freeze for SourceFileMeta",1,["vidformer::source::SourceFileMeta"]],["impl Freeze for SourceVideoStreamMeta",1,["vidformer::source::SourceVideoStreamMeta"]],["impl Freeze for JsonSpec",1,["vidformer::spec::JsonSpec"]],["impl Freeze for CodecDescriptor",1,["vidformer::util::CodecDescriptor"]],["impl Freeze for Config",1,["vidformer::dve::Config"]],["impl Freeze for Context",1,["vidformer::dve::Context"]],["impl Freeze for EncoderConfig",1,["vidformer::dve::EncoderConfig"]],["impl Freeze for Range",1,["vidformer::dve::Range"]],["impl Freeze for Stats",1,["vidformer::dve::Stats"]]]]]);
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+})()
+//{"start":57,"fragment_lengths":[14028]}
\ No newline at end of file
diff --git a/trait.impl/core/marker/trait.Send.js b/trait.impl/core/marker/trait.Send.js
new file mode 100644
index 0000000..e3d4e6c
--- /dev/null
+++ b/trait.impl/core/marker/trait.Send.js
@@ -0,0 +1,9 @@
+(function() {
+ var implementors = Object.fromEntries([["vidformer",[["impl Send for Error",1,["vidformer::dve::Error"]],["impl Send for RangeTsFormat",1,["vidformer::dve::RangeTsFormat"]],["impl Send for Val",1,["vidformer::filter::Val"]],["impl Send for DataExpr",1,["vidformer::sir::DataExpr"]],["impl Send for Expr",1,["vidformer::sir::Expr"]],["impl Send for FrameExpr",1,["vidformer::sir::FrameExpr"]],["impl Send for IndexConst",1,["vidformer::sir::IndexConst"]],["impl Send for JsonArary",1,["vidformer::array::JsonArary"]],["impl Send for Annotate",1,["vidformer::filter::builtin::Annotate"]],["impl Send for BoundingBox",1,["vidformer::filter::builtin::BoundingBox"]],["impl Send for BoundingBoxBound",1,["vidformer::filter::builtin::BoundingBoxBound"]],["impl Send for Box",1,["vidformer::filter::builtin::Box"]],["impl Send for DrawBox",1,["vidformer::filter::builtin::DrawBox"]],["impl Send for DrawText",1,["vidformer::filter::builtin::DrawText"]],["impl Send for HStack",1,["vidformer::filter::builtin::HStack"]],["impl Send for IPC",1,["vidformer::filter::builtin::ipc::IPC"]],["impl Send for InlineMat",1,["vidformer::filter::builtin::InlineMat"]],["impl Send for Pad",1,["vidformer::filter::builtin::Pad"]],["impl Send for PlaceholderFrame",1,["vidformer::filter::builtin::PlaceholderFrame"]],["impl Send for Scale",1,["vidformer::filter::builtin::Scale"]],["impl Send for SliceMat",1,["vidformer::filter::builtin::SliceMat"]],["impl Send for SliceWriteMat",1,["vidformer::filter::builtin::SliceWriteMat"]],["impl Send for VStack",1,["vidformer::filter::builtin::VStack"]],["impl Send for AddWeighted",1,["vidformer::filter::cv2::AddWeighted"]],["impl Send for ArrowedLine",1,["vidformer::filter::cv2::ArrowedLine"]],["impl Send for Circle",1,["vidformer::filter::cv2::Circle"]],["impl Send for Line",1,["vidformer::filter::cv2::Line"]],["impl Send for PutText",1,["vidformer::filter::cv2::PutText"]],["impl Send for Rectangle",1,["vidformer::filter::cv2::Rectangle"]],["impl Send for SetTo",1,["vidformer::filter::cv2::SetTo"]],["impl Send for Frame",1,["vidformer::filter::Frame"]],["impl Send for FrameType",1,["vidformer::filter::FrameType"]],["impl Send for Service",1,["vidformer::service::Service"]],["impl Send for FilterExpr",1,["vidformer::sir::FilterExpr"]],["impl Send for FrameSource",1,["vidformer::sir::FrameSource"]],["impl Send for SourceFileMeta",1,["vidformer::source::SourceFileMeta"]],["impl Send for SourceVideoStreamMeta",1,["vidformer::source::SourceVideoStreamMeta"]],["impl Send for JsonSpec",1,["vidformer::spec::JsonSpec"]],["impl Send for CodecDescriptor",1,["vidformer::util::CodecDescriptor"]],["impl Send for Config",1,["vidformer::dve::Config"]],["impl Send for Context",1,["vidformer::dve::Context"]],["impl Send for EncoderConfig",1,["vidformer::dve::EncoderConfig"]],["impl Send for Range",1,["vidformer::dve::Range"]],["impl Send for Stats",1,["vidformer::dve::Stats"]]]]]);
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+})()
+//{"start":57,"fragment_lengths":[13763]}
\ No newline at end of file
diff --git a/trait.impl/core/marker/trait.StructuralPartialEq.js b/trait.impl/core/marker/trait.StructuralPartialEq.js
new file mode 100644
index 0000000..efc95c7
--- /dev/null
+++ b/trait.impl/core/marker/trait.StructuralPartialEq.js
@@ -0,0 +1,9 @@
+(function() {
+ var implementors = Object.fromEntries([["vidformer",[["impl StructuralPartialEq for IndexConst"],["impl StructuralPartialEq for FrameType"],["impl StructuralPartialEq for FrameSource"]]]]);
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+})()
+//{"start":57,"fragment_lengths":[963]}
\ No newline at end of file
diff --git a/trait.impl/core/marker/trait.Sync.js b/trait.impl/core/marker/trait.Sync.js
new file mode 100644
index 0000000..b61f5a4
--- /dev/null
+++ b/trait.impl/core/marker/trait.Sync.js
@@ -0,0 +1,9 @@
+(function() {
+ var implementors = Object.fromEntries([["vidformer",[["impl Sync for Error",1,["vidformer::dve::Error"]],["impl Sync for RangeTsFormat",1,["vidformer::dve::RangeTsFormat"]],["impl Sync for Val",1,["vidformer::filter::Val"]],["impl Sync for DataExpr",1,["vidformer::sir::DataExpr"]],["impl Sync for Expr",1,["vidformer::sir::Expr"]],["impl Sync for FrameExpr",1,["vidformer::sir::FrameExpr"]],["impl Sync for IndexConst",1,["vidformer::sir::IndexConst"]],["impl Sync for JsonArary",1,["vidformer::array::JsonArary"]],["impl Sync for Annotate",1,["vidformer::filter::builtin::Annotate"]],["impl Sync for BoundingBox",1,["vidformer::filter::builtin::BoundingBox"]],["impl Sync for BoundingBoxBound",1,["vidformer::filter::builtin::BoundingBoxBound"]],["impl Sync for Box",1,["vidformer::filter::builtin::Box"]],["impl Sync for DrawBox",1,["vidformer::filter::builtin::DrawBox"]],["impl Sync for DrawText",1,["vidformer::filter::builtin::DrawText"]],["impl Sync for HStack",1,["vidformer::filter::builtin::HStack"]],["impl Sync for IPC",1,["vidformer::filter::builtin::ipc::IPC"]],["impl Sync for InlineMat",1,["vidformer::filter::builtin::InlineMat"]],["impl Sync for Pad",1,["vidformer::filter::builtin::Pad"]],["impl Sync for PlaceholderFrame",1,["vidformer::filter::builtin::PlaceholderFrame"]],["impl Sync for Scale",1,["vidformer::filter::builtin::Scale"]],["impl Sync for SliceMat",1,["vidformer::filter::builtin::SliceMat"]],["impl Sync for SliceWriteMat",1,["vidformer::filter::builtin::SliceWriteMat"]],["impl Sync for VStack",1,["vidformer::filter::builtin::VStack"]],["impl Sync for AddWeighted",1,["vidformer::filter::cv2::AddWeighted"]],["impl Sync for ArrowedLine",1,["vidformer::filter::cv2::ArrowedLine"]],["impl Sync for Circle",1,["vidformer::filter::cv2::Circle"]],["impl Sync for Line",1,["vidformer::filter::cv2::Line"]],["impl Sync for PutText",1,["vidformer::filter::cv2::PutText"]],["impl Sync for Rectangle",1,["vidformer::filter::cv2::Rectangle"]],["impl Sync for SetTo",1,["vidformer::filter::cv2::SetTo"]],["impl Sync for Frame",1,["vidformer::filter::Frame"]],["impl Sync for FrameType",1,["vidformer::filter::FrameType"]],["impl Sync for Service",1,["vidformer::service::Service"]],["impl Sync for FilterExpr",1,["vidformer::sir::FilterExpr"]],["impl Sync for FrameSource",1,["vidformer::sir::FrameSource"]],["impl Sync for SourceFileMeta",1,["vidformer::source::SourceFileMeta"]],["impl Sync for SourceVideoStreamMeta",1,["vidformer::source::SourceVideoStreamMeta"]],["impl Sync for JsonSpec",1,["vidformer::spec::JsonSpec"]],["impl Sync for CodecDescriptor",1,["vidformer::util::CodecDescriptor"]],["impl Sync for Config",1,["vidformer::dve::Config"]],["impl Sync for Context",1,["vidformer::dve::Context"]],["impl Sync for EncoderConfig",1,["vidformer::dve::EncoderConfig"]],["impl Sync for Range",1,["vidformer::dve::Range"]],["impl Sync for Stats",1,["vidformer::dve::Stats"]]]]]);
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+})()
+//{"start":57,"fragment_lengths":[13763]}
\ No newline at end of file
diff --git a/trait.impl/core/marker/trait.Unpin.js b/trait.impl/core/marker/trait.Unpin.js
new file mode 100644
index 0000000..b69ad06
--- /dev/null
+++ b/trait.impl/core/marker/trait.Unpin.js
@@ -0,0 +1,9 @@
+(function() {
+ var implementors = Object.fromEntries([["vidformer",[["impl Unpin for Error",1,["vidformer::dve::Error"]],["impl Unpin for RangeTsFormat",1,["vidformer::dve::RangeTsFormat"]],["impl Unpin for Val",1,["vidformer::filter::Val"]],["impl Unpin for DataExpr",1,["vidformer::sir::DataExpr"]],["impl Unpin for Expr",1,["vidformer::sir::Expr"]],["impl Unpin for FrameExpr",1,["vidformer::sir::FrameExpr"]],["impl Unpin for IndexConst",1,["vidformer::sir::IndexConst"]],["impl Unpin for JsonArary",1,["vidformer::array::JsonArary"]],["impl Unpin for Annotate",1,["vidformer::filter::builtin::Annotate"]],["impl Unpin for BoundingBox",1,["vidformer::filter::builtin::BoundingBox"]],["impl Unpin for BoundingBoxBound",1,["vidformer::filter::builtin::BoundingBoxBound"]],["impl Unpin for Box",1,["vidformer::filter::builtin::Box"]],["impl Unpin for DrawBox",1,["vidformer::filter::builtin::DrawBox"]],["impl Unpin for DrawText",1,["vidformer::filter::builtin::DrawText"]],["impl Unpin for HStack",1,["vidformer::filter::builtin::HStack"]],["impl Unpin for IPC",1,["vidformer::filter::builtin::ipc::IPC"]],["impl Unpin for InlineMat",1,["vidformer::filter::builtin::InlineMat"]],["impl Unpin for Pad",1,["vidformer::filter::builtin::Pad"]],["impl Unpin for PlaceholderFrame",1,["vidformer::filter::builtin::PlaceholderFrame"]],["impl Unpin for Scale",1,["vidformer::filter::builtin::Scale"]],["impl Unpin for SliceMat",1,["vidformer::filter::builtin::SliceMat"]],["impl Unpin for SliceWriteMat",1,["vidformer::filter::builtin::SliceWriteMat"]],["impl Unpin for VStack",1,["vidformer::filter::builtin::VStack"]],["impl Unpin for AddWeighted",1,["vidformer::filter::cv2::AddWeighted"]],["impl Unpin for ArrowedLine",1,["vidformer::filter::cv2::ArrowedLine"]],["impl Unpin for Circle",1,["vidformer::filter::cv2::Circle"]],["impl Unpin for Line",1,["vidformer::filter::cv2::Line"]],["impl Unpin for PutText",1,["vidformer::filter::cv2::PutText"]],["impl Unpin for Rectangle",1,["vidformer::filter::cv2::Rectangle"]],["impl Unpin for SetTo",1,["vidformer::filter::cv2::SetTo"]],["impl Unpin for Frame",1,["vidformer::filter::Frame"]],["impl Unpin for FrameType",1,["vidformer::filter::FrameType"]],["impl Unpin for Service",1,["vidformer::service::Service"]],["impl Unpin for FilterExpr",1,["vidformer::sir::FilterExpr"]],["impl Unpin for FrameSource",1,["vidformer::sir::FrameSource"]],["impl Unpin for SourceFileMeta",1,["vidformer::source::SourceFileMeta"]],["impl Unpin for SourceVideoStreamMeta",1,["vidformer::source::SourceVideoStreamMeta"]],["impl Unpin for JsonSpec",1,["vidformer::spec::JsonSpec"]],["impl Unpin for CodecDescriptor",1,["vidformer::util::CodecDescriptor"]],["impl Unpin for Config",1,["vidformer::dve::Config"]],["impl Unpin for Context",1,["vidformer::dve::Context"]],["impl Unpin for EncoderConfig",1,["vidformer::dve::EncoderConfig"]],["impl Unpin for Range",1,["vidformer::dve::Range"]],["impl Unpin for Stats",1,["vidformer::dve::Stats"]]]]]);
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+})()
+//{"start":57,"fragment_lengths":[13895]}
\ No newline at end of file
diff --git a/trait.impl/core/panic/unwind_safe/trait.RefUnwindSafe.js b/trait.impl/core/panic/unwind_safe/trait.RefUnwindSafe.js
new file mode 100644
index 0000000..0f26524
--- /dev/null
+++ b/trait.impl/core/panic/unwind_safe/trait.RefUnwindSafe.js
@@ -0,0 +1,9 @@
+(function() {
+ var implementors = Object.fromEntries([["vidformer",[["impl !RefUnwindSafe for IPC",1,["vidformer::filter::builtin::ipc::IPC"]],["impl !RefUnwindSafe for Context",1,["vidformer::dve::Context"]],["impl RefUnwindSafe for Error",1,["vidformer::dve::Error"]],["impl RefUnwindSafe for RangeTsFormat",1,["vidformer::dve::RangeTsFormat"]],["impl RefUnwindSafe for Val",1,["vidformer::filter::Val"]],["impl RefUnwindSafe for DataExpr",1,["vidformer::sir::DataExpr"]],["impl RefUnwindSafe for Expr",1,["vidformer::sir::Expr"]],["impl RefUnwindSafe for FrameExpr",1,["vidformer::sir::FrameExpr"]],["impl RefUnwindSafe for IndexConst",1,["vidformer::sir::IndexConst"]],["impl RefUnwindSafe for JsonArary",1,["vidformer::array::JsonArary"]],["impl RefUnwindSafe for Annotate",1,["vidformer::filter::builtin::Annotate"]],["impl RefUnwindSafe for BoundingBox",1,["vidformer::filter::builtin::BoundingBox"]],["impl RefUnwindSafe for BoundingBoxBound",1,["vidformer::filter::builtin::BoundingBoxBound"]],["impl RefUnwindSafe for Box",1,["vidformer::filter::builtin::Box"]],["impl RefUnwindSafe for DrawBox",1,["vidformer::filter::builtin::DrawBox"]],["impl RefUnwindSafe for DrawText",1,["vidformer::filter::builtin::DrawText"]],["impl RefUnwindSafe for HStack",1,["vidformer::filter::builtin::HStack"]],["impl RefUnwindSafe for InlineMat",1,["vidformer::filter::builtin::InlineMat"]],["impl RefUnwindSafe for Pad",1,["vidformer::filter::builtin::Pad"]],["impl RefUnwindSafe for PlaceholderFrame",1,["vidformer::filter::builtin::PlaceholderFrame"]],["impl RefUnwindSafe for Scale",1,["vidformer::filter::builtin::Scale"]],["impl RefUnwindSafe for SliceMat",1,["vidformer::filter::builtin::SliceMat"]],["impl RefUnwindSafe for SliceWriteMat",1,["vidformer::filter::builtin::SliceWriteMat"]],["impl RefUnwindSafe for VStack",1,["vidformer::filter::builtin::VStack"]],["impl RefUnwindSafe for AddWeighted",1,["vidformer::filter::cv2::AddWeighted"]],["impl RefUnwindSafe for ArrowedLine",1,["vidformer::filter::cv2::ArrowedLine"]],["impl RefUnwindSafe for Circle",1,["vidformer::filter::cv2::Circle"]],["impl RefUnwindSafe for Line",1,["vidformer::filter::cv2::Line"]],["impl RefUnwindSafe for PutText",1,["vidformer::filter::cv2::PutText"]],["impl RefUnwindSafe for Rectangle",1,["vidformer::filter::cv2::Rectangle"]],["impl RefUnwindSafe for SetTo",1,["vidformer::filter::cv2::SetTo"]],["impl RefUnwindSafe for Frame",1,["vidformer::filter::Frame"]],["impl RefUnwindSafe for FrameType",1,["vidformer::filter::FrameType"]],["impl RefUnwindSafe for Service",1,["vidformer::service::Service"]],["impl RefUnwindSafe for FilterExpr",1,["vidformer::sir::FilterExpr"]],["impl RefUnwindSafe for FrameSource",1,["vidformer::sir::FrameSource"]],["impl RefUnwindSafe for SourceFileMeta",1,["vidformer::source::SourceFileMeta"]],["impl RefUnwindSafe for SourceVideoStreamMeta",1,["vidformer::source::SourceVideoStreamMeta"]],["impl RefUnwindSafe for JsonSpec",1,["vidformer::spec::JsonSpec"]],["impl RefUnwindSafe for CodecDescriptor",1,["vidformer::util::CodecDescriptor"]],["impl RefUnwindSafe for Config",1,["vidformer::dve::Config"]],["impl RefUnwindSafe for EncoderConfig",1,["vidformer::dve::EncoderConfig"]],["impl RefUnwindSafe for Range",1,["vidformer::dve::Range"]],["impl RefUnwindSafe for Stats",1,["vidformer::dve::Stats"]]]]]);
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+})()
+//{"start":57,"fragment_lengths":[15965]}
\ No newline at end of file
diff --git a/trait.impl/core/panic/unwind_safe/trait.UnwindSafe.js b/trait.impl/core/panic/unwind_safe/trait.UnwindSafe.js
new file mode 100644
index 0000000..6adb19f
--- /dev/null
+++ b/trait.impl/core/panic/unwind_safe/trait.UnwindSafe.js
@@ -0,0 +1,9 @@
+(function() {
+ var implementors = Object.fromEntries([["vidformer",[["impl !UnwindSafe for Context",1,["vidformer::dve::Context"]],["impl UnwindSafe for Error",1,["vidformer::dve::Error"]],["impl UnwindSafe for RangeTsFormat",1,["vidformer::dve::RangeTsFormat"]],["impl UnwindSafe for Val",1,["vidformer::filter::Val"]],["impl UnwindSafe for DataExpr",1,["vidformer::sir::DataExpr"]],["impl UnwindSafe for Expr",1,["vidformer::sir::Expr"]],["impl UnwindSafe for FrameExpr",1,["vidformer::sir::FrameExpr"]],["impl UnwindSafe for IndexConst",1,["vidformer::sir::IndexConst"]],["impl UnwindSafe for JsonArary",1,["vidformer::array::JsonArary"]],["impl UnwindSafe for Annotate",1,["vidformer::filter::builtin::Annotate"]],["impl UnwindSafe for BoundingBox",1,["vidformer::filter::builtin::BoundingBox"]],["impl UnwindSafe for BoundingBoxBound",1,["vidformer::filter::builtin::BoundingBoxBound"]],["impl UnwindSafe for Box",1,["vidformer::filter::builtin::Box"]],["impl UnwindSafe for DrawBox",1,["vidformer::filter::builtin::DrawBox"]],["impl UnwindSafe for DrawText",1,["vidformer::filter::builtin::DrawText"]],["impl UnwindSafe for HStack",1,["vidformer::filter::builtin::HStack"]],["impl UnwindSafe for IPC",1,["vidformer::filter::builtin::ipc::IPC"]],["impl UnwindSafe for InlineMat",1,["vidformer::filter::builtin::InlineMat"]],["impl UnwindSafe for Pad",1,["vidformer::filter::builtin::Pad"]],["impl UnwindSafe for PlaceholderFrame",1,["vidformer::filter::builtin::PlaceholderFrame"]],["impl UnwindSafe for Scale",1,["vidformer::filter::builtin::Scale"]],["impl UnwindSafe for SliceMat",1,["vidformer::filter::builtin::SliceMat"]],["impl UnwindSafe for SliceWriteMat",1,["vidformer::filter::builtin::SliceWriteMat"]],["impl UnwindSafe for VStack",1,["vidformer::filter::builtin::VStack"]],["impl UnwindSafe for AddWeighted",1,["vidformer::filter::cv2::AddWeighted"]],["impl UnwindSafe for ArrowedLine",1,["vidformer::filter::cv2::ArrowedLine"]],["impl UnwindSafe for Circle",1,["vidformer::filter::cv2::Circle"]],["impl UnwindSafe for Line",1,["vidformer::filter::cv2::Line"]],["impl UnwindSafe for PutText",1,["vidformer::filter::cv2::PutText"]],["impl UnwindSafe for Rectangle",1,["vidformer::filter::cv2::Rectangle"]],["impl UnwindSafe for SetTo",1,["vidformer::filter::cv2::SetTo"]],["impl UnwindSafe for Frame",1,["vidformer::filter::Frame"]],["impl UnwindSafe for FrameType",1,["vidformer::filter::FrameType"]],["impl UnwindSafe for Service",1,["vidformer::service::Service"]],["impl UnwindSafe for FilterExpr",1,["vidformer::sir::FilterExpr"]],["impl UnwindSafe for FrameSource",1,["vidformer::sir::FrameSource"]],["impl UnwindSafe for SourceFileMeta",1,["vidformer::source::SourceFileMeta"]],["impl UnwindSafe for SourceVideoStreamMeta",1,["vidformer::source::SourceVideoStreamMeta"]],["impl UnwindSafe for JsonSpec",1,["vidformer::spec::JsonSpec"]],["impl UnwindSafe for CodecDescriptor",1,["vidformer::util::CodecDescriptor"]],["impl UnwindSafe for Config",1,["vidformer::dve::Config"]],["impl UnwindSafe for EncoderConfig",1,["vidformer::dve::EncoderConfig"]],["impl UnwindSafe for Range",1,["vidformer::dve::Range"]],["impl UnwindSafe for Stats",1,["vidformer::dve::Stats"]]]]]);
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+})()
+//{"start":57,"fragment_lengths":[15568]}
\ No newline at end of file
diff --git a/trait.impl/serde/de/trait.Deserialize.js b/trait.impl/serde/de/trait.Deserialize.js
new file mode 100644
index 0000000..d6945a5
--- /dev/null
+++ b/trait.impl/serde/de/trait.Deserialize.js
@@ -0,0 +1,9 @@
+(function() {
+ var implementors = Object.fromEntries([["vidformer",[["impl<'de> Deserialize<'de> for DataExpr"],["impl<'de> Deserialize<'de> for Expr"],["impl<'de> Deserialize<'de> for FrameExpr"],["impl<'de> Deserialize<'de> for IndexConst"],["impl<'de> Deserialize<'de> for JsonArary"],["impl<'de> Deserialize<'de> for BoundingBoxBound"],["impl<'de> Deserialize<'de> for Frame"],["impl<'de> Deserialize<'de> for FrameType"],["impl<'de> Deserialize<'de> for Service"],["impl<'de> Deserialize<'de> for FilterExpr"],["impl<'de> Deserialize<'de> for FrameSource"],["impl<'de> Deserialize<'de> for SourceFileMeta"],["impl<'de> Deserialize<'de> for SourceVideoStreamMeta"],["impl<'de> Deserialize<'de> for JsonSpec"],["impl<'de> Deserialize<'de> for Config"],["impl<'de> Deserialize<'de> for EncoderConfig"]]]]);
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+})()
+//{"start":57,"fragment_lengths":[4914]}
\ No newline at end of file
diff --git a/trait.impl/serde/ser/trait.Serialize.js b/trait.impl/serde/ser/trait.Serialize.js
new file mode 100644
index 0000000..4fcb440
--- /dev/null
+++ b/trait.impl/serde/ser/trait.Serialize.js
@@ -0,0 +1,9 @@
+(function() {
+ var implementors = Object.fromEntries([["vidformer",[["impl Serialize for Val"],["impl Serialize for DataExpr"],["impl Serialize for Expr"],["impl Serialize for FrameExpr"],["impl Serialize for IndexConst"],["impl Serialize for JsonArary"],["impl Serialize for Frame"],["impl Serialize for FrameType"],["impl Serialize for Service"],["impl Serialize for FilterExpr"],["impl Serialize for FrameSource"],["impl Serialize for SourceFileMeta"],["impl Serialize for SourceVideoStreamMeta"],["impl Serialize for JsonSpec"],["impl Serialize for Config"],["impl Serialize for EncoderConfig"],["impl Serialize for Stats"]]]]);
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+})()
+//{"start":57,"fragment_lengths":[4691]}
\ No newline at end of file
diff --git a/trait.impl/vidformer/array/trait.Array.js b/trait.impl/vidformer/array/trait.Array.js
new file mode 100644
index 0000000..64003a1
--- /dev/null
+++ b/trait.impl/vidformer/array/trait.Array.js
@@ -0,0 +1,9 @@
+(function() {
+ var implementors = Object.fromEntries([["vidformer",[]]]);
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+})()
+//{"start":57,"fragment_lengths":[16]}
\ No newline at end of file
diff --git a/trait.impl/vidformer/filter/trait.Filter.js b/trait.impl/vidformer/filter/trait.Filter.js
new file mode 100644
index 0000000..64003a1
--- /dev/null
+++ b/trait.impl/vidformer/filter/trait.Filter.js
@@ -0,0 +1,9 @@
+(function() {
+ var implementors = Object.fromEntries([["vidformer",[]]]);
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+})()
+//{"start":57,"fragment_lengths":[16]}
\ No newline at end of file
diff --git a/trait.impl/vidformer/spec/trait.Spec.js b/trait.impl/vidformer/spec/trait.Spec.js
new file mode 100644
index 0000000..64003a1
--- /dev/null
+++ b/trait.impl/vidformer/spec/trait.Spec.js
@@ -0,0 +1,9 @@
+(function() {
+ var implementors = Object.fromEntries([["vidformer",[]]]);
+ if (window.register_implementors) {
+ window.register_implementors(implementors);
+ } else {
+ window.pending_implementors = implementors;
+ }
+})()
+//{"start":57,"fragment_lengths":[16]}
\ No newline at end of file
diff --git a/udf-filters.html b/udf-filters.html
new file mode 100644
index 0000000..1397953
--- /dev/null
+++ b/udf-filters.html
@@ -0,0 +1,256 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The vidformer Tools
+vidformer is a highly modular suite of tools that work together:
+-
+
-
+
vidformer-py: A Python 🐍 client for declarative video synthesis
+-
+
- Provides an easy-to-use library for symbolically representing transformed videos +
- Acts as a client for a VoD server (i.e., for yrden) +
- Using vidformer-py is the best place to get started +
+ -
+
libvidformer: The core data-oriented declarative video editing library
+-
+
- An embedded video processing execution engine with low-level interfaces +
- Systems code, written in Rust 🦀 +
- You should use if: You are building a VDBMS or other multimodal data-system infrastructure. +
- You should not use if: You just want to use vidformer in your workflows or projects. +
+ -
+
yrden: A vidformer Video-on-Demand server
+-
+
- Provides vidformer services over a REST-style API +
- Allows for client libraries to be written in any language +
- Serves video results via HLS streams +
- Designed for local single-tenant use +
- You should use if: You want to create faster video results in your workflows or projects. +
- Note that yrden servers may be spun up transparently by client libraries, so you might use yrden without realizing it. +
+ -
+
igni: A planned scale-out Video-on-Demand server
+-
+
- Will allow for scalable and secure public-facing VOD endpoints +
+
Client libraries in other languages: +Writing a vidformer client library for other languages is simple. +It's a few hundred lines of code, and you just have to construct some JSON. +Contributions or suggestions for other languages are welcome.
+Other VoD servers: +We provide yrden as a simple reference VoD server implementation. +If you want to scale-out deployments, multi-tenant deployments, or deep integration with a specific system, writing another VoD server is needed. (In progress work)
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/vidformer-py-cv2/index.html b/vidformer-py-cv2/index.html
new file mode 100644
index 0000000..6e134f6
--- /dev/null
+++ b/vidformer-py-cv2/index.html
@@ -0,0 +1,7 @@
+
+
+
+
+
+
+
diff --git a/vidformer-py-cv2/search.js b/vidformer-py-cv2/search.js
new file mode 100644
index 0000000..0321465
--- /dev/null
+++ b/vidformer-py-cv2/search.js
@@ -0,0 +1,46 @@
+window.pdocSearch = (function(){
+/** elasticlunr - http://weixsong.github.io * Copyright (C) 2017 Oliver Nightingale * Copyright (C) 2017 Wei Song * MIT Licensed */!function(){function e(e){if(null===e||"object"!=typeof e)return e;var t=e.constructor();for(var n in e)e.hasOwnProperty(n)&&(t[n]=e[n]);return t}var t=function(e){var n=new t.Index;return n.pipeline.add(t.trimmer,t.stopWordFilter,t.stemmer),e&&e.call(n,n),n};t.version="0.9.5",lunr=t,t.utils={},t.utils.warn=function(e){return function(t){e.console&&console.warn&&console.warn(t)}}(this),t.utils.toString=function(e){return void 0===e||null===e?"":e.toString()},t.EventEmitter=function(){this.events={}},t.EventEmitter.prototype.addListener=function(){var e=Array.prototype.slice.call(arguments),t=e.pop(),n=e;if("function"!=typeof t)throw new TypeError("last argument must be a function");n.forEach(function(e){this.hasHandler(e)||(this.events[e]=[]),this.events[e].push(t)},this)},t.EventEmitter.prototype.removeListener=function(e,t){if(this.hasHandler(e)){var n=this.events[e].indexOf(t);-1!==n&&(this.events[e].splice(n,1),0==this.events[e].length&&delete this.events[e])}},t.EventEmitter.prototype.emit=function(e){if(this.hasHandler(e)){var t=Array.prototype.slice.call(arguments,1);this.events[e].forEach(function(e){e.apply(void 0,t)},this)}},t.EventEmitter.prototype.hasHandler=function(e){return e in this.events},t.tokenizer=function(e){if(!arguments.length||null===e||void 0===e)return[];if(Array.isArray(e)){var n=e.filter(function(e){return null===e||void 0===e?!1:!0});n=n.map(function(e){return t.utils.toString(e).toLowerCase()});var i=[];return n.forEach(function(e){var n=e.split(t.tokenizer.seperator);i=i.concat(n)},this),i}return e.toString().trim().toLowerCase().split(t.tokenizer.seperator)},t.tokenizer.defaultSeperator=/[\s\-]+/,t.tokenizer.seperator=t.tokenizer.defaultSeperator,t.tokenizer.setSeperator=function(e){null!==e&&void 0!==e&&"object"==typeof e&&(t.tokenizer.seperator=e)},t.tokenizer.resetSeperator=function(){t.tokenizer.seperator=t.tokenizer.defaultSeperator},t.tokenizer.getSeperator=function(){return t.tokenizer.seperator},t.Pipeline=function(){this._queue=[]},t.Pipeline.registeredFunctions={},t.Pipeline.registerFunction=function(e,n){n in t.Pipeline.registeredFunctions&&t.utils.warn("Overwriting existing registered function: "+n),e.label=n,t.Pipeline.registeredFunctions[n]=e},t.Pipeline.getRegisteredFunction=function(e){return e in t.Pipeline.registeredFunctions!=!0?null:t.Pipeline.registeredFunctions[e]},t.Pipeline.warnIfFunctionNotRegistered=function(e){var n=e.label&&e.label in this.registeredFunctions;n||t.utils.warn("Function is not registered with pipeline. This may cause problems when serialising the index.\n",e)},t.Pipeline.load=function(e){var n=new t.Pipeline;return e.forEach(function(e){var i=t.Pipeline.getRegisteredFunction(e);if(!i)throw new Error("Cannot load un-registered function: "+e);n.add(i)}),n},t.Pipeline.prototype.add=function(){var e=Array.prototype.slice.call(arguments);e.forEach(function(e){t.Pipeline.warnIfFunctionNotRegistered(e),this._queue.push(e)},this)},t.Pipeline.prototype.after=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i+1,0,n)},t.Pipeline.prototype.before=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i,0,n)},t.Pipeline.prototype.remove=function(e){var t=this._queue.indexOf(e);-1!==t&&this._queue.splice(t,1)},t.Pipeline.prototype.run=function(e){for(var t=[],n=e.length,i=this._queue.length,o=0;n>o;o++){for(var r=e[o],s=0;i>s&&(r=this._queue[s](r,o,e),void 0!==r&&null!==r);s++);void 0!==r&&null!==r&&t.push(r)}return t},t.Pipeline.prototype.reset=function(){this._queue=[]},t.Pipeline.prototype.get=function(){return this._queue},t.Pipeline.prototype.toJSON=function(){return this._queue.map(function(e){return t.Pipeline.warnIfFunctionNotRegistered(e),e.label})},t.Index=function(){this._fields=[],this._ref="id",this.pipeline=new t.Pipeline,this.documentStore=new t.DocumentStore,this.index={},this.eventEmitter=new t.EventEmitter,this._idfCache={},this.on("add","remove","update",function(){this._idfCache={}}.bind(this))},t.Index.prototype.on=function(){var e=Array.prototype.slice.call(arguments);return this.eventEmitter.addListener.apply(this.eventEmitter,e)},t.Index.prototype.off=function(e,t){return this.eventEmitter.removeListener(e,t)},t.Index.load=function(e){e.version!==t.version&&t.utils.warn("version mismatch: current "+t.version+" importing "+e.version);var n=new this;n._fields=e.fields,n._ref=e.ref,n.documentStore=t.DocumentStore.load(e.documentStore),n.pipeline=t.Pipeline.load(e.pipeline),n.index={};for(var i in e.index)n.index[i]=t.InvertedIndex.load(e.index[i]);return n},t.Index.prototype.addField=function(e){return this._fields.push(e),this.index[e]=new t.InvertedIndex,this},t.Index.prototype.setRef=function(e){return this._ref=e,this},t.Index.prototype.saveDocument=function(e){return this.documentStore=new t.DocumentStore(e),this},t.Index.prototype.addDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.addDoc(i,e),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));this.documentStore.addFieldLength(i,n,o.length);var r={};o.forEach(function(e){e in r?r[e]+=1:r[e]=1},this);for(var s in r){var u=r[s];u=Math.sqrt(u),this.index[n].addToken(s,{ref:i,tf:u})}},this),n&&this.eventEmitter.emit("add",e,this)}},t.Index.prototype.removeDocByRef=function(e){if(e&&this.documentStore.isDocStored()!==!1&&this.documentStore.hasDoc(e)){var t=this.documentStore.getDoc(e);this.removeDoc(t,!1)}},t.Index.prototype.removeDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.hasDoc(i)&&(this.documentStore.removeDoc(i),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));o.forEach(function(e){this.index[n].removeToken(e,i)},this)},this),n&&this.eventEmitter.emit("remove",e,this))}},t.Index.prototype.updateDoc=function(e,t){var t=void 0===t?!0:t;this.removeDocByRef(e[this._ref],!1),this.addDoc(e,!1),t&&this.eventEmitter.emit("update",e,this)},t.Index.prototype.idf=function(e,t){var n="@"+t+"/"+e;if(Object.prototype.hasOwnProperty.call(this._idfCache,n))return this._idfCache[n];var i=this.index[t].getDocFreq(e),o=1+Math.log(this.documentStore.length/(i+1));return this._idfCache[n]=o,o},t.Index.prototype.getFields=function(){return this._fields.slice()},t.Index.prototype.search=function(e,n){if(!e)return[];e="string"==typeof e?{any:e}:JSON.parse(JSON.stringify(e));var i=null;null!=n&&(i=JSON.stringify(n));for(var o=new t.Configuration(i,this.getFields()).get(),r={},s=Object.keys(e),u=0;u
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ User-Defined Filters
+To implement a new user-defined filter (UDF) you need to host a filter server over a UNIX Domain Socket.
+The vidformer-py library makes this easy.
Filters take some combination of frames and data (string, int, bool) and return a single frame result.
+The vidformer project uses Python-style arguments, allowing ordered and named arguments (*args and **kwargs style).
To do this we define a new filter class and host it:
+import vidformer as vf
+import cv2
+
+class MyFilter(vf.UDF):
+
+ def filter(self, frame: vf.UDFFrame, name: str):
+ """Return the result frame."""
+
+ text = f"Hello, {name}!"
+
+ image = frame.data().copy()
+ cv2.putText(
+ image,
+ text,
+ (100,100),
+ cv2.FONT_HERSHEY_SIMPLEX,
+ 1,
+ (255, 0, 0),
+ 1,
+ )
+ return vf.UDFFrame(image, frame.frame_type())
+
+ def filter_type(self, frame: vf.UDFFrameType, _name: str):
+ """Returns the type of the output frame."""
+ return frame
+
+mf_udf = MyFilter("MyFilter") # name used for pretty printing
+
+my_filter = mf_udf.into_filter() # host the UDF in a subprocess, returns a vf.Filter
+Now we can use our newly-created filter in specs: my_filter(some_frame, "vidformer").
There is a catch, UDFs currently only support rgb24 pixel formats.
+So invoking my_filter will need to convert around this:
scale = vf.Filter('Scale')
+
+def render(t, i):
+ f = scale(tos[t], pix_fmt="rgb24", width=1280, height=720)
+ f = my_filter(f, "world")
+ f = scale(f, pix_fmt="yuv420p", width=1280, height=720)
+ return f
+\n\n\n\u26a0\ufe0f This module is a work in progress. See the implemented functions list.
\n
Quick links:
\n\n- \n
- \ud83d\udce6 PyPI \n
- \ud83d\udcd8 Documentation - vidformer-py \n
- \ud83d\udcd8 Documentation - vidformer.cv2 \n
- \ud83e\uddd1\u200d\ud83d\udcbb Source Code \n
Set the server to use for the cv2 frontend.
\n", "signature": "(server: vidformer.vf.YrdenServer):", "funcdef": "def"}, "vidformer.cv2.vf_cv2.Frame": {"fullname": "vidformer.cv2.vf_cv2.Frame", "modulename": "vidformer.cv2.vf_cv2", "qualname": "Frame", "kind": "class", "doc": "\n"}, "vidformer.cv2.vf_cv2.Frame.__init__": {"fullname": "vidformer.cv2.vf_cv2.Frame.__init__", "modulename": "vidformer.cv2.vf_cv2", "qualname": "Frame.__init__", "kind": "function", "doc": "\n", "signature": "(f, fmt)"}, "vidformer.cv2.vf_cv2.Frame.shape": {"fullname": "vidformer.cv2.vf_cv2.Frame.shape", "modulename": "vidformer.cv2.vf_cv2", "qualname": "Frame.shape", "kind": "variable", "doc": "\n"}, "vidformer.cv2.vf_cv2.Frame.numpy": {"fullname": "vidformer.cv2.vf_cv2.Frame.numpy", "modulename": "vidformer.cv2.vf_cv2", "qualname": "Frame.numpy", "kind": "function", "doc": "Return the frame as a numpy array.
\n", "signature": "(self):", "funcdef": "def"}, "vidformer.cv2.vf_cv2.VideoCapture": {"fullname": "vidformer.cv2.vf_cv2.VideoCapture", "modulename": "vidformer.cv2.vf_cv2", "qualname": "VideoCapture", "kind": "class", "doc": "\n"}, "vidformer.cv2.vf_cv2.VideoCapture.__init__": {"fullname": "vidformer.cv2.vf_cv2.VideoCapture.__init__", "modulename": "vidformer.cv2.vf_cv2", "qualname": "VideoCapture.__init__", "kind": "function", "doc": "\n", "signature": "(path)"}, "vidformer.cv2.vf_cv2.VideoCapture.isOpened": {"fullname": "vidformer.cv2.vf_cv2.VideoCapture.isOpened", "modulename": "vidformer.cv2.vf_cv2", "qualname": "VideoCapture.isOpened", "kind": "function", "doc": "\n", "signature": "(self):", "funcdef": "def"}, "vidformer.cv2.vf_cv2.VideoCapture.get": {"fullname": "vidformer.cv2.vf_cv2.VideoCapture.get", "modulename": "vidformer.cv2.vf_cv2", "qualname": "VideoCapture.get", "kind": "function", "doc": "\n", "signature": "(self, prop):", "funcdef": "def"}, "vidformer.cv2.vf_cv2.VideoCapture.set": {"fullname": "vidformer.cv2.vf_cv2.VideoCapture.set", "modulename": "vidformer.cv2.vf_cv2", "qualname": "VideoCapture.set", "kind": "function", "doc": "\n", "signature": "(self, prop, value):", "funcdef": "def"}, "vidformer.cv2.vf_cv2.VideoCapture.read": {"fullname": "vidformer.cv2.vf_cv2.VideoCapture.read", "modulename": "vidformer.cv2.vf_cv2", "qualname": "VideoCapture.read", "kind": "function", "doc": "\n", "signature": "(self):", "funcdef": "def"}, "vidformer.cv2.vf_cv2.VideoCapture.release": {"fullname": "vidformer.cv2.vf_cv2.VideoCapture.release", "modulename": "vidformer.cv2.vf_cv2", "qualname": "VideoCapture.release", "kind": "function", "doc": "\n", "signature": "(self):", "funcdef": "def"}, "vidformer.cv2.vf_cv2.VideoWriter": {"fullname": "vidformer.cv2.vf_cv2.VideoWriter", "modulename": "vidformer.cv2.vf_cv2", "qualname": "VideoWriter", "kind": "class", "doc": "\n"}, "vidformer.cv2.vf_cv2.VideoWriter.__init__": {"fullname": "vidformer.cv2.vf_cv2.VideoWriter.__init__", "modulename": "vidformer.cv2.vf_cv2", "qualname": "VideoWriter.__init__", "kind": "function", "doc": "\n", "signature": "(path, fourcc, fps, size)"}, "vidformer.cv2.vf_cv2.VideoWriter.write": {"fullname": "vidformer.cv2.vf_cv2.VideoWriter.write", "modulename": "vidformer.cv2.vf_cv2", "qualname": "VideoWriter.write", "kind": "function", "doc": "\n", "signature": "(self, frame):", "funcdef": "def"}, "vidformer.cv2.vf_cv2.VideoWriter.release": {"fullname": "vidformer.cv2.vf_cv2.VideoWriter.release", "modulename": "vidformer.cv2.vf_cv2", "qualname": "VideoWriter.release", "kind": "function", "doc": "\n", "signature": "(self):", "funcdef": "def"}, "vidformer.cv2.vf_cv2.VideoWriter.spec": {"fullname": "vidformer.cv2.vf_cv2.VideoWriter.spec", "modulename": "vidformer.cv2.vf_cv2", "qualname": "VideoWriter.spec", "kind": "function", "doc": "\n", "signature": "(self) -> vidformer.vf.Spec:", "funcdef": "def"}, "vidformer.cv2.vf_cv2.VideoWriter_fourcc": {"fullname": "vidformer.cv2.vf_cv2.VideoWriter_fourcc", "modulename": "vidformer.cv2.vf_cv2", "qualname": "VideoWriter_fourcc", "kind": "class", "doc": "\n"}, "vidformer.cv2.vf_cv2.VideoWriter_fourcc.__init__": {"fullname": "vidformer.cv2.vf_cv2.VideoWriter_fourcc.__init__", "modulename": "vidformer.cv2.vf_cv2", "qualname": "VideoWriter_fourcc.__init__", "kind": "function", "doc": "\n", "signature": "(*args)"}, "vidformer.cv2.vf_cv2.frameify": {"fullname": "vidformer.cv2.vf_cv2.frameify", "modulename": "vidformer.cv2.vf_cv2", "qualname": "frameify", "kind": "function", "doc": "Turn an object (e.g., ndarray) into a Frame.
\n", "signature": "(obj, field_name=None):", "funcdef": "def"}, "vidformer.cv2.vf_cv2.imread": {"fullname": "vidformer.cv2.vf_cv2.imread", "modulename": "vidformer.cv2.vf_cv2", "qualname": "imread", "kind": "function", "doc": "\n", "signature": "(path, *args):", "funcdef": "def"}, "vidformer.cv2.vf_cv2.imwrite": {"fullname": "vidformer.cv2.vf_cv2.imwrite", "modulename": "vidformer.cv2.vf_cv2", "qualname": "imwrite", "kind": "function", "doc": "\n", "signature": "(path, img, *args):", "funcdef": "def"}, "vidformer.cv2.vf_cv2.vidplay": {"fullname": "vidformer.cv2.vf_cv2.vidplay", "modulename": "vidformer.cv2.vf_cv2", "qualname": "vidplay", "kind": "function", "doc": "Play a vidformer video specification.
\n\nArgs:\n video: one of [vidformer.Spec, vidformer.Source, vidformer.cv2.VideoWriter]
\n", "signature": "(video, *args, **kwargs):", "funcdef": "def"}, "vidformer.cv2.vf_cv2.rectangle": {"fullname": "vidformer.cv2.vf_cv2.rectangle", "modulename": "vidformer.cv2.vf_cv2", "qualname": "rectangle", "kind": "function", "doc": "cv.rectangle( img, pt1, pt2, color[, thickness[, lineType[, shift]]] )
\n", "signature": "(img, pt1, pt2, color, thickness=None, lineType=None, shift=None):", "funcdef": "def"}, "vidformer.cv2.vf_cv2.putText": {"fullname": "vidformer.cv2.vf_cv2.putText", "modulename": "vidformer.cv2.vf_cv2", "qualname": "putText", "kind": "function", "doc": "cv.putText( img, text, org, fontFace, fontScale, color[, thickness[, lineType[, bottomLeftOrigin]]] )
\n", "signature": "(\timg,\ttext,\torg,\tfontFace,\tfontScale,\tcolor,\tthickness=None,\tlineType=None,\tbottomLeftOrigin=None):", "funcdef": "def"}, "vidformer.cv2.vf_cv2.arrowedLine": {"fullname": "vidformer.cv2.vf_cv2.arrowedLine", "modulename": "vidformer.cv2.vf_cv2", "qualname": "arrowedLine", "kind": "function", "doc": "cv.arrowedLine( img, pt1, pt2, color[, thickness[, line_type[, shift[, tipLength]]]] )
\n", "signature": "(\timg,\tpt1,\tpt2,\tcolor,\tthickness=None,\tline_type=None,\tshift=None,\ttipLength=None):", "funcdef": "def"}, "vidformer.cv2.vf_cv2.line": {"fullname": "vidformer.cv2.vf_cv2.line", "modulename": "vidformer.cv2.vf_cv2", "qualname": "line", "kind": "function", "doc": "\n", "signature": "(img, pt1, pt2, color, thickness=None, lineType=None, shift=None):", "funcdef": "def"}, "vidformer.cv2.vf_cv2.circle": {"fullname": "vidformer.cv2.vf_cv2.circle", "modulename": "vidformer.cv2.vf_cv2", "qualname": "circle", "kind": "function", "doc": "\n", "signature": "(\timg,\tcenter,\tradius,\tcolor,\tthickness=None,\tlineType=None,\tshift=None):", "funcdef": "def"}, "vidformer.cv2.vf_cv2.getFontScaleFromHeight": {"fullname": "vidformer.cv2.vf_cv2.getFontScaleFromHeight", "modulename": "vidformer.cv2.vf_cv2", "qualname": "getFontScaleFromHeight", "kind": "function", "doc": "cv.getFontScaleFromHeight( fontFace, pixelHeight[, thickness] )
\n", "signature": "(*args, **kwargs):", "funcdef": "def"}, "vidformer.cv2.vf_cv2.getTextSize": {"fullname": "vidformer.cv2.vf_cv2.getTextSize", "modulename": "vidformer.cv2.vf_cv2", "qualname": "getTextSize", "kind": "function", "doc": "cv.getTextSize( text, fontFace, fontScale, thickness )
\n", "signature": "(*args, **kwargs):", "funcdef": "def"}, "vidformer.cv2.vf_cv2.addWeighted": {"fullname": "vidformer.cv2.vf_cv2.addWeighted", "modulename": "vidformer.cv2.vf_cv2", "qualname": "addWeighted", "kind": "function", "doc": "cv.addWeighted( src1, alpha, src2, beta, gamma[, dst[, dtype]] ) -> dst
\n", "signature": "(src1, alpha, src2, beta, gamma, dst=None, dtype=-1):", "funcdef": "def"}, "vidformer.cv2.vf_cv2.clipLine": {"fullname": "vidformer.cv2.vf_cv2.clipLine", "modulename": "vidformer.cv2.vf_cv2", "qualname": "clipLine", "kind": "function", "doc": "\n", "signature": "(*args, **kwargs):", "funcdef": "def"}, "vidformer.cv2.vf_cv2.drawContours": {"fullname": "vidformer.cv2.vf_cv2.drawContours", "modulename": "vidformer.cv2.vf_cv2", "qualname": "drawContours", "kind": "function", "doc": "\n", "signature": "(*args, **kwargs):", "funcdef": "def"}, "vidformer.cv2.vf_cv2.drawMarker": {"fullname": "vidformer.cv2.vf_cv2.drawMarker", "modulename": "vidformer.cv2.vf_cv2", "qualname": "drawMarker", "kind": "function", "doc": "\n", "signature": "(*args, **kwargs):", "funcdef": "def"}, "vidformer.cv2.vf_cv2.ellipse": {"fullname": "vidformer.cv2.vf_cv2.ellipse", "modulename": "vidformer.cv2.vf_cv2", "qualname": "ellipse", "kind": "function", "doc": "\n", "signature": "(*args, **kwargs):", "funcdef": "def"}, "vidformer.cv2.vf_cv2.ellipse2Poly": {"fullname": "vidformer.cv2.vf_cv2.ellipse2Poly", "modulename": "vidformer.cv2.vf_cv2", "qualname": "ellipse2Poly", "kind": "function", "doc": "\n", "signature": "(*args, **kwargs):", "funcdef": "def"}, "vidformer.cv2.vf_cv2.fillConvexPoly": {"fullname": "vidformer.cv2.vf_cv2.fillConvexPoly", "modulename": "vidformer.cv2.vf_cv2", "qualname": "fillConvexPoly", "kind": "function", "doc": "\n", "signature": "(*args, **kwargs):", "funcdef": "def"}, "vidformer.cv2.vf_cv2.fillPoly": {"fullname": "vidformer.cv2.vf_cv2.fillPoly", "modulename": "vidformer.cv2.vf_cv2", "qualname": "fillPoly", "kind": "function", "doc": "\n", "signature": "(*args, **kwargs):", "funcdef": "def"}, "vidformer.cv2.vf_cv2.polylines": {"fullname": "vidformer.cv2.vf_cv2.polylines", "modulename": "vidformer.cv2.vf_cv2", "qualname": "polylines", "kind": "function", "doc": "\n", "signature": "(*args, **kwargs):", "funcdef": "def"}}, "docInfo": {"vidformer.cv2.vf_cv2": {"qualname": 0, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 74}, "vidformer.cv2.vf_cv2.CAP_PROP_POS_MSEC": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.CAP_PROP_POS_FRAMES": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_WIDTH": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_HEIGHT": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.CAP_PROP_FPS": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_COUNT": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SIMPLEX": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_PLAIN": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_DUPLEX": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_COMPLEX": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_TRIPLEX": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_COMPLEX_SMALL": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SCRIPT_SIMPLEX": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SCRIPT_COMPLEX": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.FONT_ITALIC": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.FILLED": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 2, "signature": 0, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.LINE_4": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.LINE_8": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.LINE_AA": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.set_cv2_server": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 26, "bases": 0, "doc": 12}, "vidformer.cv2.vf_cv2.Frame": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.Frame.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.Frame.shape": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.Frame.numpy": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 10}, "vidformer.cv2.vf_cv2.VideoCapture": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.VideoCapture.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 9, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.VideoCapture.isOpened": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.VideoCapture.get": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.VideoCapture.set": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 21, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.VideoCapture.read": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.VideoCapture.release": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.VideoWriter": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.VideoWriter.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 24, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.VideoWriter.write": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.VideoWriter.release": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.VideoWriter.spec": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 24, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.VideoWriter_fourcc": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.VideoWriter_fourcc.__init__": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.frameify": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 22, "bases": 0, "doc": 12}, "vidformer.cv2.vf_cv2.imread": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 18, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.imwrite": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 23, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.vidplay": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 25, "bases": 0, "doc": 21}, "vidformer.cv2.vf_cv2.rectangle": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 56, "bases": 0, "doc": 12}, "vidformer.cv2.vf_cv2.putText": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 75, "bases": 0, "doc": 14}, "vidformer.cv2.vf_cv2.arrowedLine": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 75, "bases": 0, "doc": 14}, "vidformer.cv2.vf_cv2.line": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 56, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.circle": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 63, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.getFontScaleFromHeight": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 20, "bases": 0, "doc": 8}, "vidformer.cv2.vf_cv2.getTextSize": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 20, "bases": 0, "doc": 9}, "vidformer.cv2.vf_cv2.addWeighted": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 51, "bases": 0, "doc": 13}, "vidformer.cv2.vf_cv2.clipLine": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 20, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.drawContours": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 20, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.drawMarker": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 20, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.ellipse": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 20, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.ellipse2Poly": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 20, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.fillConvexPoly": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 20, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.fillPoly": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 20, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.polylines": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 20, "bases": 0, "doc": 3}}, "length": 59, "save": true}, "index": {"qualname": {"root": {"4": {"docs": {"vidformer.cv2.vf_cv2.LINE_4": {"tf": 1}}, "df": 1}, "8": {"docs": {"vidformer.cv2.vf_cv2.LINE_8": {"tf": 1}}, "df": 1}, "docs": {"vidformer.cv2.vf_cv2.Frame.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter_fourcc.__init__": {"tf": 1}}, "df": 4, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {"vidformer.cv2.vf_cv2.CAP_PROP_POS_MSEC": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_POS_FRAMES": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_WIDTH": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_HEIGHT": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_FPS": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_COUNT": {"tf": 1}}, "df": 6}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2.CAP_PROP_FRAME_COUNT": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {"vidformer.cv2.vf_cv2.FONT_HERSHEY_COMPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_COMPLEX_SMALL": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SCRIPT_COMPLEX": {"tf": 1}}, "df": 3}}}}}}, "v": {"2": {"docs": {"vidformer.cv2.vf_cv2.set_cv2_server": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.circle": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.clipLine": {"tf": 1}}, "df": 1}}}}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {"vidformer.cv2.vf_cv2.CAP_PROP_POS_MSEC": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_POS_FRAMES": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_WIDTH": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_HEIGHT": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_FPS": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_COUNT": {"tf": 1}}, "df": 6}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.cv2.vf_cv2.CAP_PROP_POS_MSEC": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_POS_FRAMES": {"tf": 1}}, "df": 2}, "l": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.cv2.vf_cv2.polylines": {"tf": 1}}, "df": 1}}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"vidformer.cv2.vf_cv2.FONT_HERSHEY_PLAIN": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2.putText": {"tf": 1}}, "df": 1}}}}}}}, "m": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {"vidformer.cv2.vf_cv2.CAP_PROP_POS_MSEC": {"tf": 1}}, "df": 1}}}}, "f": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.CAP_PROP_FRAME_WIDTH": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_HEIGHT": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_COUNT": {"tf": 1}, "vidformer.cv2.vf_cv2.Frame": {"tf": 1}, "vidformer.cv2.vf_cv2.Frame.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.Frame.shape": {"tf": 1}, "vidformer.cv2.vf_cv2.Frame.numpy": {"tf": 1}}, "df": 7, "s": {"docs": {"vidformer.cv2.vf_cv2.CAP_PROP_POS_FRAMES": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "y": {"docs": {"vidformer.cv2.vf_cv2.frameify": {"tf": 1}}, "df": 1}}}}}}}, "p": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.cv2.vf_cv2.CAP_PROP_FPS": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2.FONT_HERSHEY_SIMPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_PLAIN": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_DUPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_COMPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_TRIPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_COMPLEX_SMALL": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SCRIPT_SIMPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SCRIPT_COMPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_ITALIC": {"tf": 1}}, "df": 9}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "c": {"docs": {"vidformer.cv2.vf_cv2.VideoWriter_fourcc": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter_fourcc.__init__": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"vidformer.cv2.vf_cv2.FILLED": {"tf": 1}}, "df": 1}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"vidformer.cv2.vf_cv2.fillConvexPoly": {"tf": 1}}, "df": 1}}}}}}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"vidformer.cv2.vf_cv2.fillPoly": {"tf": 1}}, "df": 1}}}}}}}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"vidformer.cv2.vf_cv2.CAP_PROP_FRAME_WIDTH": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.VideoWriter.write": {"tf": 1}}, "df": 1}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2.CAP_PROP_FRAME_HEIGHT": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "y": {"docs": {"vidformer.cv2.vf_cv2.FONT_HERSHEY_SIMPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_PLAIN": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_DUPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_COMPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_TRIPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_COMPLEX_SMALL": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SCRIPT_SIMPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SCRIPT_COMPLEX": {"tf": 1}}, "df": 8}}}}}}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {"vidformer.cv2.vf_cv2.FONT_HERSHEY_SIMPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SCRIPT_SIMPLEX": {"tf": 1}}, "df": 2}}}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"vidformer.cv2.vf_cv2.FONT_HERSHEY_COMPLEX_SMALL": {"tf": 1}}, "df": 1}}}}, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2.FONT_HERSHEY_SCRIPT_SIMPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SCRIPT_COMPLEX": {"tf": 1}}, "df": 2}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2.set_cv2_server": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.set": {"tf": 1}}, "df": 2}, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.cv2.vf_cv2.set_cv2_server": {"tf": 1}}, "df": 1}}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.Frame.shape": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {"vidformer.cv2.vf_cv2.VideoWriter.spec": {"tf": 1}}, "df": 1}}}}, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {"vidformer.cv2.vf_cv2.FONT_HERSHEY_DUPLEX": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.cv2.vf_cv2.drawContours": {"tf": 1}}, "df": 1}}}}}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.cv2.vf_cv2.drawMarker": {"tf": 1}}, "df": 1}}}}}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {"vidformer.cv2.vf_cv2.FONT_HERSHEY_TRIPLEX": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"vidformer.cv2.vf_cv2.FONT_ITALIC": {"tf": 1}}, "df": 1}}}}}, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2.Frame.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter_fourcc.__init__": {"tf": 1}}, "df": 4}}}, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"vidformer.cv2.vf_cv2.VideoCapture.isOpened": {"tf": 1}}, "df": 1}}}}}}}, "m": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"vidformer.cv2.vf_cv2.imread": {"tf": 1}}, "df": 1}}}}, "w": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.imwrite": {"tf": 1}}, "df": 1}}}}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.LINE_4": {"tf": 1}, "vidformer.cv2.vf_cv2.LINE_8": {"tf": 1}, "vidformer.cv2.vf_cv2.LINE_AA": {"tf": 1}, "vidformer.cv2.vf_cv2.line": {"tf": 1}}, "df": 4}}}}, "a": {"docs": {}, "df": 0, "a": {"docs": {"vidformer.cv2.vf_cv2.LINE_AA": {"tf": 1}}, "df": 1}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.arrowedLine": {"tf": 1}}, "df": 1}}}}}}}}}}, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"vidformer.cv2.vf_cv2.addWeighted": {"tf": 1}}, "df": 1}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"vidformer.cv2.vf_cv2.Frame.numpy": {"tf": 1}}, "df": 1}}}}}, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.VideoCapture": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.isOpened": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.get": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.set": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.read": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.release": {"tf": 1}}, "df": 7}}}}}}}, "w": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.cv2.vf_cv2.VideoWriter": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter.write": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter.release": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter.spec": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter_fourcc": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter_fourcc.__init__": {"tf": 1}}, "df": 7}}}}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"vidformer.cv2.vf_cv2.vidplay": {"tf": 1}}, "df": 1}}}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2.VideoCapture.get": {"tf": 1}}, "df": 1, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2.getFontScaleFromHeight": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.getTextSize": {"tf": 1}}, "df": 1}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"vidformer.cv2.vf_cv2.VideoCapture.read": {"tf": 1}}, "df": 1}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.VideoCapture.release": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter.release": {"tf": 1}}, "df": 2}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.rectangle": {"tf": 1}}, "df": 1}}}}}}}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"2": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"vidformer.cv2.vf_cv2.ellipse2Poly": {"tf": 1}}, "df": 1}}}}}, "docs": {"vidformer.cv2.vf_cv2.ellipse": {"tf": 1}}, "df": 1}}}}}}}}}, "fullname": {"root": {"4": {"docs": {"vidformer.cv2.vf_cv2.LINE_4": {"tf": 1}}, "df": 1}, "8": {"docs": {"vidformer.cv2.vf_cv2.LINE_8": {"tf": 1}}, "df": 1}, "docs": {"vidformer.cv2.vf_cv2.Frame.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter_fourcc.__init__": {"tf": 1}}, "df": 4, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.cv2.vf_cv2": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_POS_MSEC": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_POS_FRAMES": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_WIDTH": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_HEIGHT": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_FPS": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_COUNT": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SIMPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_PLAIN": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_DUPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_COMPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_TRIPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_COMPLEX_SMALL": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SCRIPT_SIMPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SCRIPT_COMPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_ITALIC": {"tf": 1}, "vidformer.cv2.vf_cv2.FILLED": {"tf": 1}, "vidformer.cv2.vf_cv2.LINE_4": {"tf": 1}, "vidformer.cv2.vf_cv2.LINE_8": {"tf": 1}, "vidformer.cv2.vf_cv2.LINE_AA": {"tf": 1}, "vidformer.cv2.vf_cv2.set_cv2_server": {"tf": 1}, "vidformer.cv2.vf_cv2.Frame": {"tf": 1}, "vidformer.cv2.vf_cv2.Frame.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.Frame.shape": {"tf": 1}, "vidformer.cv2.vf_cv2.Frame.numpy": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.isOpened": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.get": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.set": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.read": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.release": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter.write": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter.release": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter.spec": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter_fourcc": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter_fourcc.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.frameify": {"tf": 1}, "vidformer.cv2.vf_cv2.imread": {"tf": 1}, "vidformer.cv2.vf_cv2.imwrite": {"tf": 1}, "vidformer.cv2.vf_cv2.vidplay": {"tf": 1}, "vidformer.cv2.vf_cv2.rectangle": {"tf": 1}, "vidformer.cv2.vf_cv2.putText": {"tf": 1}, "vidformer.cv2.vf_cv2.arrowedLine": {"tf": 1}, "vidformer.cv2.vf_cv2.line": {"tf": 1}, "vidformer.cv2.vf_cv2.circle": {"tf": 1}, "vidformer.cv2.vf_cv2.getFontScaleFromHeight": {"tf": 1}, "vidformer.cv2.vf_cv2.getTextSize": {"tf": 1}, "vidformer.cv2.vf_cv2.addWeighted": {"tf": 1}, "vidformer.cv2.vf_cv2.clipLine": {"tf": 1}, "vidformer.cv2.vf_cv2.drawContours": {"tf": 1}, "vidformer.cv2.vf_cv2.drawMarker": {"tf": 1}, "vidformer.cv2.vf_cv2.ellipse": {"tf": 1}, "vidformer.cv2.vf_cv2.ellipse2Poly": {"tf": 1}, "vidformer.cv2.vf_cv2.fillConvexPoly": {"tf": 1}, "vidformer.cv2.vf_cv2.fillPoly": {"tf": 1}, "vidformer.cv2.vf_cv2.polylines": {"tf": 1}}, "df": 59}}}}}}, "e": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.VideoCapture": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.isOpened": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.get": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.set": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.read": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.release": {"tf": 1}}, "df": 7}}}}}}}, "w": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.cv2.vf_cv2.VideoWriter": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter.write": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter.release": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter.spec": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter_fourcc": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter_fourcc.__init__": {"tf": 1}}, "df": 7}}}}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"vidformer.cv2.vf_cv2.vidplay": {"tf": 1}}, "df": 1}}}}}}, "f": {"docs": {"vidformer.cv2.vf_cv2": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_POS_MSEC": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_POS_FRAMES": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_WIDTH": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_HEIGHT": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_FPS": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_COUNT": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SIMPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_PLAIN": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_DUPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_COMPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_TRIPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_COMPLEX_SMALL": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SCRIPT_SIMPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SCRIPT_COMPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_ITALIC": {"tf": 1}, "vidformer.cv2.vf_cv2.FILLED": {"tf": 1}, "vidformer.cv2.vf_cv2.LINE_4": {"tf": 1}, "vidformer.cv2.vf_cv2.LINE_8": {"tf": 1}, "vidformer.cv2.vf_cv2.LINE_AA": {"tf": 1}, "vidformer.cv2.vf_cv2.set_cv2_server": {"tf": 1}, "vidformer.cv2.vf_cv2.Frame": {"tf": 1}, "vidformer.cv2.vf_cv2.Frame.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.Frame.shape": {"tf": 1}, "vidformer.cv2.vf_cv2.Frame.numpy": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.isOpened": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.get": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.set": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.read": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.release": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter.write": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter.release": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter.spec": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter_fourcc": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter_fourcc.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.frameify": {"tf": 1}, "vidformer.cv2.vf_cv2.imread": {"tf": 1}, "vidformer.cv2.vf_cv2.imwrite": {"tf": 1}, "vidformer.cv2.vf_cv2.vidplay": {"tf": 1}, "vidformer.cv2.vf_cv2.rectangle": {"tf": 1}, "vidformer.cv2.vf_cv2.putText": {"tf": 1}, "vidformer.cv2.vf_cv2.arrowedLine": {"tf": 1}, "vidformer.cv2.vf_cv2.line": {"tf": 1}, "vidformer.cv2.vf_cv2.circle": {"tf": 1}, "vidformer.cv2.vf_cv2.getFontScaleFromHeight": {"tf": 1}, "vidformer.cv2.vf_cv2.getTextSize": {"tf": 1}, "vidformer.cv2.vf_cv2.addWeighted": {"tf": 1}, "vidformer.cv2.vf_cv2.clipLine": {"tf": 1}, "vidformer.cv2.vf_cv2.drawContours": {"tf": 1}, "vidformer.cv2.vf_cv2.drawMarker": {"tf": 1}, "vidformer.cv2.vf_cv2.ellipse": {"tf": 1}, "vidformer.cv2.vf_cv2.ellipse2Poly": {"tf": 1}, "vidformer.cv2.vf_cv2.fillConvexPoly": {"tf": 1}, "vidformer.cv2.vf_cv2.fillPoly": {"tf": 1}, "vidformer.cv2.vf_cv2.polylines": {"tf": 1}}, "df": 59}}, "c": {"docs": {}, "df": 0, "v": {"2": {"docs": {"vidformer.cv2.vf_cv2": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.CAP_PROP_POS_MSEC": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.CAP_PROP_POS_FRAMES": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_WIDTH": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_HEIGHT": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.CAP_PROP_FPS": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_COUNT": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SIMPLEX": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_PLAIN": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_DUPLEX": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_COMPLEX": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_TRIPLEX": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_COMPLEX_SMALL": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SCRIPT_SIMPLEX": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SCRIPT_COMPLEX": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.FONT_ITALIC": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.FILLED": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.LINE_4": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.LINE_8": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.LINE_AA": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.set_cv2_server": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.Frame": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.Frame.__init__": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.Frame.shape": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.Frame.numpy": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.VideoCapture": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.VideoCapture.__init__": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.VideoCapture.isOpened": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.VideoCapture.get": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.VideoCapture.set": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.VideoCapture.read": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.VideoCapture.release": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.VideoWriter": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.VideoWriter.__init__": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.VideoWriter.write": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.VideoWriter.release": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.VideoWriter.spec": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.VideoWriter_fourcc": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.VideoWriter_fourcc.__init__": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.frameify": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.imread": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.imwrite": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.vidplay": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.rectangle": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.putText": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.arrowedLine": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.line": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.circle": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.getFontScaleFromHeight": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.getTextSize": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.addWeighted": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.clipLine": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.drawContours": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.drawMarker": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.ellipse": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.ellipse2Poly": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.fillConvexPoly": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.fillPoly": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.polylines": {"tf": 1.4142135623730951}}, "df": 59}, "docs": {}, "df": 0}, "a": {"docs": {}, "df": 0, "p": {"docs": {"vidformer.cv2.vf_cv2.CAP_PROP_POS_MSEC": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_POS_FRAMES": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_WIDTH": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_HEIGHT": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_FPS": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_COUNT": {"tf": 1}}, "df": 6}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2.CAP_PROP_FRAME_COUNT": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {"vidformer.cv2.vf_cv2.FONT_HERSHEY_COMPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_COMPLEX_SMALL": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SCRIPT_COMPLEX": {"tf": 1}}, "df": 3}}}}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.circle": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.clipLine": {"tf": 1}}, "df": 1}}}}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {"vidformer.cv2.vf_cv2.CAP_PROP_POS_MSEC": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_POS_FRAMES": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_WIDTH": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_HEIGHT": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_FPS": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_COUNT": {"tf": 1}}, "df": 6}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.cv2.vf_cv2.CAP_PROP_POS_MSEC": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_POS_FRAMES": {"tf": 1}}, "df": 2}, "l": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.cv2.vf_cv2.polylines": {"tf": 1}}, "df": 1}}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"vidformer.cv2.vf_cv2.FONT_HERSHEY_PLAIN": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2.putText": {"tf": 1}}, "df": 1}}}}}}}, "m": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {"vidformer.cv2.vf_cv2.CAP_PROP_POS_MSEC": {"tf": 1}}, "df": 1}}}}, "f": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.CAP_PROP_FRAME_WIDTH": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_HEIGHT": {"tf": 1}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_COUNT": {"tf": 1}, "vidformer.cv2.vf_cv2.Frame": {"tf": 1}, "vidformer.cv2.vf_cv2.Frame.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.Frame.shape": {"tf": 1}, "vidformer.cv2.vf_cv2.Frame.numpy": {"tf": 1}}, "df": 7, "s": {"docs": {"vidformer.cv2.vf_cv2.CAP_PROP_POS_FRAMES": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "y": {"docs": {"vidformer.cv2.vf_cv2.frameify": {"tf": 1}}, "df": 1}}}}}}}, "p": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.cv2.vf_cv2.CAP_PROP_FPS": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2.FONT_HERSHEY_SIMPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_PLAIN": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_DUPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_COMPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_TRIPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_COMPLEX_SMALL": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SCRIPT_SIMPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SCRIPT_COMPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_ITALIC": {"tf": 1}}, "df": 9}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "c": {"docs": {"vidformer.cv2.vf_cv2.VideoWriter_fourcc": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter_fourcc.__init__": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"vidformer.cv2.vf_cv2.FILLED": {"tf": 1}}, "df": 1}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"vidformer.cv2.vf_cv2.fillConvexPoly": {"tf": 1}}, "df": 1}}}}}}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"vidformer.cv2.vf_cv2.fillPoly": {"tf": 1}}, "df": 1}}}}}}}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"vidformer.cv2.vf_cv2.CAP_PROP_FRAME_WIDTH": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.VideoWriter.write": {"tf": 1}}, "df": 1}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2.CAP_PROP_FRAME_HEIGHT": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "y": {"docs": {"vidformer.cv2.vf_cv2.FONT_HERSHEY_SIMPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_PLAIN": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_DUPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_COMPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_TRIPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_COMPLEX_SMALL": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SCRIPT_SIMPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SCRIPT_COMPLEX": {"tf": 1}}, "df": 8}}}}}}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {"vidformer.cv2.vf_cv2.FONT_HERSHEY_SIMPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SCRIPT_SIMPLEX": {"tf": 1}}, "df": 2}}}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"vidformer.cv2.vf_cv2.FONT_HERSHEY_COMPLEX_SMALL": {"tf": 1}}, "df": 1}}}}, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2.FONT_HERSHEY_SCRIPT_SIMPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SCRIPT_COMPLEX": {"tf": 1}}, "df": 2}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2.set_cv2_server": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.set": {"tf": 1}}, "df": 2}, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.cv2.vf_cv2.set_cv2_server": {"tf": 1}}, "df": 1}}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.Frame.shape": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {"vidformer.cv2.vf_cv2.VideoWriter.spec": {"tf": 1}}, "df": 1}}}}, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {"vidformer.cv2.vf_cv2.FONT_HERSHEY_DUPLEX": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.cv2.vf_cv2.drawContours": {"tf": 1}}, "df": 1}}}}}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.cv2.vf_cv2.drawMarker": {"tf": 1}}, "df": 1}}}}}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {"vidformer.cv2.vf_cv2.FONT_HERSHEY_TRIPLEX": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"vidformer.cv2.vf_cv2.FONT_ITALIC": {"tf": 1}}, "df": 1}}}}}, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2.Frame.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter_fourcc.__init__": {"tf": 1}}, "df": 4}}}, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"vidformer.cv2.vf_cv2.VideoCapture.isOpened": {"tf": 1}}, "df": 1}}}}}}}, "m": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"vidformer.cv2.vf_cv2.imread": {"tf": 1}}, "df": 1}}}}, "w": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.imwrite": {"tf": 1}}, "df": 1}}}}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.LINE_4": {"tf": 1}, "vidformer.cv2.vf_cv2.LINE_8": {"tf": 1}, "vidformer.cv2.vf_cv2.LINE_AA": {"tf": 1}, "vidformer.cv2.vf_cv2.line": {"tf": 1}}, "df": 4}}}}, "a": {"docs": {}, "df": 0, "a": {"docs": {"vidformer.cv2.vf_cv2.LINE_AA": {"tf": 1}}, "df": 1}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.arrowedLine": {"tf": 1}}, "df": 1}}}}}}}}}}, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"vidformer.cv2.vf_cv2.addWeighted": {"tf": 1}}, "df": 1}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"vidformer.cv2.vf_cv2.Frame.numpy": {"tf": 1}}, "df": 1}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2.VideoCapture.get": {"tf": 1}}, "df": 1, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2.getFontScaleFromHeight": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.getTextSize": {"tf": 1}}, "df": 1}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"vidformer.cv2.vf_cv2.VideoCapture.read": {"tf": 1}}, "df": 1}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.VideoCapture.release": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter.release": {"tf": 1}}, "df": 2}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.rectangle": {"tf": 1}}, "df": 1}}}}}}}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"2": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"vidformer.cv2.vf_cv2.ellipse2Poly": {"tf": 1}}, "df": 1}}}}}, "docs": {"vidformer.cv2.vf_cv2.ellipse": {"tf": 1}}, "df": 1}}}}}}}}}, "annotation": {"root": {"docs": {}, "df": 0}}, "default_value": {"root": {"0": {"docs": {"vidformer.cv2.vf_cv2.CAP_PROP_POS_MSEC": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SIMPLEX": {"tf": 1}}, "df": 2}, "1": {"6": {"docs": {"vidformer.cv2.vf_cv2.FONT_ITALIC": {"tf": 1}, "vidformer.cv2.vf_cv2.LINE_AA": {"tf": 1}}, "df": 2}, "docs": {"vidformer.cv2.vf_cv2.CAP_PROP_POS_FRAMES": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_PLAIN": {"tf": 1}, "vidformer.cv2.vf_cv2.FILLED": {"tf": 1}}, "df": 3}, "2": {"docs": {"vidformer.cv2.vf_cv2.FONT_HERSHEY_DUPLEX": {"tf": 1}}, "df": 1}, "3": {"docs": {"vidformer.cv2.vf_cv2.CAP_PROP_FRAME_WIDTH": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_COMPLEX": {"tf": 1}}, "df": 2}, "4": {"docs": {"vidformer.cv2.vf_cv2.CAP_PROP_FRAME_HEIGHT": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_TRIPLEX": {"tf": 1}, "vidformer.cv2.vf_cv2.LINE_4": {"tf": 1}}, "df": 3}, "5": {"docs": {"vidformer.cv2.vf_cv2.CAP_PROP_FPS": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_COMPLEX_SMALL": {"tf": 1}}, "df": 2}, "6": {"docs": {"vidformer.cv2.vf_cv2.FONT_HERSHEY_SCRIPT_SIMPLEX": {"tf": 1}}, "df": 1}, "7": {"docs": {"vidformer.cv2.vf_cv2.CAP_PROP_FRAME_COUNT": {"tf": 1}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SCRIPT_COMPLEX": {"tf": 1}}, "df": 2}, "8": {"docs": {"vidformer.cv2.vf_cv2.LINE_8": {"tf": 1}}, "df": 1}, "docs": {"vidformer.cv2.vf_cv2.FILLED": {"tf": 1}}, "df": 1}}, "signature": {"root": {"1": {"docs": {"vidformer.cv2.vf_cv2.addWeighted": {"tf": 1}}, "df": 1}, "docs": {"vidformer.cv2.vf_cv2.set_cv2_server": {"tf": 4.69041575982343}, "vidformer.cv2.vf_cv2.Frame.__init__": {"tf": 3.4641016151377544}, "vidformer.cv2.vf_cv2.Frame.numpy": {"tf": 3.1622776601683795}, "vidformer.cv2.vf_cv2.VideoCapture.__init__": {"tf": 2.8284271247461903}, "vidformer.cv2.vf_cv2.VideoCapture.isOpened": {"tf": 3.1622776601683795}, "vidformer.cv2.vf_cv2.VideoCapture.get": {"tf": 3.7416573867739413}, "vidformer.cv2.vf_cv2.VideoCapture.set": {"tf": 4.242640687119285}, "vidformer.cv2.vf_cv2.VideoCapture.read": {"tf": 3.1622776601683795}, "vidformer.cv2.vf_cv2.VideoCapture.release": {"tf": 3.1622776601683795}, "vidformer.cv2.vf_cv2.VideoWriter.__init__": {"tf": 4.47213595499958}, "vidformer.cv2.vf_cv2.VideoWriter.write": {"tf": 3.7416573867739413}, "vidformer.cv2.vf_cv2.VideoWriter.release": {"tf": 3.1622776601683795}, "vidformer.cv2.vf_cv2.VideoWriter.spec": {"tf": 4.47213595499958}, "vidformer.cv2.vf_cv2.VideoWriter_fourcc.__init__": {"tf": 3.1622776601683795}, "vidformer.cv2.vf_cv2.frameify": {"tf": 4.242640687119285}, "vidformer.cv2.vf_cv2.imread": {"tf": 4}, "vidformer.cv2.vf_cv2.imwrite": {"tf": 4.47213595499958}, "vidformer.cv2.vf_cv2.vidplay": {"tf": 4.69041575982343}, "vidformer.cv2.vf_cv2.rectangle": {"tf": 6.782329983125268}, "vidformer.cv2.vf_cv2.putText": {"tf": 7.937253933193772}, "vidformer.cv2.vf_cv2.arrowedLine": {"tf": 7.874007874011811}, "vidformer.cv2.vf_cv2.line": {"tf": 6.782329983125268}, "vidformer.cv2.vf_cv2.circle": {"tf": 7.280109889280518}, "vidformer.cv2.vf_cv2.getFontScaleFromHeight": {"tf": 4.242640687119285}, "vidformer.cv2.vf_cv2.getTextSize": {"tf": 4.242640687119285}, "vidformer.cv2.vf_cv2.addWeighted": {"tf": 6.48074069840786}, "vidformer.cv2.vf_cv2.clipLine": {"tf": 4.242640687119285}, "vidformer.cv2.vf_cv2.drawContours": {"tf": 4.242640687119285}, "vidformer.cv2.vf_cv2.drawMarker": {"tf": 4.242640687119285}, "vidformer.cv2.vf_cv2.ellipse": {"tf": 4.242640687119285}, "vidformer.cv2.vf_cv2.ellipse2Poly": {"tf": 4.242640687119285}, "vidformer.cv2.vf_cv2.fillConvexPoly": {"tf": 4.242640687119285}, "vidformer.cv2.vf_cv2.fillPoly": {"tf": 4.242640687119285}, "vidformer.cv2.vf_cv2.polylines": {"tf": 4.242640687119285}}, "df": 34, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.cv2.vf_cv2.set_cv2_server": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "f": {"docs": {"vidformer.cv2.vf_cv2.Frame.numpy": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.isOpened": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.get": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.set": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.read": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.release": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter.write": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter.release": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter.spec": {"tf": 1}}, "df": 9}}}, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.VideoWriter.__init__": {"tf": 1}}, "df": 1}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {"vidformer.cv2.vf_cv2.VideoWriter.spec": {"tf": 1}}, "df": 1}}}, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2.rectangle": {"tf": 1}, "vidformer.cv2.vf_cv2.arrowedLine": {"tf": 1}, "vidformer.cv2.vf_cv2.line": {"tf": 1}, "vidformer.cv2.vf_cv2.circle": {"tf": 1}}, "df": 4}}}}, "r": {"docs": {}, "df": 0, "c": {"1": {"docs": {"vidformer.cv2.vf_cv2.addWeighted": {"tf": 1}}, "df": 1}, "2": {"docs": {"vidformer.cv2.vf_cv2.addWeighted": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}}}, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.cv2.vf_cv2.set_cv2_server": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter.spec": {"tf": 1}}, "df": 2}}}}}}, "e": {"docs": {}, "df": 0, "o": {"docs": {"vidformer.cv2.vf_cv2.vidplay": {"tf": 1}}, "df": 1}}}}, "f": {"docs": {"vidformer.cv2.vf_cv2.set_cv2_server": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter.spec": {"tf": 1}}, "df": 2}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.VideoCapture.set": {"tf": 1}}, "df": 1}}}}}, "y": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.cv2.vf_cv2.set_cv2_server": {"tf": 1}}, "df": 1}}}}}}}}}}}, "f": {"docs": {"vidformer.cv2.vf_cv2.Frame.__init__": {"tf": 1}}, "df": 1, "m": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2.Frame.__init__": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "c": {"docs": {"vidformer.cv2.vf_cv2.VideoWriter.__init__": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.putText": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.putText": {"tf": 1}}, "df": 1}}}}}}}}, "p": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.cv2.vf_cv2.VideoWriter.__init__": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.VideoWriter.write": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {"vidformer.cv2.vf_cv2.frameify": {"tf": 1}}, "df": 1}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"vidformer.cv2.vf_cv2.VideoCapture.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoWriter.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.imread": {"tf": 1}, "vidformer.cv2.vf_cv2.imwrite": {"tf": 1}}, "df": 4}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {"vidformer.cv2.vf_cv2.VideoCapture.get": {"tf": 1}, "vidformer.cv2.vf_cv2.VideoCapture.set": {"tf": 1}}, "df": 2}}}, "t": {"1": {"docs": {"vidformer.cv2.vf_cv2.rectangle": {"tf": 1}, "vidformer.cv2.vf_cv2.arrowedLine": {"tf": 1}, "vidformer.cv2.vf_cv2.line": {"tf": 1}}, "df": 3}, "2": {"docs": {"vidformer.cv2.vf_cv2.rectangle": {"tf": 1}, "vidformer.cv2.vf_cv2.arrowedLine": {"tf": 1}, "vidformer.cv2.vf_cv2.line": {"tf": 1}}, "df": 3}, "docs": {}, "df": 0}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.cv2.vf_cv2.VideoWriter_fourcc.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.imread": {"tf": 1}, "vidformer.cv2.vf_cv2.imwrite": {"tf": 1}, "vidformer.cv2.vf_cv2.vidplay": {"tf": 1}, "vidformer.cv2.vf_cv2.getFontScaleFromHeight": {"tf": 1}, "vidformer.cv2.vf_cv2.getTextSize": {"tf": 1}, "vidformer.cv2.vf_cv2.clipLine": {"tf": 1}, "vidformer.cv2.vf_cv2.drawContours": {"tf": 1}, "vidformer.cv2.vf_cv2.drawMarker": {"tf": 1}, "vidformer.cv2.vf_cv2.ellipse": {"tf": 1}, "vidformer.cv2.vf_cv2.ellipse2Poly": {"tf": 1}, "vidformer.cv2.vf_cv2.fillConvexPoly": {"tf": 1}, "vidformer.cv2.vf_cv2.fillPoly": {"tf": 1}, "vidformer.cv2.vf_cv2.polylines": {"tf": 1}}, "df": 14}}}, "l": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {"vidformer.cv2.vf_cv2.addWeighted": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "j": {"docs": {"vidformer.cv2.vf_cv2.frameify": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "g": {"docs": {"vidformer.cv2.vf_cv2.putText": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.frameify": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.frameify": {"tf": 1}, "vidformer.cv2.vf_cv2.rectangle": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.putText": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.arrowedLine": {"tf": 2}, "vidformer.cv2.vf_cv2.line": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.circle": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.addWeighted": {"tf": 1}}, "df": 7}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "g": {"docs": {"vidformer.cv2.vf_cv2.imwrite": {"tf": 1}, "vidformer.cv2.vf_cv2.rectangle": {"tf": 1}, "vidformer.cv2.vf_cv2.putText": {"tf": 1}, "vidformer.cv2.vf_cv2.arrowedLine": {"tf": 1}, "vidformer.cv2.vf_cv2.line": {"tf": 1}, "vidformer.cv2.vf_cv2.circle": {"tf": 1}}, "df": 6}}}, "k": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.cv2.vf_cv2.vidplay": {"tf": 1}, "vidformer.cv2.vf_cv2.getFontScaleFromHeight": {"tf": 1}, "vidformer.cv2.vf_cv2.getTextSize": {"tf": 1}, "vidformer.cv2.vf_cv2.clipLine": {"tf": 1}, "vidformer.cv2.vf_cv2.drawContours": {"tf": 1}, "vidformer.cv2.vf_cv2.drawMarker": {"tf": 1}, "vidformer.cv2.vf_cv2.ellipse": {"tf": 1}, "vidformer.cv2.vf_cv2.ellipse2Poly": {"tf": 1}, "vidformer.cv2.vf_cv2.fillConvexPoly": {"tf": 1}, "vidformer.cv2.vf_cv2.fillPoly": {"tf": 1}, "vidformer.cv2.vf_cv2.polylines": {"tf": 1}}, "df": 11}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.cv2.vf_cv2.rectangle": {"tf": 1}, "vidformer.cv2.vf_cv2.putText": {"tf": 1}, "vidformer.cv2.vf_cv2.arrowedLine": {"tf": 1}, "vidformer.cv2.vf_cv2.line": {"tf": 1}, "vidformer.cv2.vf_cv2.circle": {"tf": 1}}, "df": 5}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.cv2.vf_cv2.circle": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.cv2.vf_cv2.rectangle": {"tf": 1}, "vidformer.cv2.vf_cv2.putText": {"tf": 1}, "vidformer.cv2.vf_cv2.arrowedLine": {"tf": 1}, "vidformer.cv2.vf_cv2.line": {"tf": 1}, "vidformer.cv2.vf_cv2.circle": {"tf": 1}}, "df": 5}}}}}}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2.putText": {"tf": 1}}, "df": 1}}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.arrowedLine": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"vidformer.cv2.vf_cv2.arrowedLine": {"tf": 1}}, "df": 1}}}}}}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.arrowedLine": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.rectangle": {"tf": 1}, "vidformer.cv2.vf_cv2.putText": {"tf": 1}, "vidformer.cv2.vf_cv2.line": {"tf": 1}, "vidformer.cv2.vf_cv2.circle": {"tf": 1}}, "df": 4}}}}}}}}, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"vidformer.cv2.vf_cv2.putText": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"vidformer.cv2.vf_cv2.addWeighted": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.cv2.vf_cv2.circle": {"tf": 1}}, "df": 1}}}}}}, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"vidformer.cv2.vf_cv2.addWeighted": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2.addWeighted": {"tf": 1}}, "df": 1}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.addWeighted": {"tf": 1}}, "df": 1}}}}}}}, "bases": {"root": {"docs": {}, "df": 0}}, "doc": {"root": {"docs": {"vidformer.cv2.vf_cv2": {"tf": 6.557438524302}, "vidformer.cv2.vf_cv2.CAP_PROP_POS_MSEC": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.CAP_PROP_POS_FRAMES": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_WIDTH": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_HEIGHT": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.CAP_PROP_FPS": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.CAP_PROP_FRAME_COUNT": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SIMPLEX": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_PLAIN": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_DUPLEX": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_COMPLEX": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_TRIPLEX": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_COMPLEX_SMALL": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SCRIPT_SIMPLEX": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.FONT_HERSHEY_SCRIPT_COMPLEX": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.FONT_ITALIC": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.FILLED": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.LINE_4": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.LINE_8": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.LINE_AA": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.set_cv2_server": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.Frame": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.Frame.__init__": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.Frame.shape": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.Frame.numpy": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.VideoCapture": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.VideoCapture.__init__": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.VideoCapture.isOpened": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.VideoCapture.get": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.VideoCapture.set": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.VideoCapture.read": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.VideoCapture.release": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.VideoWriter": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.VideoWriter.__init__": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.VideoWriter.write": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.VideoWriter.release": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.VideoWriter.spec": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.VideoWriter_fourcc": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.VideoWriter_fourcc.__init__": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.frameify": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.imread": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.imwrite": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.vidplay": {"tf": 2.23606797749979}, "vidformer.cv2.vf_cv2.rectangle": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.putText": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.arrowedLine": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.line": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.circle": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.getFontScaleFromHeight": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.getTextSize": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.addWeighted": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.clipLine": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.drawContours": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.drawMarker": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.ellipse": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.ellipse2Poly": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.fillConvexPoly": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.fillPoly": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.polylines": {"tf": 1.7320508075688772}}, "df": 59, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.cv2.vf_cv2": {"tf": 2}, "vidformer.cv2.vf_cv2.vidplay": {"tf": 2}}, "df": 2}}}}}}, "e": {"docs": {}, "df": 0, "o": {"docs": {"vidformer.cv2.vf_cv2.vidplay": {"tf": 1.4142135623730951}}, "df": 1, "w": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.cv2.vf_cv2.vidplay": {"tf": 1}}, "df": 1}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "v": {"2": {"docs": {"vidformer.cv2.vf_cv2": {"tf": 1.7320508075688772}, "vidformer.cv2.vf_cv2.set_cv2_server": {"tf": 1}, "vidformer.cv2.vf_cv2.vidplay": {"tf": 1}}, "df": 3}, "docs": {"vidformer.cv2.vf_cv2.rectangle": {"tf": 1}, "vidformer.cv2.vf_cv2.putText": {"tf": 1}, "vidformer.cv2.vf_cv2.arrowedLine": {"tf": 1}, "vidformer.cv2.vf_cv2.getFontScaleFromHeight": {"tf": 1}, "vidformer.cv2.vf_cv2.getTextSize": {"tf": 1}, "vidformer.cv2.vf_cv2.addWeighted": {"tf": 1}}, "df": 6}, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2": {"tf": 1}}, "df": 1}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.cv2.vf_cv2.rectangle": {"tf": 1}, "vidformer.cv2.vf_cv2.putText": {"tf": 1}, "vidformer.cv2.vf_cv2.arrowedLine": {"tf": 1}}, "df": 3}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.cv2.vf_cv2": {"tf": 1.4142135623730951}}, "df": 1}, "n": {"docs": {"vidformer.cv2.vf_cv2": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "o": {"docs": {"vidformer.cv2.vf_cv2.frameify": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"vidformer.cv2.vf_cv2": {"tf": 1}}, "df": 1}}}}}}}}}, "g": {"docs": {"vidformer.cv2.vf_cv2.rectangle": {"tf": 1}, "vidformer.cv2.vf_cv2.putText": {"tf": 1}, "vidformer.cv2.vf_cv2.arrowedLine": {"tf": 1}}, "df": 3}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.set_cv2_server": {"tf": 1.4142135623730951}, "vidformer.cv2.vf_cv2.Frame.numpy": {"tf": 1}}, "df": 3}, "i": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.cv2.vf_cv2": {"tf": 1}}, "df": 1}, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.cv2.vf_cv2.rectangle": {"tf": 1}, "vidformer.cv2.vf_cv2.putText": {"tf": 1}, "vidformer.cv2.vf_cv2.arrowedLine": {"tf": 1}, "vidformer.cv2.vf_cv2.getFontScaleFromHeight": {"tf": 1}, "vidformer.cv2.vf_cv2.getTextSize": {"tf": 1}}, "df": 5}}}}}}}}, "o": {"docs": {"vidformer.cv2.vf_cv2.set_cv2_server": {"tf": 1}}, "df": 1}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {"vidformer.cv2.vf_cv2.frameify": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2.putText": {"tf": 1}, "vidformer.cv2.vf_cv2.getTextSize": {"tf": 1}}, "df": 2}}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.arrowedLine": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"vidformer.cv2.vf_cv2.arrowedLine": {"tf": 1}}, "df": 1}}}}}}}}}, "f": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"vidformer.cv2.vf_cv2": {"tf": 1}, "vidformer.cv2.vf_cv2.set_cv2_server": {"tf": 1}}, "df": 2}}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.Frame.numpy": {"tf": 1}, "vidformer.cv2.vf_cv2.frameify": {"tf": 1}}, "df": 2}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.cv2.vf_cv2": {"tf": 1}, "vidformer.cv2.vf_cv2.set_cv2_server": {"tf": 1}}, "df": 2}, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.putText": {"tf": 1}, "vidformer.cv2.vf_cv2.getFontScaleFromHeight": {"tf": 1}, "vidformer.cv2.vf_cv2.getTextSize": {"tf": 1}}, "df": 3}}}}, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.putText": {"tf": 1}, "vidformer.cv2.vf_cv2.getTextSize": {"tf": 1}}, "df": 2}}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.cv2.vf_cv2": {"tf": 1}}, "df": 1}}}}}}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {"vidformer.cv2.vf_cv2": {"tf": 1}, "vidformer.cv2.vf_cv2.Frame.numpy": {"tf": 1}, "vidformer.cv2.vf_cv2.frameify": {"tf": 1}, "vidformer.cv2.vf_cv2.vidplay": {"tf": 1}}, "df": 4, "s": {"docs": {"vidformer.cv2.vf_cv2.Frame.numpy": {"tf": 1}}, "df": 1}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"vidformer.cv2.vf_cv2.Frame.numpy": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.arrowedLine": {"tf": 1}}, "df": 1}}}}}}}}}, "g": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.cv2.vf_cv2.vidplay": {"tf": 1}}, "df": 1}}}, "n": {"docs": {"vidformer.cv2.vf_cv2.frameify": {"tf": 1}}, "df": 1}, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"vidformer.cv2.vf_cv2.addWeighted": {"tf": 1}}, "df": 1}}}}}}}}}}, "l": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {"vidformer.cv2.vf_cv2.addWeighted": {"tf": 1}}, "df": 1}}}}}, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {"vidformer.cv2.vf_cv2": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.cv2.vf_cv2": {"tf": 1}}, "df": 1}}}}}}}, "y": {"docs": {"vidformer.cv2.vf_cv2": {"tf": 1}}, "df": 1, "p": {"docs": {}, "df": 0, "i": {"docs": {"vidformer.cv2.vf_cv2": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"vidformer.cv2.vf_cv2.vidplay": {"tf": 1}}, "df": 1}}}, "t": {"1": {"docs": {"vidformer.cv2.vf_cv2.rectangle": {"tf": 1}, "vidformer.cv2.vf_cv2.arrowedLine": {"tf": 1}}, "df": 2}, "2": {"docs": {"vidformer.cv2.vf_cv2.rectangle": {"tf": 1}, "vidformer.cv2.vf_cv2.arrowedLine": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2.putText": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2.getFontScaleFromHeight": {"tf": 1}}, "df": 1}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2": {"tf": 1}}, "df": 1}, "t": {"docs": {"vidformer.cv2.vf_cv2.set_cv2_server": {"tf": 1}}, "df": 1}, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.cv2.vf_cv2.set_cv2_server": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2": {"tf": 1}, "vidformer.cv2.vf_cv2.vidplay": {"tf": 1}}, "df": 2}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {"vidformer.cv2.vf_cv2.vidplay": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"vidformer.cv2.vf_cv2.vidplay": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2.rectangle": {"tf": 1}, "vidformer.cv2.vf_cv2.arrowedLine": {"tf": 1}}, "df": 2}}}}, "r": {"docs": {}, "df": 0, "c": {"1": {"docs": {"vidformer.cv2.vf_cv2.addWeighted": {"tf": 1}}, "df": 1}, "2": {"docs": {"vidformer.cv2.vf_cv2.addWeighted": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2": {"tf": 1}}, "df": 1}}, "n": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.cv2.vf_cv2": {"tf": 1}}, "df": 1}}, "e": {"docs": {"vidformer.cv2.vf_cv2.arrowedLine": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.rectangle": {"tf": 1}, "vidformer.cv2.vf_cv2.putText": {"tf": 1}}, "df": 2}}}}}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"vidformer.cv2.vf_cv2": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"vidformer.cv2.vf_cv2": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2.addWeighted": {"tf": 1.4142135623730951}}, "df": 1}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.addWeighted": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.set_cv2_server": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {"vidformer.cv2.vf_cv2.Frame.numpy": {"tf": 1}}, "df": 1}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.rectangle": {"tf": 1}}, "df": 1}}}}}}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"vidformer.cv2.vf_cv2.Frame.numpy": {"tf": 1}}, "df": 1}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"vidformer.cv2.vf_cv2.frameify": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2.frameify": {"tf": 1}}, "df": 1}}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.vidplay": {"tf": 1}}, "df": 1}}, "f": {"docs": {"vidformer.cv2.vf_cv2.vidplay": {"tf": 1}}, "df": 1}, "r": {"docs": {}, "df": 0, "g": {"docs": {"vidformer.cv2.vf_cv2.putText": {"tf": 1}}, "df": 1}}}, "e": {"docs": {"vidformer.cv2.vf_cv2.frameify": {"tf": 1}}, "df": 1}, "g": {"docs": {"vidformer.cv2.vf_cv2.frameify": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.cv2.vf_cv2.getFontScaleFromHeight": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.getTextSize": {"tf": 1}}, "df": 1}}}}}}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"vidformer.cv2.vf_cv2.addWeighted": {"tf": 1}}, "df": 1}}}}}, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"vidformer.cv2.vf_cv2.putText": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"vidformer.cv2.vf_cv2.addWeighted": {"tf": 1}}, "df": 1}}}}}}}, "pipeline": ["trimmer"], "_isPrebuiltIndex": true}; + + // mirrored in build-search-index.js (part 1) + // Also split on html tags. this is a cheap heuristic, but good enough. + elasticlunr.tokenizer.setSeperator(/[\s\-.;&_'"=,()]+|<[^>]*>/); + + let searchIndex; + if (docs._isPrebuiltIndex) { + console.info("using precompiled search index"); + searchIndex = elasticlunr.Index.load(docs); + } else { + console.time("building search index"); + // mirrored in build-search-index.js (part 2) + searchIndex = elasticlunr(function () { + this.pipeline.remove(elasticlunr.stemmer); + this.pipeline.remove(elasticlunr.stopWordFilter); + this.addField("qualname"); + this.addField("fullname"); + this.addField("annotation"); + this.addField("default_value"); + this.addField("signature"); + this.addField("bases"); + this.addField("doc"); + this.setRef("fullname"); + }); + for (let doc of docs) { + searchIndex.addDoc(doc); + } + console.timeEnd("building search index"); + } + + return (term) => searchIndex.search(term, { + fields: { + qualname: {boost: 4}, + fullname: {boost: 2}, + annotation: {boost: 2}, + default_value: {boost: 2}, + signature: {boost: 2}, + bases: {boost: 2}, + doc: {boost: 1}, + }, + expand: true + }); +})(); \ No newline at end of file diff --git a/vidformer-py-cv2/vidformer/cv2/vf_cv2.html b/vidformer-py-cv2/vidformer/cv2/vf_cv2.html new file mode 100644 index 0000000..8d5c5d6 --- /dev/null +++ b/vidformer-py-cv2/vidformer/cv2/vf_cv2.html @@ -0,0 +1,2449 @@ + + + + + + +
+vidformer.cv2.vf_cv2
+
+ vidformer.cv2 is the cv2 frontend for vidformer.
+ +++ +⚠️ This module is a work in progress. See the implemented functions list.
+
Quick links:
+ + +1""" + 2vidformer.cv2 is the cv2 frontend for [vidformer](https://github.com/ixlab/vidformer). + 3 + 4> ⚠️ This module is a work in progress. See the [implemented functions list](https://ixlab.github.io/vidformer/opencv-filters.html). + 5 + 6**Quick links:** + 7* [📦 PyPI](https://pypi.org/project/vidformer/) + 8* [📘 Documentation - vidformer-py](https://ixlab.github.io/vidformer/vidformer-py/) + 9* [📘 Documentation - vidformer.cv2](https://ixlab.github.io/vidformer/vidformer-py-cv2/) + 10* [🧑💻 Source Code](https://github.com/ixlab/vidformer/tree/main/vidformer-py/) + 11""" + 12 + 13from .. import vf + 14 + 15try: + 16 import cv2 as _opencv2 + 17except: + 18 _opencv2 = None + 19 + 20import numpy as np + 21 + 22import uuid + 23from fractions import Fraction + 24from bisect import bisect_right + 25 + 26CAP_PROP_POS_MSEC = 0 + 27CAP_PROP_POS_FRAMES = 1 + 28CAP_PROP_FRAME_WIDTH = 3 + 29CAP_PROP_FRAME_HEIGHT = 4 + 30CAP_PROP_FPS = 5 + 31CAP_PROP_FRAME_COUNT = 7 + 32 + 33FONT_HERSHEY_SIMPLEX = 0 + 34FONT_HERSHEY_PLAIN = 1 + 35FONT_HERSHEY_DUPLEX = 2 + 36FONT_HERSHEY_COMPLEX = 3 + 37FONT_HERSHEY_TRIPLEX = 4 + 38FONT_HERSHEY_COMPLEX_SMALL = 5 + 39FONT_HERSHEY_SCRIPT_SIMPLEX = 6 + 40FONT_HERSHEY_SCRIPT_COMPLEX = 7 + 41FONT_ITALIC = 16 + 42 + 43FILLED = -1 + 44LINE_4 = 4 + 45LINE_8 = 8 + 46LINE_AA = 16 + 47 + 48_inline_mat = vf.Filter("_inline_mat") + 49_slice_mat = vf.Filter("_slice_mat") + 50_slice_write_mat = vf.Filter("_slice_write_mat") + 51 + 52 + 53_filter_scale = vf.Filter("Scale") + 54_filter_rectangle = vf.Filter("cv2.rectangle") + 55_filter_putText = vf.Filter("cv2.putText") + 56_filter_arrowedLine = vf.Filter("cv2.arrowedLine") + 57_filter_line = vf.Filter("cv2.line") + 58_filter_circle = vf.Filter("cv2.circle") + 59_filter_addWeighted = vf.Filter("cv2.addWeighted") + 60 + 61 + 62def _ts_to_fps(timestamps): + 63 return int(1 / (timestamps[1] - timestamps[0])) # TODO: Fix for non-integer fps + 64 + 65 + 66def _fps_to_ts(fps, n_frames): + 67 assert type(fps) == int + 68 return [Fraction(i, fps) for i in range(n_frames)] + 69 + 70 + 71_global_cv2_server = None + 72 + 73 + 74def _server(): + 75 global _global_cv2_server + 76 if _global_cv2_server is None: + 77 _global_cv2_server = vf.YrdenServer() + 78 return _global_cv2_server + 79 + 80 + 81def set_cv2_server(server: vf.YrdenServer): + 82 """Set the server to use for the cv2 frontend.""" + 83 global _global_cv2_server + 84 assert isinstance(server, vf.YrdenServer) + 85 _global_cv2_server = server + 86 + 87 + 88class Frame: + 89 def __init__(self, f, fmt): + 90 self._f = f + 91 self._fmt = fmt + 92 self.shape = (fmt["height"], fmt["width"], 3) + 93 + 94 # denotes that the frame has not yet been modified + 95 # when a frame is modified, it is converted to rgb24 first + 96 self._modified = False + 97 + 98 def _mut(self): + 99 if self._modified: +100 assert self._fmt["pix_fmt"] == "rgb24" +101 return +102 +103 self._modified = True +104 if self._fmt["pix_fmt"] != "rgb24": +105 self._f = _filter_scale(self._f, pix_fmt="rgb24") +106 self._fmt["pix_fmt"] = "rgb24" +107 +108 def numpy(self): +109 """ +110 Return the frame as a numpy array. +111 """ +112 +113 self._mut() +114 spec = vf.Spec([Fraction(0, 1)], lambda t, i: self._f, self._fmt) +115 loader = spec.load(_server()) +116 +117 frame_raster_rgb24 = loader[0] +118 assert type(frame_raster_rgb24) == bytes +119 assert len(frame_raster_rgb24) == self.shape[0] * self.shape[1] * 3 +120 raw_data_array = np.frombuffer(frame_raster_rgb24, dtype=np.uint8) +121 frame = raw_data_array.reshape(self.shape) +122 frame = frame[:, :, ::-1] # convert RGB to BGR +123 return frame +124 +125 def __getitem__(self, key): +126 if not isinstance(key, tuple): +127 raise NotImplementedError("Only 2D slicing is supported") +128 +129 if len(key) != 2: +130 raise NotImplementedError("Only 2D slicing is supported") +131 +132 if not all(isinstance(x, slice) for x in key): +133 raise NotImplementedError("Only 2D slicing is supported") +134 +135 miny = key[0].start if key[0].start is not None else 0 +136 maxy = key[0].stop if key[0].stop is not None else self.shape[0] +137 minx = key[1].start if key[1].start is not None else 0 +138 maxx = key[1].stop if key[1].stop is not None else self.shape[1] +139 +140 # handle negative indices +141 if miny < 0: +142 miny = self.shape[0] + miny +143 if maxy < 0: +144 maxy = self.shape[0] + maxy +145 if minx < 0: +146 minx = self.shape[1] + minx +147 if maxx < 0: +148 maxx = self.shape[1] + maxx +149 +150 if ( +151 maxy <= miny +152 or maxx <= minx +153 or miny < 0 +154 or minx < 0 +155 or maxy > self.shape[0] +156 or maxx > self.shape[1] +157 ): +158 raise NotImplementedError("Invalid slice") +159 +160 f = _slice_mat(self._f, miny, maxy, minx, maxx) +161 fmt = self._fmt.copy() +162 fmt["width"] = maxx - minx +163 fmt["height"] = maxy - miny +164 return Frame(f, fmt) +165 +166 def __setitem__(self, key, value): +167 value = frameify(value, "value") +168 +169 if not isinstance(key, tuple): +170 raise NotImplementedError("Only 2D slicing is supported") +171 +172 if len(key) != 2: +173 raise NotImplementedError("Only 2D slicing is supported") +174 +175 if not all(isinstance(x, slice) for x in key): +176 raise NotImplementedError("Only 2D slicing is supported") +177 +178 miny = key[0].start if key[0].start is not None else 0 +179 maxy = key[0].stop if key[0].stop is not None else self.shape[0] +180 minx = key[1].start if key[1].start is not None else 0 +181 maxx = key[1].stop if key[1].stop is not None else self.shape[1] +182 +183 # handle negative indices +184 if miny < 0: +185 miny = self.shape[0] + miny +186 if maxy < 0: +187 maxy = self.shape[0] + maxy +188 if minx < 0: +189 minx = self.shape[1] + minx +190 if maxx < 0: +191 maxx = self.shape[1] + maxx +192 +193 if ( +194 maxy <= miny +195 or maxx <= minx +196 or miny < 0 +197 or minx < 0 +198 or maxy > self.shape[0] +199 or maxx > self.shape[1] +200 ): +201 raise NotImplementedError("Invalid slice") +202 +203 if value.shape[0] != maxy - miny or value.shape[1] != maxx - minx: +204 raise NotImplementedError("Shape mismatch") +205 +206 self._mut() +207 value._mut() +208 +209 self._f = _slice_write_mat(self._f, value._f, miny, maxy, minx, maxx) +210 +211 +212def _inline_frame(arr): +213 assert arr.dtype == np.uint8 +214 assert arr.ndim == 3 +215 assert arr.shape[2] == 3 +216 +217 # convert BGR to RGB +218 arr = arr[:, :, ::-1] +219 +220 width = arr.shape[1] +221 height = arr.shape[0] +222 pix_fmt = "rgb24" +223 +224 f = _inline_mat(arr.tobytes(), width=width, height=height, pix_fmt=pix_fmt) +225 fmt = {"width": width, "height": height, "pix_fmt": pix_fmt} +226 return Frame(f, fmt) +227 +228 +229class VideoCapture: +230 def __init__(self, path): +231 self._path = path +232 server = _server() +233 self._source = vf.Source(server, str(uuid.uuid4()), path, 0) +234 self._next_frame_idx = 0 +235 +236 def isOpened(self): +237 return True +238 +239 def get(self, prop): +240 if prop == CAP_PROP_FPS: +241 return _ts_to_fps(self._source.ts()) +242 elif prop == CAP_PROP_FRAME_WIDTH: +243 return self._source.fmt()["width"] +244 elif prop == CAP_PROP_FRAME_HEIGHT: +245 return self._source.fmt()["height"] +246 elif prop == CAP_PROP_FRAME_COUNT: +247 return len(self._source.ts()) +248 elif prop == CAP_PROP_POS_FRAMES: +249 return self._next_frame_idx +250 +251 raise Exception(f"Unknown property {prop}") +252 +253 def set(self, prop, value): +254 if prop == CAP_PROP_POS_FRAMES: +255 assert value >= 0 and value < len(self._source.ts()) +256 self._next_frame_idx = value +257 elif prop == CAP_PROP_POS_MSEC: +258 t = Fraction(value, 1000) +259 ts = self._source.ts() +260 next_frame_idx = bisect_right(ts, t) +261 self._next_frame_idx = next_frame_idx +262 else: +263 raise Exception(f"Unsupported property {prop}") +264 +265 def read(self): +266 if self._next_frame_idx >= len(self._source.ts()): +267 return False, None +268 frame = self._source.iloc[self._next_frame_idx] +269 self._next_frame_idx += 1 +270 frame = Frame(frame, self._source.fmt()) +271 return True, frame +272 +273 def release(self): +274 pass +275 +276 +277class VideoWriter: +278 def __init__(self, path, fourcc, fps, size): +279 assert isinstance(fourcc, VideoWriter_fourcc) +280 if path is not None and not isinstance(path, str): +281 raise Exception("path must be a string or None") +282 self._path = path +283 self._fourcc = fourcc +284 self._fps = fps +285 self._size = size +286 +287 self._frames = [] +288 self._pix_fmt = "yuv420p" +289 +290 def write(self, frame): +291 frame = frameify(frame, "frame") +292 +293 if frame._fmt["pix_fmt"] != self._pix_fmt: +294 f_obj = _filter_scale(frame._f, pix_fmt=self._pix_fmt) +295 self._frames.append(f_obj) +296 else: +297 self._frames.append(frame._f) +298 +299 def release(self): +300 if self._path is None: +301 return +302 +303 spec = self.spec() +304 server = _server() +305 spec.save(server, self._path) +306 +307 def spec(self) -> vf.Spec: +308 fmt = { +309 "width": self._size[0], +310 "height": self._size[1], +311 "pix_fmt": self._pix_fmt, +312 } +313 domain = _fps_to_ts(self._fps, len(self._frames)) +314 spec = vf.Spec(domain, lambda t, i: self._frames[i], fmt) +315 return spec +316 +317 +318class VideoWriter_fourcc: +319 def __init__(self, *args): +320 self._args = args +321 +322 +323def frameify(obj, field_name=None): +324 """ +325 Turn an object (e.g., ndarray) into a Frame. +326 """ +327 +328 if isinstance(obj, Frame): +329 return obj +330 elif isinstance(obj, np.ndarray): +331 return _inline_frame(obj) +332 else: +333 if field_name is not None: +334 raise Exception( +335 f"Unsupported type for field {field_name}, expected Frame or np.ndarray" +336 ) +337 else: +338 raise Exception("Unsupported type, expected Frame or np.ndarray") +339 +340 +341def imread(path, *args): +342 if len(args) > 0: +343 raise NotImplementedError("imread does not support additional arguments") +344 +345 assert path.lower().endswith((".jpg", ".jpeg", ".png")) +346 server = _server() +347 source = vf.Source(server, str(uuid.uuid4()), path, 0) +348 frame = Frame(source.iloc[0], source.fmt()) +349 return frame +350 +351 +352def imwrite(path, img, *args): +353 if len(args) > 0: +354 raise NotImplementedError("imwrite does not support additional arguments") +355 +356 img = frameify(img) +357 +358 fmt = img._fmt.copy() +359 width = fmt["width"] +360 height = fmt["height"] +361 f = img._f +362 +363 domain = [Fraction(0, 1)] +364 +365 if path.lower().endswith(".png"): +366 img._mut() # Make sure it's in rgb24 +367 spec = vf.Spec( +368 domain, +369 lambda t, i: img._f, +370 {"width": width, "height": height, "pix_fmt": "rgb24"}, +371 ) +372 spec.save(_server(), path, encoder="png") +373 elif path.lower().endswith((".jpg", ".jpeg")): +374 if img._modified: +375 # it's rgb24, we need to convert to something jpeg can handle +376 f = _filter_scale(img._f, pix_fmt="yuv420p") +377 fmt["pix_fmt"] = "yuv420p" +378 else: +379 if fmt["pix_fmt"] not in ["yuvj420p", "yuvj422p", "yuvj444p"]: +380 f = _filter_scale(img._f, pix_fmt="yuvj420p") +381 fmt["pix_fmt"] = "yuvj420p" +382 +383 spec = vf.Spec(domain, lambda t, i: f, fmt) +384 spec.save(_server(), path, encoder="mjpeg") +385 else: +386 raise Exception("Unsupported image format") +387 +388 +389def vidplay(video, *args, **kwargs): +390 """ +391 Play a vidformer video specification. +392 +393 Args: +394 video: one of [vidformer.Spec, vidformer.Source, vidformer.cv2.VideoWriter] +395 """ +396 +397 if isinstance(video, vf.Spec): +398 return video.play(_server(), *args, **kwargs) +399 elif isinstance(video, vf.Source): +400 return video.play(_server(), *args, **kwargs) +401 elif isinstance(video, VideoWriter): +402 return video.spec().play(_server(), *args, **kwargs) +403 else: +404 raise Exception("Unsupported video type to vidplay") +405 +406 +407def rectangle(img, pt1, pt2, color, thickness=None, lineType=None, shift=None): +408 """ +409 cv.rectangle( img, pt1, pt2, color[, thickness[, lineType[, shift]]] ) +410 """ +411 +412 img = frameify(img) +413 img._mut() +414 +415 assert len(pt1) == 2 +416 assert len(pt2) == 2 +417 assert all(isinstance(x, int) for x in pt1) +418 assert all(isinstance(x, int) for x in pt2) +419 +420 assert len(color) == 3 or len(color) == 4 +421 color = [float(x) for x in color] +422 if len(color) == 3: +423 color.append(255.0) +424 +425 args = [] +426 if thickness is not None: +427 assert isinstance(thickness, int) +428 args.append(thickness) +429 if lineType is not None: +430 assert isinstance(lineType, int) +431 assert thickness is not None +432 args.append(lineType) +433 if shift is not None: +434 assert isinstance(shift, int) +435 assert shift is not None +436 args.append(shift) +437 +438 img._f = _filter_rectangle(img._f, pt1, pt2, color, *args) +439 +440 +441def putText( +442 img, +443 text, +444 org, +445 fontFace, +446 fontScale, +447 color, +448 thickness=None, +449 lineType=None, +450 bottomLeftOrigin=None, +451): +452 """ +453 cv.putText( img, text, org, fontFace, fontScale, color[, thickness[, lineType[, bottomLeftOrigin]]] ) +454 """ +455 +456 img = frameify(img) +457 img._mut() +458 +459 assert isinstance(text, str) +460 +461 assert len(org) == 2 +462 assert all(isinstance(x, int) for x in org) +463 +464 assert isinstance(fontFace, int) +465 assert isinstance(fontScale, float) or isinstance(fontScale, int) +466 fontScale = float(fontScale) +467 +468 assert len(color) == 3 or len(color) == 4 +469 color = [float(x) for x in color] +470 if len(color) == 3: +471 color.append(255.0) +472 +473 args = [] +474 if thickness is not None: +475 assert isinstance(thickness, int) +476 args.append(thickness) +477 if lineType is not None: +478 assert isinstance(lineType, int) +479 assert thickness is not None +480 args.append(lineType) +481 if bottomLeftOrigin is not None: +482 assert isinstance(bottomLeftOrigin, bool) +483 assert lineType is not None +484 args.append(bottomLeftOrigin) +485 +486 img._f = _filter_putText(img._f, text, org, fontFace, fontScale, color, *args) +487 +488 +489def arrowedLine( +490 img, pt1, pt2, color, thickness=None, line_type=None, shift=None, tipLength=None +491): +492 """ +493 cv.arrowedLine( img, pt1, pt2, color[, thickness[, line_type[, shift[, tipLength]]]] ) +494 """ +495 img = frameify(img) +496 img._mut() +497 +498 assert len(pt1) == 2 +499 assert len(pt2) == 2 +500 assert all(isinstance(x, int) for x in pt1) +501 assert all(isinstance(x, int) for x in pt2) +502 +503 assert len(color) == 3 or len(color) == 4 +504 color = [float(x) for x in color] +505 if len(color) == 3: +506 color.append(255.0) +507 +508 args = [] +509 if thickness is not None: +510 assert isinstance(thickness, int) +511 args.append(thickness) +512 if line_type is not None: +513 assert isinstance(line_type, int) +514 assert thickness is not None +515 args.append(line_type) +516 if shift is not None: +517 assert isinstance(shift, int) +518 assert shift is not None +519 args.append(shift) +520 if tipLength is not None: +521 assert isinstance(tipLength, float) +522 assert shift is not None +523 args.append(tipLength) +524 +525 img._f = _filter_arrowedLine(img._f, pt1, pt2, color, *args) +526 +527 +528def line(img, pt1, pt2, color, thickness=None, lineType=None, shift=None): +529 img = frameify(img) +530 img._mut() +531 +532 assert len(pt1) == 2 +533 assert len(pt2) == 2 +534 assert all(isinstance(x, int) for x in pt1) +535 assert all(isinstance(x, int) for x in pt2) +536 +537 assert len(color) == 3 or len(color) == 4 +538 color = [float(x) for x in color] +539 if len(color) == 3: +540 color.append(255.0) +541 +542 args = [] +543 if thickness is not None: +544 assert isinstance(thickness, int) +545 args.append(thickness) +546 if lineType is not None: +547 assert isinstance(lineType, int) +548 assert thickness is not None +549 args.append(lineType) +550 if shift is not None: +551 assert isinstance(shift, int) +552 assert shift is not None +553 args.append(shift) +554 +555 img._f = _filter_line(img._f, pt1, pt2, color, *args) +556 +557 +558def circle(img, center, radius, color, thickness=None, lineType=None, shift=None): +559 img = frameify(img) +560 img._mut() +561 +562 assert len(center) == 2 +563 assert all(isinstance(x, int) for x in center) +564 +565 assert isinstance(radius, int) +566 +567 assert len(color) == 3 or len(color) == 4 +568 color = [float(x) for x in color] +569 if len(color) == 3: +570 color.append(255.0) +571 +572 args = [] +573 if thickness is not None: +574 assert isinstance(thickness, int) +575 args.append(thickness) +576 if lineType is not None: +577 assert isinstance(lineType, int) +578 assert thickness is not None +579 args.append(lineType) +580 if shift is not None: +581 assert isinstance(shift, int) +582 assert shift is not None +583 args.append(shift) +584 +585 img._f = _filter_circle(img._f, center, radius, color, *args) +586 +587 +588def getFontScaleFromHeight(*args, **kwargs): +589 """ +590 cv.getFontScaleFromHeight( fontFace, pixelHeight[, thickness] ) +591 """ +592 if _opencv2 is None: +593 raise NotImplementedError("getFontScaleFromHeight requires the cv2 module") +594 return _opencv2.getFontScaleFromHeight(*args, **kwargs) +595 +596 +597def getTextSize(*args, **kwargs): +598 """ +599 cv.getTextSize( text, fontFace, fontScale, thickness ) +600 """ +601 if _opencv2 is None: +602 raise NotImplementedError("getTextSize requires the cv2 module") +603 return _opencv2.getTextSize(*args, **kwargs) +604 +605 +606def addWeighted(src1, alpha, src2, beta, gamma, dst=None, dtype=-1): +607 """ +608 cv.addWeighted( src1, alpha, src2, beta, gamma[, dst[, dtype]] ) -> dst +609 """ +610 src1 = frameify(src1, "src1") +611 src2 = frameify(src2, "src2") +612 src1._mut() +613 src2._mut() +614 +615 if dst is None: +616 dst = Frame(src1._f, src1._fmt.copy()) +617 else: +618 assert isinstance(dst, Frame), "dst must be a Frame" +619 dst._mut() +620 +621 assert isinstance(alpha, float) or isinstance(alpha, int) +622 assert isinstance(beta, float) or isinstance(beta, int) +623 assert isinstance(gamma, float) or isinstance(gamma, int) +624 alpha = float(alpha) +625 beta = float(beta) +626 gamma = float(gamma) +627 +628 if dtype != -1: +629 raise Exception("addWeighted does not support the dtype argument") +630 +631 dst._f = _filter_addWeighted(src1._f, alpha, src2._f, beta, gamma) +632 return dst +633 +634 +635# Stubs for unimplemented functions +636 +637 +638def clipLine(*args, **kwargs): +639 raise NotImplementedError("clipLine is not yet implemented in the cv2 frontend") +640 +641 +642def drawContours(*args, **kwargs): +643 raise NotImplementedError("drawContours is not yet implemented in the cv2 frontend") +644 +645 +646def drawMarker(*args, **kwargs): +647 raise NotImplementedError("drawMarker is not yet implemented in the cv2 frontend") +648 +649 +650def ellipse(*args, **kwargs): +651 raise NotImplementedError("ellipse is not yet implemented in the cv2 frontend") +652 +653 +654def ellipse2Poly(*args, **kwargs): +655 raise NotImplementedError("ellipse2Poly is not yet implemented in the cv2 frontend") +656 +657 +658def fillConvexPoly(*args, **kwargs): +659 raise NotImplementedError( +660 "fillConvexPoly is not yet implemented in the cv2 frontend" +661 ) +662 +663 +664def fillPoly(*args, **kwargs): +665 raise NotImplementedError("fillPoly is not yet implemented in the cv2 frontend") +666 +667 +668def polylines(*args, **kwargs): +669 raise NotImplementedError("polylines is not yet implemented in the cv2 frontend") +
+ CAP_PROP_POS_MSEC =
+0
+
+
+
+
+
+
+
+
+ CAP_PROP_POS_FRAMES =
+1
+
+
+
+
+
+
+
+
+ CAP_PROP_FRAME_WIDTH =
+3
+
+
+
+
+
+
+
+
+ CAP_PROP_FRAME_HEIGHT =
+4
+
+
+
+
+
+
+
+
+ CAP_PROP_FPS =
+5
+
+
+
+
+
+
+
+
+ CAP_PROP_FRAME_COUNT =
+7
+
+
+
+
+
+
+
+
+ FONT_HERSHEY_SIMPLEX =
+0
+
+
+
+
+
+
+
+
+ FONT_HERSHEY_PLAIN =
+1
+
+
+
+
+
+
+
+
+ FONT_HERSHEY_DUPLEX =
+2
+
+
+
+
+
+
+
+
+ FONT_HERSHEY_COMPLEX =
+3
+
+
+
+
+
+
+
+
+ FONT_HERSHEY_TRIPLEX =
+4
+
+
+
+
+
+
+
+
+ FONT_HERSHEY_COMPLEX_SMALL =
+5
+
+
+
+
+
+
+
+
+ FONT_HERSHEY_SCRIPT_SIMPLEX =
+6
+
+
+
+
+
+
+
+
+ FONT_HERSHEY_SCRIPT_COMPLEX =
+7
+
+
+
+
+
+
+
+
+ FONT_ITALIC =
+16
+
+
+
+
+
+
+
+
+ FILLED =
+-1
+
+
+
+
+
+
+
+
+ LINE_4 =
+4
+
+
+
+
+
+
+
+
+ LINE_8 =
+8
+
+
+
+
+
+
+
+
+ LINE_AA =
+16
+
+
+
+
+
+
+
+
+
+ def
+ set_cv2_server(server: vidformer.vf.YrdenServer):
+
+
+
+
+
+ 82def set_cv2_server(server: vf.YrdenServer): +83 """Set the server to use for the cv2 frontend.""" +84 global _global_cv2_server +85 assert isinstance(server, vf.YrdenServer) +86 _global_cv2_server = server +
Set the server to use for the cv2 frontend.
+
+
+ class
+ Frame:
+
+
+
+
+
+ 89class Frame: + 90 def __init__(self, f, fmt): + 91 self._f = f + 92 self._fmt = fmt + 93 self.shape = (fmt["height"], fmt["width"], 3) + 94 + 95 # denotes that the frame has not yet been modified + 96 # when a frame is modified, it is converted to rgb24 first + 97 self._modified = False + 98 + 99 def _mut(self): +100 if self._modified: +101 assert self._fmt["pix_fmt"] == "rgb24" +102 return +103 +104 self._modified = True +105 if self._fmt["pix_fmt"] != "rgb24": +106 self._f = _filter_scale(self._f, pix_fmt="rgb24") +107 self._fmt["pix_fmt"] = "rgb24" +108 +109 def numpy(self): +110 """ +111 Return the frame as a numpy array. +112 """ +113 +114 self._mut() +115 spec = vf.Spec([Fraction(0, 1)], lambda t, i: self._f, self._fmt) +116 loader = spec.load(_server()) +117 +118 frame_raster_rgb24 = loader[0] +119 assert type(frame_raster_rgb24) == bytes +120 assert len(frame_raster_rgb24) == self.shape[0] * self.shape[1] * 3 +121 raw_data_array = np.frombuffer(frame_raster_rgb24, dtype=np.uint8) +122 frame = raw_data_array.reshape(self.shape) +123 frame = frame[:, :, ::-1] # convert RGB to BGR +124 return frame +125 +126 def __getitem__(self, key): +127 if not isinstance(key, tuple): +128 raise NotImplementedError("Only 2D slicing is supported") +129 +130 if len(key) != 2: +131 raise NotImplementedError("Only 2D slicing is supported") +132 +133 if not all(isinstance(x, slice) for x in key): +134 raise NotImplementedError("Only 2D slicing is supported") +135 +136 miny = key[0].start if key[0].start is not None else 0 +137 maxy = key[0].stop if key[0].stop is not None else self.shape[0] +138 minx = key[1].start if key[1].start is not None else 0 +139 maxx = key[1].stop if key[1].stop is not None else self.shape[1] +140 +141 # handle negative indices +142 if miny < 0: +143 miny = self.shape[0] + miny +144 if maxy < 0: +145 maxy = self.shape[0] + maxy +146 if minx < 0: +147 minx = self.shape[1] + minx +148 if maxx < 0: +149 maxx = self.shape[1] + maxx +150 +151 if ( +152 maxy <= miny +153 or maxx <= minx +154 or miny < 0 +155 or minx < 0 +156 or maxy > self.shape[0] +157 or maxx > self.shape[1] +158 ): +159 raise NotImplementedError("Invalid slice") +160 +161 f = _slice_mat(self._f, miny, maxy, minx, maxx) +162 fmt = self._fmt.copy() +163 fmt["width"] = maxx - minx +164 fmt["height"] = maxy - miny +165 return Frame(f, fmt) +166 +167 def __setitem__(self, key, value): +168 value = frameify(value, "value") +169 +170 if not isinstance(key, tuple): +171 raise NotImplementedError("Only 2D slicing is supported") +172 +173 if len(key) != 2: +174 raise NotImplementedError("Only 2D slicing is supported") +175 +176 if not all(isinstance(x, slice) for x in key): +177 raise NotImplementedError("Only 2D slicing is supported") +178 +179 miny = key[0].start if key[0].start is not None else 0 +180 maxy = key[0].stop if key[0].stop is not None else self.shape[0] +181 minx = key[1].start if key[1].start is not None else 0 +182 maxx = key[1].stop if key[1].stop is not None else self.shape[1] +183 +184 # handle negative indices +185 if miny < 0: +186 miny = self.shape[0] + miny +187 if maxy < 0: +188 maxy = self.shape[0] + maxy +189 if minx < 0: +190 minx = self.shape[1] + minx +191 if maxx < 0: +192 maxx = self.shape[1] + maxx +193 +194 if ( +195 maxy <= miny +196 or maxx <= minx +197 or miny < 0 +198 or minx < 0 +199 or maxy > self.shape[0] +200 or maxx > self.shape[1] +201 ): +202 raise NotImplementedError("Invalid slice") +203 +204 if value.shape[0] != maxy - miny or value.shape[1] != maxx - minx: +205 raise NotImplementedError("Shape mismatch") +206 +207 self._mut() +208 value._mut() +209 +210 self._f = _slice_write_mat(self._f, value._f, miny, maxy, minx, maxx) +
+
+
+
+
+
+
+
+
+
+
+ def
+ numpy(self):
+
+
+
+
+
+ 109 def numpy(self): +110 """ +111 Return the frame as a numpy array. +112 """ +113 +114 self._mut() +115 spec = vf.Spec([Fraction(0, 1)], lambda t, i: self._f, self._fmt) +116 loader = spec.load(_server()) +117 +118 frame_raster_rgb24 = loader[0] +119 assert type(frame_raster_rgb24) == bytes +120 assert len(frame_raster_rgb24) == self.shape[0] * self.shape[1] * 3 +121 raw_data_array = np.frombuffer(frame_raster_rgb24, dtype=np.uint8) +122 frame = raw_data_array.reshape(self.shape) +123 frame = frame[:, :, ::-1] # convert RGB to BGR +124 return frame +
Return the frame as a numpy array.
+
+
+ class
+ VideoCapture:
+
+
+
+
+
+ 230class VideoCapture: +231 def __init__(self, path): +232 self._path = path +233 server = _server() +234 self._source = vf.Source(server, str(uuid.uuid4()), path, 0) +235 self._next_frame_idx = 0 +236 +237 def isOpened(self): +238 return True +239 +240 def get(self, prop): +241 if prop == CAP_PROP_FPS: +242 return _ts_to_fps(self._source.ts()) +243 elif prop == CAP_PROP_FRAME_WIDTH: +244 return self._source.fmt()["width"] +245 elif prop == CAP_PROP_FRAME_HEIGHT: +246 return self._source.fmt()["height"] +247 elif prop == CAP_PROP_FRAME_COUNT: +248 return len(self._source.ts()) +249 elif prop == CAP_PROP_POS_FRAMES: +250 return self._next_frame_idx +251 +252 raise Exception(f"Unknown property {prop}") +253 +254 def set(self, prop, value): +255 if prop == CAP_PROP_POS_FRAMES: +256 assert value >= 0 and value < len(self._source.ts()) +257 self._next_frame_idx = value +258 elif prop == CAP_PROP_POS_MSEC: +259 t = Fraction(value, 1000) +260 ts = self._source.ts() +261 next_frame_idx = bisect_right(ts, t) +262 self._next_frame_idx = next_frame_idx +263 else: +264 raise Exception(f"Unsupported property {prop}") +265 +266 def read(self): +267 if self._next_frame_idx >= len(self._source.ts()): +268 return False, None +269 frame = self._source.iloc[self._next_frame_idx] +270 self._next_frame_idx += 1 +271 frame = Frame(frame, self._source.fmt()) +272 return True, frame +273 +274 def release(self): +275 pass +
+
+
+
+
+
+
+
+
+
+ def
+ get(self, prop):
+
+
+
+
+
+ 240 def get(self, prop): +241 if prop == CAP_PROP_FPS: +242 return _ts_to_fps(self._source.ts()) +243 elif prop == CAP_PROP_FRAME_WIDTH: +244 return self._source.fmt()["width"] +245 elif prop == CAP_PROP_FRAME_HEIGHT: +246 return self._source.fmt()["height"] +247 elif prop == CAP_PROP_FRAME_COUNT: +248 return len(self._source.ts()) +249 elif prop == CAP_PROP_POS_FRAMES: +250 return self._next_frame_idx +251 +252 raise Exception(f"Unknown property {prop}") +
+
+
+
+
+
+
+
+
+
+
+
+ def
+ set(self, prop, value):
+
+
+
+
+
+ 254 def set(self, prop, value): +255 if prop == CAP_PROP_POS_FRAMES: +256 assert value >= 0 and value < len(self._source.ts()) +257 self._next_frame_idx = value +258 elif prop == CAP_PROP_POS_MSEC: +259 t = Fraction(value, 1000) +260 ts = self._source.ts() +261 next_frame_idx = bisect_right(ts, t) +262 self._next_frame_idx = next_frame_idx +263 else: +264 raise Exception(f"Unsupported property {prop}") +
+
+ class
+ VideoWriter:
+
+
+
+
+
+ 278class VideoWriter: +279 def __init__(self, path, fourcc, fps, size): +280 assert isinstance(fourcc, VideoWriter_fourcc) +281 if path is not None and not isinstance(path, str): +282 raise Exception("path must be a string or None") +283 self._path = path +284 self._fourcc = fourcc +285 self._fps = fps +286 self._size = size +287 +288 self._frames = [] +289 self._pix_fmt = "yuv420p" +290 +291 def write(self, frame): +292 frame = frameify(frame, "frame") +293 +294 if frame._fmt["pix_fmt"] != self._pix_fmt: +295 f_obj = _filter_scale(frame._f, pix_fmt=self._pix_fmt) +296 self._frames.append(f_obj) +297 else: +298 self._frames.append(frame._f) +299 +300 def release(self): +301 if self._path is None: +302 return +303 +304 spec = self.spec() +305 server = _server() +306 spec.save(server, self._path) +307 +308 def spec(self) -> vf.Spec: +309 fmt = { +310 "width": self._size[0], +311 "height": self._size[1], +312 "pix_fmt": self._pix_fmt, +313 } +314 domain = _fps_to_ts(self._fps, len(self._frames)) +315 spec = vf.Spec(domain, lambda t, i: self._frames[i], fmt) +316 return spec +
+
+
+
+
+
+
+
+
+
+
+
+
+ VideoWriter(path, fourcc, fps, size)
+
+
+
+
+
+ 279 def __init__(self, path, fourcc, fps, size): +280 assert isinstance(fourcc, VideoWriter_fourcc) +281 if path is not None and not isinstance(path, str): +282 raise Exception("path must be a string or None") +283 self._path = path +284 self._fourcc = fourcc +285 self._fps = fps +286 self._size = size +287 +288 self._frames = [] +289 self._pix_fmt = "yuv420p" +
+
+ class
+ VideoWriter_fourcc:
+
+
+
+
+
+
+
+
+
+
+
+
+
+ def
+ frameify(obj, field_name=None):
+
+
+
+
+
+ 324def frameify(obj, field_name=None): +325 """ +326 Turn an object (e.g., ndarray) into a Frame. +327 """ +328 +329 if isinstance(obj, Frame): +330 return obj +331 elif isinstance(obj, np.ndarray): +332 return _inline_frame(obj) +333 else: +334 if field_name is not None: +335 raise Exception( +336 f"Unsupported type for field {field_name}, expected Frame or np.ndarray" +337 ) +338 else: +339 raise Exception("Unsupported type, expected Frame or np.ndarray") +
Turn an object (e.g., ndarray) into a Frame.
+
+
+ def
+ imread(path, *args):
+
+
+
+
+
+ 342def imread(path, *args): +343 if len(args) > 0: +344 raise NotImplementedError("imread does not support additional arguments") +345 +346 assert path.lower().endswith((".jpg", ".jpeg", ".png")) +347 server = _server() +348 source = vf.Source(server, str(uuid.uuid4()), path, 0) +349 frame = Frame(source.iloc[0], source.fmt()) +350 return frame +
+
+ def
+ imwrite(path, img, *args):
+
+
+
+
+
+ 353def imwrite(path, img, *args): +354 if len(args) > 0: +355 raise NotImplementedError("imwrite does not support additional arguments") +356 +357 img = frameify(img) +358 +359 fmt = img._fmt.copy() +360 width = fmt["width"] +361 height = fmt["height"] +362 f = img._f +363 +364 domain = [Fraction(0, 1)] +365 +366 if path.lower().endswith(".png"): +367 img._mut() # Make sure it's in rgb24 +368 spec = vf.Spec( +369 domain, +370 lambda t, i: img._f, +371 {"width": width, "height": height, "pix_fmt": "rgb24"}, +372 ) +373 spec.save(_server(), path, encoder="png") +374 elif path.lower().endswith((".jpg", ".jpeg")): +375 if img._modified: +376 # it's rgb24, we need to convert to something jpeg can handle +377 f = _filter_scale(img._f, pix_fmt="yuv420p") +378 fmt["pix_fmt"] = "yuv420p" +379 else: +380 if fmt["pix_fmt"] not in ["yuvj420p", "yuvj422p", "yuvj444p"]: +381 f = _filter_scale(img._f, pix_fmt="yuvj420p") +382 fmt["pix_fmt"] = "yuvj420p" +383 +384 spec = vf.Spec(domain, lambda t, i: f, fmt) +385 spec.save(_server(), path, encoder="mjpeg") +386 else: +387 raise Exception("Unsupported image format") +
+
+ def
+ vidplay(video, *args, **kwargs):
+
+
+
+
+
+ 390def vidplay(video, *args, **kwargs): +391 """ +392 Play a vidformer video specification. +393 +394 Args: +395 video: one of [vidformer.Spec, vidformer.Source, vidformer.cv2.VideoWriter] +396 """ +397 +398 if isinstance(video, vf.Spec): +399 return video.play(_server(), *args, **kwargs) +400 elif isinstance(video, vf.Source): +401 return video.play(_server(), *args, **kwargs) +402 elif isinstance(video, VideoWriter): +403 return video.spec().play(_server(), *args, **kwargs) +404 else: +405 raise Exception("Unsupported video type to vidplay") +
Play a vidformer video specification.
+ +Args: + video: one of [vidformer.Spec, vidformer.Source, vidformer.cv2.VideoWriter]
+
+
+ def
+ rectangle(img, pt1, pt2, color, thickness=None, lineType=None, shift=None):
+
+
+
+
+
+ 408def rectangle(img, pt1, pt2, color, thickness=None, lineType=None, shift=None): +409 """ +410 cv.rectangle( img, pt1, pt2, color[, thickness[, lineType[, shift]]] ) +411 """ +412 +413 img = frameify(img) +414 img._mut() +415 +416 assert len(pt1) == 2 +417 assert len(pt2) == 2 +418 assert all(isinstance(x, int) for x in pt1) +419 assert all(isinstance(x, int) for x in pt2) +420 +421 assert len(color) == 3 or len(color) == 4 +422 color = [float(x) for x in color] +423 if len(color) == 3: +424 color.append(255.0) +425 +426 args = [] +427 if thickness is not None: +428 assert isinstance(thickness, int) +429 args.append(thickness) +430 if lineType is not None: +431 assert isinstance(lineType, int) +432 assert thickness is not None +433 args.append(lineType) +434 if shift is not None: +435 assert isinstance(shift, int) +436 assert shift is not None +437 args.append(shift) +438 +439 img._f = _filter_rectangle(img._f, pt1, pt2, color, *args) +
cv.rectangle( img, pt1, pt2, color[, thickness[, lineType[, shift]]] )
+
+
+ def
+ putText( img, text, org, fontFace, fontScale, color, thickness=None, lineType=None, bottomLeftOrigin=None):
+
+
+
+
+
+ 442def putText( +443 img, +444 text, +445 org, +446 fontFace, +447 fontScale, +448 color, +449 thickness=None, +450 lineType=None, +451 bottomLeftOrigin=None, +452): +453 """ +454 cv.putText( img, text, org, fontFace, fontScale, color[, thickness[, lineType[, bottomLeftOrigin]]] ) +455 """ +456 +457 img = frameify(img) +458 img._mut() +459 +460 assert isinstance(text, str) +461 +462 assert len(org) == 2 +463 assert all(isinstance(x, int) for x in org) +464 +465 assert isinstance(fontFace, int) +466 assert isinstance(fontScale, float) or isinstance(fontScale, int) +467 fontScale = float(fontScale) +468 +469 assert len(color) == 3 or len(color) == 4 +470 color = [float(x) for x in color] +471 if len(color) == 3: +472 color.append(255.0) +473 +474 args = [] +475 if thickness is not None: +476 assert isinstance(thickness, int) +477 args.append(thickness) +478 if lineType is not None: +479 assert isinstance(lineType, int) +480 assert thickness is not None +481 args.append(lineType) +482 if bottomLeftOrigin is not None: +483 assert isinstance(bottomLeftOrigin, bool) +484 assert lineType is not None +485 args.append(bottomLeftOrigin) +486 +487 img._f = _filter_putText(img._f, text, org, fontFace, fontScale, color, *args) +
cv.putText( img, text, org, fontFace, fontScale, color[, thickness[, lineType[, bottomLeftOrigin]]] )
+
+
+ def
+ arrowedLine( img, pt1, pt2, color, thickness=None, line_type=None, shift=None, tipLength=None):
+
+
+
+
+
+ 490def arrowedLine( +491 img, pt1, pt2, color, thickness=None, line_type=None, shift=None, tipLength=None +492): +493 """ +494 cv.arrowedLine( img, pt1, pt2, color[, thickness[, line_type[, shift[, tipLength]]]] ) +495 """ +496 img = frameify(img) +497 img._mut() +498 +499 assert len(pt1) == 2 +500 assert len(pt2) == 2 +501 assert all(isinstance(x, int) for x in pt1) +502 assert all(isinstance(x, int) for x in pt2) +503 +504 assert len(color) == 3 or len(color) == 4 +505 color = [float(x) for x in color] +506 if len(color) == 3: +507 color.append(255.0) +508 +509 args = [] +510 if thickness is not None: +511 assert isinstance(thickness, int) +512 args.append(thickness) +513 if line_type is not None: +514 assert isinstance(line_type, int) +515 assert thickness is not None +516 args.append(line_type) +517 if shift is not None: +518 assert isinstance(shift, int) +519 assert shift is not None +520 args.append(shift) +521 if tipLength is not None: +522 assert isinstance(tipLength, float) +523 assert shift is not None +524 args.append(tipLength) +525 +526 img._f = _filter_arrowedLine(img._f, pt1, pt2, color, *args) +
cv.arrowedLine( img, pt1, pt2, color[, thickness[, line_type[, shift[, tipLength]]]] )
+
+
+ def
+ line(img, pt1, pt2, color, thickness=None, lineType=None, shift=None):
+
+
+
+
+
+ 529def line(img, pt1, pt2, color, thickness=None, lineType=None, shift=None): +530 img = frameify(img) +531 img._mut() +532 +533 assert len(pt1) == 2 +534 assert len(pt2) == 2 +535 assert all(isinstance(x, int) for x in pt1) +536 assert all(isinstance(x, int) for x in pt2) +537 +538 assert len(color) == 3 or len(color) == 4 +539 color = [float(x) for x in color] +540 if len(color) == 3: +541 color.append(255.0) +542 +543 args = [] +544 if thickness is not None: +545 assert isinstance(thickness, int) +546 args.append(thickness) +547 if lineType is not None: +548 assert isinstance(lineType, int) +549 assert thickness is not None +550 args.append(lineType) +551 if shift is not None: +552 assert isinstance(shift, int) +553 assert shift is not None +554 args.append(shift) +555 +556 img._f = _filter_line(img._f, pt1, pt2, color, *args) +
+
+ def
+ circle( img, center, radius, color, thickness=None, lineType=None, shift=None):
+
+
+
+
+
+ 559def circle(img, center, radius, color, thickness=None, lineType=None, shift=None): +560 img = frameify(img) +561 img._mut() +562 +563 assert len(center) == 2 +564 assert all(isinstance(x, int) for x in center) +565 +566 assert isinstance(radius, int) +567 +568 assert len(color) == 3 or len(color) == 4 +569 color = [float(x) for x in color] +570 if len(color) == 3: +571 color.append(255.0) +572 +573 args = [] +574 if thickness is not None: +575 assert isinstance(thickness, int) +576 args.append(thickness) +577 if lineType is not None: +578 assert isinstance(lineType, int) +579 assert thickness is not None +580 args.append(lineType) +581 if shift is not None: +582 assert isinstance(shift, int) +583 assert shift is not None +584 args.append(shift) +585 +586 img._f = _filter_circle(img._f, center, radius, color, *args) +
+
+ def
+ getFontScaleFromHeight(*args, **kwargs):
+
+
+
+
+
+ 589def getFontScaleFromHeight(*args, **kwargs): +590 """ +591 cv.getFontScaleFromHeight( fontFace, pixelHeight[, thickness] ) +592 """ +593 if _opencv2 is None: +594 raise NotImplementedError("getFontScaleFromHeight requires the cv2 module") +595 return _opencv2.getFontScaleFromHeight(*args, **kwargs) +
cv.getFontScaleFromHeight( fontFace, pixelHeight[, thickness] )
+
+
+ def
+ getTextSize(*args, **kwargs):
+
+
+
+
+
+ 598def getTextSize(*args, **kwargs): +599 """ +600 cv.getTextSize( text, fontFace, fontScale, thickness ) +601 """ +602 if _opencv2 is None: +603 raise NotImplementedError("getTextSize requires the cv2 module") +604 return _opencv2.getTextSize(*args, **kwargs) +
cv.getTextSize( text, fontFace, fontScale, thickness )
+
+
+ def
+ addWeighted(src1, alpha, src2, beta, gamma, dst=None, dtype=-1):
+
+
+
+
+
+ 607def addWeighted(src1, alpha, src2, beta, gamma, dst=None, dtype=-1): +608 """ +609 cv.addWeighted( src1, alpha, src2, beta, gamma[, dst[, dtype]] ) -> dst +610 """ +611 src1 = frameify(src1, "src1") +612 src2 = frameify(src2, "src2") +613 src1._mut() +614 src2._mut() +615 +616 if dst is None: +617 dst = Frame(src1._f, src1._fmt.copy()) +618 else: +619 assert isinstance(dst, Frame), "dst must be a Frame" +620 dst._mut() +621 +622 assert isinstance(alpha, float) or isinstance(alpha, int) +623 assert isinstance(beta, float) or isinstance(beta, int) +624 assert isinstance(gamma, float) or isinstance(gamma, int) +625 alpha = float(alpha) +626 beta = float(beta) +627 gamma = float(gamma) +628 +629 if dtype != -1: +630 raise Exception("addWeighted does not support the dtype argument") +631 +632 dst._f = _filter_addWeighted(src1._f, alpha, src2._f, beta, gamma) +633 return dst +
cv.addWeighted( src1, alpha, src2, beta, gamma[, dst[, dtype]] ) -> dst
+
+
+ def
+ clipLine(*args, **kwargs):
+
+
+
+
+
+
+
+
+
+
+
+
+ def
+ drawContours(*args, **kwargs):
+
+
+
+
+
+
+
+
+
+
+
+
+ def
+ drawMarker(*args, **kwargs):
+
+
+
+
+
+
+
+
+
+
+
+
+ def
+ ellipse(*args, **kwargs):
+
+
+
+
+
+
+
+
+
+
+
+
+ def
+ ellipse2Poly(*args, **kwargs):
+
+
+
+
+
+
+
+
+
+
+
+
+ def
+ fillConvexPoly(*args, **kwargs):
+
+
+
+
+
+
+
+
+
+
+
+
+ def
+ fillPoly(*args, **kwargs):
+
+
+
+
+
+
+
+
+
+
+
+
+ def
+ polylines(*args, **kwargs):
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/vidformer-py/index.html b/vidformer-py/index.html
new file mode 100644
index 0000000..a8462de
--- /dev/null
+++ b/vidformer-py/index.html
@@ -0,0 +1,7 @@
+
+
+
+
+
+
+
diff --git a/vidformer-py/search.js b/vidformer-py/search.js
new file mode 100644
index 0000000..d850197
--- /dev/null
+++ b/vidformer-py/search.js
@@ -0,0 +1,46 @@
+window.pdocSearch = (function(){
+/** elasticlunr - http://weixsong.github.io * Copyright (C) 2017 Oliver Nightingale * Copyright (C) 2017 Wei Song * MIT Licensed */!function(){function e(e){if(null===e||"object"!=typeof e)return e;var t=e.constructor();for(var n in e)e.hasOwnProperty(n)&&(t[n]=e[n]);return t}var t=function(e){var n=new t.Index;return n.pipeline.add(t.trimmer,t.stopWordFilter,t.stemmer),e&&e.call(n,n),n};t.version="0.9.5",lunr=t,t.utils={},t.utils.warn=function(e){return function(t){e.console&&console.warn&&console.warn(t)}}(this),t.utils.toString=function(e){return void 0===e||null===e?"":e.toString()},t.EventEmitter=function(){this.events={}},t.EventEmitter.prototype.addListener=function(){var e=Array.prototype.slice.call(arguments),t=e.pop(),n=e;if("function"!=typeof t)throw new TypeError("last argument must be a function");n.forEach(function(e){this.hasHandler(e)||(this.events[e]=[]),this.events[e].push(t)},this)},t.EventEmitter.prototype.removeListener=function(e,t){if(this.hasHandler(e)){var n=this.events[e].indexOf(t);-1!==n&&(this.events[e].splice(n,1),0==this.events[e].length&&delete this.events[e])}},t.EventEmitter.prototype.emit=function(e){if(this.hasHandler(e)){var t=Array.prototype.slice.call(arguments,1);this.events[e].forEach(function(e){e.apply(void 0,t)},this)}},t.EventEmitter.prototype.hasHandler=function(e){return e in this.events},t.tokenizer=function(e){if(!arguments.length||null===e||void 0===e)return[];if(Array.isArray(e)){var n=e.filter(function(e){return null===e||void 0===e?!1:!0});n=n.map(function(e){return t.utils.toString(e).toLowerCase()});var i=[];return n.forEach(function(e){var n=e.split(t.tokenizer.seperator);i=i.concat(n)},this),i}return e.toString().trim().toLowerCase().split(t.tokenizer.seperator)},t.tokenizer.defaultSeperator=/[\s\-]+/,t.tokenizer.seperator=t.tokenizer.defaultSeperator,t.tokenizer.setSeperator=function(e){null!==e&&void 0!==e&&"object"==typeof e&&(t.tokenizer.seperator=e)},t.tokenizer.resetSeperator=function(){t.tokenizer.seperator=t.tokenizer.defaultSeperator},t.tokenizer.getSeperator=function(){return t.tokenizer.seperator},t.Pipeline=function(){this._queue=[]},t.Pipeline.registeredFunctions={},t.Pipeline.registerFunction=function(e,n){n in t.Pipeline.registeredFunctions&&t.utils.warn("Overwriting existing registered function: "+n),e.label=n,t.Pipeline.registeredFunctions[n]=e},t.Pipeline.getRegisteredFunction=function(e){return e in t.Pipeline.registeredFunctions!=!0?null:t.Pipeline.registeredFunctions[e]},t.Pipeline.warnIfFunctionNotRegistered=function(e){var n=e.label&&e.label in this.registeredFunctions;n||t.utils.warn("Function is not registered with pipeline. This may cause problems when serialising the index.\n",e)},t.Pipeline.load=function(e){var n=new t.Pipeline;return e.forEach(function(e){var i=t.Pipeline.getRegisteredFunction(e);if(!i)throw new Error("Cannot load un-registered function: "+e);n.add(i)}),n},t.Pipeline.prototype.add=function(){var e=Array.prototype.slice.call(arguments);e.forEach(function(e){t.Pipeline.warnIfFunctionNotRegistered(e),this._queue.push(e)},this)},t.Pipeline.prototype.after=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i+1,0,n)},t.Pipeline.prototype.before=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i,0,n)},t.Pipeline.prototype.remove=function(e){var t=this._queue.indexOf(e);-1!==t&&this._queue.splice(t,1)},t.Pipeline.prototype.run=function(e){for(var t=[],n=e.length,i=this._queue.length,o=0;n>o;o++){for(var r=e[o],s=0;i>s&&(r=this._queue[s](r,o,e),void 0!==r&&null!==r);s++);void 0!==r&&null!==r&&t.push(r)}return t},t.Pipeline.prototype.reset=function(){this._queue=[]},t.Pipeline.prototype.get=function(){return this._queue},t.Pipeline.prototype.toJSON=function(){return this._queue.map(function(e){return t.Pipeline.warnIfFunctionNotRegistered(e),e.label})},t.Index=function(){this._fields=[],this._ref="id",this.pipeline=new t.Pipeline,this.documentStore=new t.DocumentStore,this.index={},this.eventEmitter=new t.EventEmitter,this._idfCache={},this.on("add","remove","update",function(){this._idfCache={}}.bind(this))},t.Index.prototype.on=function(){var e=Array.prototype.slice.call(arguments);return this.eventEmitter.addListener.apply(this.eventEmitter,e)},t.Index.prototype.off=function(e,t){return this.eventEmitter.removeListener(e,t)},t.Index.load=function(e){e.version!==t.version&&t.utils.warn("version mismatch: current "+t.version+" importing "+e.version);var n=new this;n._fields=e.fields,n._ref=e.ref,n.documentStore=t.DocumentStore.load(e.documentStore),n.pipeline=t.Pipeline.load(e.pipeline),n.index={};for(var i in e.index)n.index[i]=t.InvertedIndex.load(e.index[i]);return n},t.Index.prototype.addField=function(e){return this._fields.push(e),this.index[e]=new t.InvertedIndex,this},t.Index.prototype.setRef=function(e){return this._ref=e,this},t.Index.prototype.saveDocument=function(e){return this.documentStore=new t.DocumentStore(e),this},t.Index.prototype.addDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.addDoc(i,e),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));this.documentStore.addFieldLength(i,n,o.length);var r={};o.forEach(function(e){e in r?r[e]+=1:r[e]=1},this);for(var s in r){var u=r[s];u=Math.sqrt(u),this.index[n].addToken(s,{ref:i,tf:u})}},this),n&&this.eventEmitter.emit("add",e,this)}},t.Index.prototype.removeDocByRef=function(e){if(e&&this.documentStore.isDocStored()!==!1&&this.documentStore.hasDoc(e)){var t=this.documentStore.getDoc(e);this.removeDoc(t,!1)}},t.Index.prototype.removeDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.hasDoc(i)&&(this.documentStore.removeDoc(i),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));o.forEach(function(e){this.index[n].removeToken(e,i)},this)},this),n&&this.eventEmitter.emit("remove",e,this))}},t.Index.prototype.updateDoc=function(e,t){var t=void 0===t?!0:t;this.removeDocByRef(e[this._ref],!1),this.addDoc(e,!1),t&&this.eventEmitter.emit("update",e,this)},t.Index.prototype.idf=function(e,t){var n="@"+t+"/"+e;if(Object.prototype.hasOwnProperty.call(this._idfCache,n))return this._idfCache[n];var i=this.index[t].getDocFreq(e),o=1+Math.log(this.documentStore.length/(i+1));return this._idfCache[n]=o,o},t.Index.prototype.getFields=function(){return this._fields.slice()},t.Index.prototype.search=function(e,n){if(!e)return[];e="string"==typeof e?{any:e}:JSON.parse(JSON.stringify(e));var i=null;null!=n&&(i=JSON.stringify(n));for(var o=new t.Configuration(i,this.getFields()).get(),r={},s=Object.keys(e),u=0;u
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ vidformer-py
+
+
vidformer-py is a Python 🐍 interface for vidformer. +Our getting started guide explains how to use it.
+Quick links:
+ +Publish:
+ export FLIT_USERNAME='__token__' FLIT_PASSWORD='<token>'
+flit publish
+Quick links:
\n\n- \n
- \ud83d\udce6 PyPI \n
- \ud83d\udcd8 Documentation - vidformer-py \n
- \ud83d\udcd8 Documentation - vidformer.cv2 \n
- \ud83e\uddd1\u200d\ud83d\udcbb Source Code \n
A video transformation specification.
\n\nSee https://ixlab.github.io/vidformer/concepts.html for more information.
\n"}, "vidformer.vf.Spec.__init__": {"fullname": "vidformer.vf.Spec.__init__", "modulename": "vidformer.vf", "qualname": "Spec.__init__", "kind": "function", "doc": "\n", "signature": "(domain: list[fractions.Fraction], render, fmt: dict)"}, "vidformer.vf.Spec.play": {"fullname": "vidformer.vf.Spec.play", "modulename": "vidformer.vf", "qualname": "Spec.play", "kind": "function", "doc": "Play the video live in the notebook.
\n", "signature": "(self, server, method='html', verbose=False):", "funcdef": "def"}, "vidformer.vf.Spec.load": {"fullname": "vidformer.vf.Spec.load", "modulename": "vidformer.vf", "qualname": "Spec.load", "kind": "function", "doc": "\n", "signature": "(self, server):", "funcdef": "def"}, "vidformer.vf.Spec.save": {"fullname": "vidformer.vf.Spec.save", "modulename": "vidformer.vf", "qualname": "Spec.save", "kind": "function", "doc": "Save the video to a file.
\n", "signature": "(self, server, pth, encoder=None, encoder_opts=None, format=None):", "funcdef": "def"}, "vidformer.vf.Loader": {"fullname": "vidformer.vf.Loader", "modulename": "vidformer.vf", "qualname": "Loader", "kind": "class", "doc": "\n"}, "vidformer.vf.Loader.__init__": {"fullname": "vidformer.vf.Loader.__init__", "modulename": "vidformer.vf", "qualname": "Loader.__init__", "kind": "function", "doc": "\n", "signature": "(server, namespace: str, domain)"}, "vidformer.vf.YrdenServer": {"fullname": "vidformer.vf.YrdenServer", "modulename": "vidformer.vf", "qualname": "YrdenServer", "kind": "class", "doc": "A connection to a Yrden server.
\n\nA yrden server is the main API for local use of vidformer.
\n"}, "vidformer.vf.YrdenServer.__init__": {"fullname": "vidformer.vf.YrdenServer.__init__", "modulename": "vidformer.vf", "qualname": "YrdenServer.__init__", "kind": "function", "doc": "Connect to a Yrden server
\n\nCan either connect to an existing server, if domain and port are provided, or start a new server using the provided binary.\nIf no domain or binary is provided, the VIDFORMER_BIN environment variable is used.
Return the link to the yrden-hosted hls.js file
\n", "signature": "(self):", "funcdef": "def"}, "vidformer.vf.SourceExpr": {"fullname": "vidformer.vf.SourceExpr", "modulename": "vidformer.vf", "qualname": "SourceExpr", "kind": "class", "doc": "\n"}, "vidformer.vf.SourceExpr.__init__": {"fullname": "vidformer.vf.SourceExpr.__init__", "modulename": "vidformer.vf", "qualname": "SourceExpr.__init__", "kind": "function", "doc": "\n", "signature": "(source, idx, is_iloc)"}, "vidformer.vf.SourceILoc": {"fullname": "vidformer.vf.SourceILoc", "modulename": "vidformer.vf", "qualname": "SourceILoc", "kind": "class", "doc": "\n"}, "vidformer.vf.SourceILoc.__init__": {"fullname": "vidformer.vf.SourceILoc.__init__", "modulename": "vidformer.vf", "qualname": "SourceILoc.__init__", "kind": "function", "doc": "\n", "signature": "(source)"}, "vidformer.vf.Source": {"fullname": "vidformer.vf.Source", "modulename": "vidformer.vf", "qualname": "Source", "kind": "class", "doc": "A video source.
\n"}, "vidformer.vf.Source.__init__": {"fullname": "vidformer.vf.Source.__init__", "modulename": "vidformer.vf", "qualname": "Source.__init__", "kind": "function", "doc": "\n", "signature": "(\tserver: vidformer.vf.YrdenServer,\tname: str,\tpath: str,\tstream: int,\tservice=None)"}, "vidformer.vf.Source.iloc": {"fullname": "vidformer.vf.Source.iloc", "modulename": "vidformer.vf", "qualname": "Source.iloc", "kind": "variable", "doc": "\n"}, "vidformer.vf.Source.fmt": {"fullname": "vidformer.vf.Source.fmt", "modulename": "vidformer.vf", "qualname": "Source.fmt", "kind": "function", "doc": "\n", "signature": "(self):", "funcdef": "def"}, "vidformer.vf.Source.ts": {"fullname": "vidformer.vf.Source.ts", "modulename": "vidformer.vf", "qualname": "Source.ts", "kind": "function", "doc": "\n", "signature": "(self):", "funcdef": "def"}, "vidformer.vf.Source.play": {"fullname": "vidformer.vf.Source.play", "modulename": "vidformer.vf", "qualname": "Source.play", "kind": "function", "doc": "Play the video live in the notebook.
\n", "signature": "(self, *args, **kwargs):", "funcdef": "def"}, "vidformer.vf.StorageService": {"fullname": "vidformer.vf.StorageService", "modulename": "vidformer.vf", "qualname": "StorageService", "kind": "class", "doc": "\n"}, "vidformer.vf.StorageService.__init__": {"fullname": "vidformer.vf.StorageService.__init__", "modulename": "vidformer.vf", "qualname": "StorageService.__init__", "kind": "function", "doc": "\n", "signature": "(service: str, **kwargs)"}, "vidformer.vf.StorageService.as_json": {"fullname": "vidformer.vf.StorageService.as_json", "modulename": "vidformer.vf", "qualname": "StorageService.as_json", "kind": "function", "doc": "\n", "signature": "(self):", "funcdef": "def"}, "vidformer.vf.Filter": {"fullname": "vidformer.vf.Filter", "modulename": "vidformer.vf", "qualname": "Filter", "kind": "class", "doc": "A video filter.
\n"}, "vidformer.vf.Filter.__init__": {"fullname": "vidformer.vf.Filter.__init__", "modulename": "vidformer.vf", "qualname": "Filter.__init__", "kind": "function", "doc": "\n", "signature": "(name: str, tl_func=None, **kwargs)"}, "vidformer.vf.FilterExpr": {"fullname": "vidformer.vf.FilterExpr", "modulename": "vidformer.vf", "qualname": "FilterExpr", "kind": "class", "doc": "\n"}, "vidformer.vf.FilterExpr.__init__": {"fullname": "vidformer.vf.FilterExpr.__init__", "modulename": "vidformer.vf", "qualname": "FilterExpr.__init__", "kind": "function", "doc": "\n", "signature": "(filter: vidformer.vf.Filter, args, kwargs)"}, "vidformer.vf.UDF": {"fullname": "vidformer.vf.UDF", "modulename": "vidformer.vf", "qualname": "UDF", "kind": "class", "doc": "User-defined filter superclass
\n"}, "vidformer.vf.UDF.__init__": {"fullname": "vidformer.vf.UDF.__init__", "modulename": "vidformer.vf", "qualname": "UDF.__init__", "kind": "function", "doc": "\n", "signature": "(name: str)"}, "vidformer.vf.UDF.filter": {"fullname": "vidformer.vf.UDF.filter", "modulename": "vidformer.vf", "qualname": "UDF.filter", "kind": "function", "doc": "\n", "signature": "(self, *args, **kwargs):", "funcdef": "def"}, "vidformer.vf.UDF.filter_type": {"fullname": "vidformer.vf.UDF.filter_type", "modulename": "vidformer.vf", "qualname": "UDF.filter_type", "kind": "function", "doc": "\n", "signature": "(self, *args, **kwargs):", "funcdef": "def"}, "vidformer.vf.UDF.into_filter": {"fullname": "vidformer.vf.UDF.into_filter", "modulename": "vidformer.vf", "qualname": "UDF.into_filter", "kind": "function", "doc": "\n", "signature": "(self):", "funcdef": "def"}, "vidformer.vf.UDFFrameType": {"fullname": "vidformer.vf.UDFFrameType", "modulename": "vidformer.vf", "qualname": "UDFFrameType", "kind": "class", "doc": "Frame type for use in UDFs.
\n"}, "vidformer.vf.UDFFrameType.__init__": {"fullname": "vidformer.vf.UDFFrameType.__init__", "modulename": "vidformer.vf", "qualname": "UDFFrameType.__init__", "kind": "function", "doc": "\n", "signature": "(width: int, height: int, pix_fmt: str)"}, "vidformer.vf.UDFFrameType.width": {"fullname": "vidformer.vf.UDFFrameType.width", "modulename": "vidformer.vf", "qualname": "UDFFrameType.width", "kind": "function", "doc": "\n", "signature": "(self):", "funcdef": "def"}, "vidformer.vf.UDFFrameType.height": {"fullname": "vidformer.vf.UDFFrameType.height", "modulename": "vidformer.vf", "qualname": "UDFFrameType.height", "kind": "function", "doc": "\n", "signature": "(self):", "funcdef": "def"}, "vidformer.vf.UDFFrameType.pix_fmt": {"fullname": "vidformer.vf.UDFFrameType.pix_fmt", "modulename": "vidformer.vf", "qualname": "UDFFrameType.pix_fmt", "kind": "function", "doc": "\n", "signature": "(self):", "funcdef": "def"}, "vidformer.vf.UDFFrame": {"fullname": "vidformer.vf.UDFFrame", "modulename": "vidformer.vf", "qualname": "UDFFrame", "kind": "class", "doc": "A symbolic reference to a frame for use in UDFs.
\n"}, "vidformer.vf.UDFFrame.__init__": {"fullname": "vidformer.vf.UDFFrame.__init__", "modulename": "vidformer.vf", "qualname": "UDFFrame.__init__", "kind": "function", "doc": "\n", "signature": "(data: numpy.ndarray, f_type: vidformer.vf.UDFFrameType)"}, "vidformer.vf.UDFFrame.data": {"fullname": "vidformer.vf.UDFFrame.data", "modulename": "vidformer.vf", "qualname": "UDFFrame.data", "kind": "function", "doc": "\n", "signature": "(self):", "funcdef": "def"}, "vidformer.vf.UDFFrame.frame_type": {"fullname": "vidformer.vf.UDFFrame.frame_type", "modulename": "vidformer.vf", "qualname": "UDFFrame.frame_type", "kind": "function", "doc": "\n", "signature": "(self):", "funcdef": "def"}}, "docInfo": {"vidformer.vf": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 53}, "vidformer.vf.Spec": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 20}, "vidformer.vf.Spec.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 40, "bases": 0, "doc": 3}, "vidformer.vf.Spec.play": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 40, "bases": 0, "doc": 10}, "vidformer.vf.Spec.load": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 3}, "vidformer.vf.Spec.save": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 52, "bases": 0, "doc": 9}, "vidformer.vf.Loader": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "vidformer.vf.Loader.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 24, "bases": 0, "doc": 3}, "vidformer.vf.YrdenServer": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 24}, "vidformer.vf.YrdenServer.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 45, "bases": 0, "doc": 48}, "vidformer.vf.YrdenServer.hls_js_url": {"qualname": 4, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 12}, "vidformer.vf.SourceExpr": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "vidformer.vf.SourceExpr.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 20, "bases": 0, "doc": 3}, "vidformer.vf.SourceILoc": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "vidformer.vf.SourceILoc.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 9, "bases": 0, "doc": 3}, "vidformer.vf.Source": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 6}, "vidformer.vf.Source.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 69, "bases": 0, "doc": 3}, "vidformer.vf.Source.iloc": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "vidformer.vf.Source.fmt": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "vidformer.vf.Source.ts": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "vidformer.vf.Source.play": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 25, "bases": 0, "doc": 10}, "vidformer.vf.StorageService": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "vidformer.vf.StorageService.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 21, "bases": 0, "doc": 3}, "vidformer.vf.StorageService.as_json": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "vidformer.vf.Filter": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 6}, "vidformer.vf.Filter.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 32, "bases": 0, "doc": 3}, "vidformer.vf.FilterExpr": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "vidformer.vf.FilterExpr.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 34, "bases": 0, "doc": 3}, "vidformer.vf.UDF": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 6}, "vidformer.vf.UDF.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 3}, "vidformer.vf.UDF.filter": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 25, "bases": 0, "doc": 3}, "vidformer.vf.UDF.filter_type": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 25, "bases": 0, "doc": 3}, "vidformer.vf.UDF.into_filter": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "vidformer.vf.UDFFrameType": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 9}, "vidformer.vf.UDFFrameType.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 35, "bases": 0, "doc": 3}, "vidformer.vf.UDFFrameType.width": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "vidformer.vf.UDFFrameType.height": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "vidformer.vf.UDFFrameType.pix_fmt": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "vidformer.vf.UDFFrame": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 13}, "vidformer.vf.UDFFrame.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 40, "bases": 0, "doc": 3}, "vidformer.vf.UDFFrame.data": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "vidformer.vf.UDFFrame.frame_type": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}}, "length": 42, "save": true}, "index": {"qualname": {"root": {"docs": {"vidformer.vf.Spec.__init__": {"tf": 1}, "vidformer.vf.Loader.__init__": {"tf": 1}, "vidformer.vf.YrdenServer.__init__": {"tf": 1}, "vidformer.vf.SourceExpr.__init__": {"tf": 1}, "vidformer.vf.SourceILoc.__init__": {"tf": 1}, "vidformer.vf.Source.__init__": {"tf": 1}, "vidformer.vf.StorageService.__init__": {"tf": 1}, "vidformer.vf.Filter.__init__": {"tf": 1}, "vidformer.vf.FilterExpr.__init__": {"tf": 1}, "vidformer.vf.UDF.__init__": {"tf": 1}, "vidformer.vf.UDFFrameType.__init__": {"tf": 1}, "vidformer.vf.UDFFrame.__init__": {"tf": 1}}, "df": 12, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {"vidformer.vf.Spec": {"tf": 1}, "vidformer.vf.Spec.__init__": {"tf": 1}, "vidformer.vf.Spec.play": {"tf": 1}, "vidformer.vf.Spec.load": {"tf": 1}, "vidformer.vf.Spec.save": {"tf": 1}}, "df": 5}}}, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.Spec.save": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.Source": {"tf": 1}, "vidformer.vf.Source.__init__": {"tf": 1}, "vidformer.vf.Source.iloc": {"tf": 1}, "vidformer.vf.Source.fmt": {"tf": 1}, "vidformer.vf.Source.ts": {"tf": 1}, "vidformer.vf.Source.play": {"tf": 1}}, "df": 6, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.vf.SourceExpr": {"tf": 1}, "vidformer.vf.SourceExpr.__init__": {"tf": 1}}, "df": 2}}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {"vidformer.vf.SourceILoc": {"tf": 1}, "vidformer.vf.SourceILoc.__init__": {"tf": 1}}, "df": 2}}}}}}}}}, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.StorageService": {"tf": 1}, "vidformer.vf.StorageService.__init__": {"tf": 1}, "vidformer.vf.StorageService.as_json": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.vf.Spec.__init__": {"tf": 1}, "vidformer.vf.Loader.__init__": {"tf": 1}, "vidformer.vf.YrdenServer.__init__": {"tf": 1}, "vidformer.vf.SourceExpr.__init__": {"tf": 1}, "vidformer.vf.SourceILoc.__init__": {"tf": 1}, "vidformer.vf.Source.__init__": {"tf": 1}, "vidformer.vf.StorageService.__init__": {"tf": 1}, "vidformer.vf.Filter.__init__": {"tf": 1}, "vidformer.vf.FilterExpr.__init__": {"tf": 1}, "vidformer.vf.UDF.__init__": {"tf": 1}, "vidformer.vf.UDFFrameType.__init__": {"tf": 1}, "vidformer.vf.UDFFrame.__init__": {"tf": 1}}, "df": 12}}, "t": {"docs": {}, "df": 0, "o": {"docs": {"vidformer.vf.UDF.into_filter": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {"vidformer.vf.Source.iloc": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"vidformer.vf.Spec.play": {"tf": 1}, "vidformer.vf.Source.play": {"tf": 1}}, "df": 2}}}, "i": {"docs": {}, "df": 0, "x": {"docs": {"vidformer.vf.UDFFrameType.pix_fmt": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"vidformer.vf.Spec.load": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.vf.Loader": {"tf": 1}, "vidformer.vf.Loader.__init__": {"tf": 1}}, "df": 2}}}}}}, "y": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.vf.YrdenServer": {"tf": 1}, "vidformer.vf.YrdenServer.__init__": {"tf": 1}, "vidformer.vf.YrdenServer.hls_js_url": {"tf": 1}}, "df": 3}}}}}}}}}}}, "h": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.vf.YrdenServer.hls_js_url": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.vf.UDFFrameType.height": {"tf": 1}}, "df": 1}}}}}}, "j": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.vf.YrdenServer.hls_js_url": {"tf": 1}}, "df": 1, "o": {"docs": {}, "df": 0, "n": {"docs": {"vidformer.vf.StorageService.as_json": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "l": {"docs": {"vidformer.vf.YrdenServer.hls_js_url": {"tf": 1}}, "df": 1}}, "d": {"docs": {}, "df": 0, "f": {"docs": {"vidformer.vf.UDF": {"tf": 1}, "vidformer.vf.UDF.__init__": {"tf": 1}, "vidformer.vf.UDF.filter": {"tf": 1}, "vidformer.vf.UDF.filter_type": {"tf": 1}, "vidformer.vf.UDF.into_filter": {"tf": 1}}, "df": 5, "f": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.UDFFrame": {"tf": 1}, "vidformer.vf.UDFFrame.__init__": {"tf": 1}, "vidformer.vf.UDFFrame.data": {"tf": 1}, "vidformer.vf.UDFFrame.frame_type": {"tf": 1}}, "df": 4, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.UDFFrameType": {"tf": 1}, "vidformer.vf.UDFFrameType.__init__": {"tf": 1}, "vidformer.vf.UDFFrameType.width": {"tf": 1}, "vidformer.vf.UDFFrameType.height": {"tf": 1}, "vidformer.vf.UDFFrameType.pix_fmt": {"tf": 1}}, "df": 5}}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.vf.Source.fmt": {"tf": 1}, "vidformer.vf.UDFFrameType.pix_fmt": {"tf": 1}}, "df": 2}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.vf.Filter": {"tf": 1}, "vidformer.vf.Filter.__init__": {"tf": 1}, "vidformer.vf.UDF.filter": {"tf": 1}, "vidformer.vf.UDF.filter_type": {"tf": 1}, "vidformer.vf.UDF.into_filter": {"tf": 1}}, "df": 5, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.vf.FilterExpr": {"tf": 1}, "vidformer.vf.FilterExpr.__init__": {"tf": 1}}, "df": 2}}}}}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.UDFFrame.frame_type": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.vf.Source.ts": {"tf": 1}}, "df": 1}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.UDF.filter_type": {"tf": 1}, "vidformer.vf.UDFFrame.frame_type": {"tf": 1}}, "df": 2}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.vf.StorageService.as_json": {"tf": 1}}, "df": 1}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"vidformer.vf.UDFFrameType.width": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"vidformer.vf.UDFFrame.data": {"tf": 1}}, "df": 1}}}}}}, "fullname": {"root": {"docs": {"vidformer.vf.Spec.__init__": {"tf": 1}, "vidformer.vf.Loader.__init__": {"tf": 1}, "vidformer.vf.YrdenServer.__init__": {"tf": 1}, "vidformer.vf.SourceExpr.__init__": {"tf": 1}, "vidformer.vf.SourceILoc.__init__": {"tf": 1}, "vidformer.vf.Source.__init__": {"tf": 1}, "vidformer.vf.StorageService.__init__": {"tf": 1}, "vidformer.vf.Filter.__init__": {"tf": 1}, "vidformer.vf.FilterExpr.__init__": {"tf": 1}, "vidformer.vf.UDF.__init__": {"tf": 1}, "vidformer.vf.UDFFrameType.__init__": {"tf": 1}, "vidformer.vf.UDFFrame.__init__": {"tf": 1}}, "df": 12, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.vf": {"tf": 1}, "vidformer.vf.Spec": {"tf": 1}, "vidformer.vf.Spec.__init__": {"tf": 1}, "vidformer.vf.Spec.play": {"tf": 1}, "vidformer.vf.Spec.load": {"tf": 1}, "vidformer.vf.Spec.save": {"tf": 1}, "vidformer.vf.Loader": {"tf": 1}, "vidformer.vf.Loader.__init__": {"tf": 1}, "vidformer.vf.YrdenServer": {"tf": 1}, "vidformer.vf.YrdenServer.__init__": {"tf": 1}, "vidformer.vf.YrdenServer.hls_js_url": {"tf": 1}, "vidformer.vf.SourceExpr": {"tf": 1}, "vidformer.vf.SourceExpr.__init__": {"tf": 1}, "vidformer.vf.SourceILoc": {"tf": 1}, "vidformer.vf.SourceILoc.__init__": {"tf": 1}, "vidformer.vf.Source": {"tf": 1}, "vidformer.vf.Source.__init__": {"tf": 1}, "vidformer.vf.Source.iloc": {"tf": 1}, "vidformer.vf.Source.fmt": {"tf": 1}, "vidformer.vf.Source.ts": {"tf": 1}, "vidformer.vf.Source.play": {"tf": 1}, "vidformer.vf.StorageService": {"tf": 1}, "vidformer.vf.StorageService.__init__": {"tf": 1}, "vidformer.vf.StorageService.as_json": {"tf": 1}, "vidformer.vf.Filter": {"tf": 1}, "vidformer.vf.Filter.__init__": {"tf": 1}, "vidformer.vf.FilterExpr": {"tf": 1}, "vidformer.vf.FilterExpr.__init__": {"tf": 1}, "vidformer.vf.UDF": {"tf": 1}, "vidformer.vf.UDF.__init__": {"tf": 1}, "vidformer.vf.UDF.filter": {"tf": 1}, "vidformer.vf.UDF.filter_type": {"tf": 1}, "vidformer.vf.UDF.into_filter": {"tf": 1}, "vidformer.vf.UDFFrameType": {"tf": 1}, "vidformer.vf.UDFFrameType.__init__": {"tf": 1}, "vidformer.vf.UDFFrameType.width": {"tf": 1}, "vidformer.vf.UDFFrameType.height": {"tf": 1}, "vidformer.vf.UDFFrameType.pix_fmt": {"tf": 1}, "vidformer.vf.UDFFrame": {"tf": 1}, "vidformer.vf.UDFFrame.__init__": {"tf": 1}, "vidformer.vf.UDFFrame.data": {"tf": 1}, "vidformer.vf.UDFFrame.frame_type": {"tf": 1}}, "df": 42}}}}}}}}, "f": {"docs": {"vidformer.vf": {"tf": 1}, "vidformer.vf.Spec": {"tf": 1}, "vidformer.vf.Spec.__init__": {"tf": 1}, "vidformer.vf.Spec.play": {"tf": 1}, "vidformer.vf.Spec.load": {"tf": 1}, "vidformer.vf.Spec.save": {"tf": 1}, "vidformer.vf.Loader": {"tf": 1}, "vidformer.vf.Loader.__init__": {"tf": 1}, "vidformer.vf.YrdenServer": {"tf": 1}, "vidformer.vf.YrdenServer.__init__": {"tf": 1}, "vidformer.vf.YrdenServer.hls_js_url": {"tf": 1}, "vidformer.vf.SourceExpr": {"tf": 1}, "vidformer.vf.SourceExpr.__init__": {"tf": 1}, "vidformer.vf.SourceILoc": {"tf": 1}, "vidformer.vf.SourceILoc.__init__": {"tf": 1}, "vidformer.vf.Source": {"tf": 1}, "vidformer.vf.Source.__init__": {"tf": 1}, "vidformer.vf.Source.iloc": {"tf": 1}, "vidformer.vf.Source.fmt": {"tf": 1}, "vidformer.vf.Source.ts": {"tf": 1}, "vidformer.vf.Source.play": {"tf": 1}, "vidformer.vf.StorageService": {"tf": 1}, "vidformer.vf.StorageService.__init__": {"tf": 1}, "vidformer.vf.StorageService.as_json": {"tf": 1}, "vidformer.vf.Filter": {"tf": 1}, "vidformer.vf.Filter.__init__": {"tf": 1}, "vidformer.vf.FilterExpr": {"tf": 1}, "vidformer.vf.FilterExpr.__init__": {"tf": 1}, "vidformer.vf.UDF": {"tf": 1}, "vidformer.vf.UDF.__init__": {"tf": 1}, "vidformer.vf.UDF.filter": {"tf": 1}, "vidformer.vf.UDF.filter_type": {"tf": 1}, "vidformer.vf.UDF.into_filter": {"tf": 1}, "vidformer.vf.UDFFrameType": {"tf": 1}, "vidformer.vf.UDFFrameType.__init__": {"tf": 1}, "vidformer.vf.UDFFrameType.width": {"tf": 1}, "vidformer.vf.UDFFrameType.height": {"tf": 1}, "vidformer.vf.UDFFrameType.pix_fmt": {"tf": 1}, "vidformer.vf.UDFFrame": {"tf": 1}, "vidformer.vf.UDFFrame.__init__": {"tf": 1}, "vidformer.vf.UDFFrame.data": {"tf": 1}, "vidformer.vf.UDFFrame.frame_type": {"tf": 1}}, "df": 42}}, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {"vidformer.vf.Spec": {"tf": 1}, "vidformer.vf.Spec.__init__": {"tf": 1}, "vidformer.vf.Spec.play": {"tf": 1}, "vidformer.vf.Spec.load": {"tf": 1}, "vidformer.vf.Spec.save": {"tf": 1}}, "df": 5}}}, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.Spec.save": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.Source": {"tf": 1}, "vidformer.vf.Source.__init__": {"tf": 1}, "vidformer.vf.Source.iloc": {"tf": 1}, "vidformer.vf.Source.fmt": {"tf": 1}, "vidformer.vf.Source.ts": {"tf": 1}, "vidformer.vf.Source.play": {"tf": 1}}, "df": 6, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.vf.SourceExpr": {"tf": 1}, "vidformer.vf.SourceExpr.__init__": {"tf": 1}}, "df": 2}}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {"vidformer.vf.SourceILoc": {"tf": 1}, "vidformer.vf.SourceILoc.__init__": {"tf": 1}}, "df": 2}}}}}}}}}, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.StorageService": {"tf": 1}, "vidformer.vf.StorageService.__init__": {"tf": 1}, "vidformer.vf.StorageService.as_json": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.vf.Spec.__init__": {"tf": 1}, "vidformer.vf.Loader.__init__": {"tf": 1}, "vidformer.vf.YrdenServer.__init__": {"tf": 1}, "vidformer.vf.SourceExpr.__init__": {"tf": 1}, "vidformer.vf.SourceILoc.__init__": {"tf": 1}, "vidformer.vf.Source.__init__": {"tf": 1}, "vidformer.vf.StorageService.__init__": {"tf": 1}, "vidformer.vf.Filter.__init__": {"tf": 1}, "vidformer.vf.FilterExpr.__init__": {"tf": 1}, "vidformer.vf.UDF.__init__": {"tf": 1}, "vidformer.vf.UDFFrameType.__init__": {"tf": 1}, "vidformer.vf.UDFFrame.__init__": {"tf": 1}}, "df": 12}}, "t": {"docs": {}, "df": 0, "o": {"docs": {"vidformer.vf.UDF.into_filter": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {"vidformer.vf.Source.iloc": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"vidformer.vf.Spec.play": {"tf": 1}, "vidformer.vf.Source.play": {"tf": 1}}, "df": 2}}}, "i": {"docs": {}, "df": 0, "x": {"docs": {"vidformer.vf.UDFFrameType.pix_fmt": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"vidformer.vf.Spec.load": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.vf.Loader": {"tf": 1}, "vidformer.vf.Loader.__init__": {"tf": 1}}, "df": 2}}}}}}, "y": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.vf.YrdenServer": {"tf": 1}, "vidformer.vf.YrdenServer.__init__": {"tf": 1}, "vidformer.vf.YrdenServer.hls_js_url": {"tf": 1}}, "df": 3}}}}}}}}}}}, "h": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.vf.YrdenServer.hls_js_url": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.vf.UDFFrameType.height": {"tf": 1}}, "df": 1}}}}}}, "j": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.vf.YrdenServer.hls_js_url": {"tf": 1}}, "df": 1, "o": {"docs": {}, "df": 0, "n": {"docs": {"vidformer.vf.StorageService.as_json": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "l": {"docs": {"vidformer.vf.YrdenServer.hls_js_url": {"tf": 1}}, "df": 1}}, "d": {"docs": {}, "df": 0, "f": {"docs": {"vidformer.vf.UDF": {"tf": 1}, "vidformer.vf.UDF.__init__": {"tf": 1}, "vidformer.vf.UDF.filter": {"tf": 1}, "vidformer.vf.UDF.filter_type": {"tf": 1}, "vidformer.vf.UDF.into_filter": {"tf": 1}}, "df": 5, "f": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.UDFFrame": {"tf": 1}, "vidformer.vf.UDFFrame.__init__": {"tf": 1}, "vidformer.vf.UDFFrame.data": {"tf": 1}, "vidformer.vf.UDFFrame.frame_type": {"tf": 1}}, "df": 4, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.UDFFrameType": {"tf": 1}, "vidformer.vf.UDFFrameType.__init__": {"tf": 1}, "vidformer.vf.UDFFrameType.width": {"tf": 1}, "vidformer.vf.UDFFrameType.height": {"tf": 1}, "vidformer.vf.UDFFrameType.pix_fmt": {"tf": 1}}, "df": 5}}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.vf.Source.fmt": {"tf": 1}, "vidformer.vf.UDFFrameType.pix_fmt": {"tf": 1}}, "df": 2}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.vf.Filter": {"tf": 1}, "vidformer.vf.Filter.__init__": {"tf": 1}, "vidformer.vf.UDF.filter": {"tf": 1}, "vidformer.vf.UDF.filter_type": {"tf": 1}, "vidformer.vf.UDF.into_filter": {"tf": 1}}, "df": 5, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.vf.FilterExpr": {"tf": 1}, "vidformer.vf.FilterExpr.__init__": {"tf": 1}}, "df": 2}}}}}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.UDFFrame.frame_type": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.vf.Source.ts": {"tf": 1}}, "df": 1}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.UDF.filter_type": {"tf": 1}, "vidformer.vf.UDFFrame.frame_type": {"tf": 1}}, "df": 2}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.vf.StorageService.as_json": {"tf": 1}}, "df": 1}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"vidformer.vf.UDFFrameType.width": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"vidformer.vf.UDFFrame.data": {"tf": 1}}, "df": 1}}}}}}, "annotation": {"root": {"docs": {}, "df": 0}}, "default_value": {"root": {"docs": {}, "df": 0}}, "signature": {"root": {"3": {"9": {"docs": {"vidformer.vf.Spec.play": {"tf": 1.4142135623730951}}, "df": 1}, "docs": {}, "df": 0}, "docs": {"vidformer.vf.Spec.__init__": {"tf": 5.744562646538029}, "vidformer.vf.Spec.play": {"tf": 5.656854249492381}, "vidformer.vf.Spec.load": {"tf": 3.7416573867739413}, "vidformer.vf.Spec.save": {"tf": 6.48074069840786}, "vidformer.vf.Loader.__init__": {"tf": 4.47213595499958}, "vidformer.vf.YrdenServer.__init__": {"tf": 6}, "vidformer.vf.YrdenServer.hls_js_url": {"tf": 3.1622776601683795}, "vidformer.vf.SourceExpr.__init__": {"tf": 4}, "vidformer.vf.SourceILoc.__init__": {"tf": 2.8284271247461903}, "vidformer.vf.Source.__init__": {"tf": 7.54983443527075}, "vidformer.vf.Source.fmt": {"tf": 3.1622776601683795}, "vidformer.vf.Source.ts": {"tf": 3.1622776601683795}, "vidformer.vf.Source.play": {"tf": 4.69041575982343}, "vidformer.vf.StorageService.__init__": {"tf": 4.242640687119285}, "vidformer.vf.StorageService.as_json": {"tf": 3.1622776601683795}, "vidformer.vf.Filter.__init__": {"tf": 5.0990195135927845}, "vidformer.vf.FilterExpr.__init__": {"tf": 5.291502622129181}, "vidformer.vf.UDF.__init__": {"tf": 3.4641016151377544}, "vidformer.vf.UDF.filter": {"tf": 4.69041575982343}, "vidformer.vf.UDF.filter_type": {"tf": 4.69041575982343}, "vidformer.vf.UDF.into_filter": {"tf": 3.1622776601683795}, "vidformer.vf.UDFFrameType.__init__": {"tf": 5.291502622129181}, "vidformer.vf.UDFFrameType.width": {"tf": 3.1622776601683795}, "vidformer.vf.UDFFrameType.height": {"tf": 3.1622776601683795}, "vidformer.vf.UDFFrameType.pix_fmt": {"tf": 3.1622776601683795}, "vidformer.vf.UDFFrame.__init__": {"tf": 5.656854249492381}, "vidformer.vf.UDFFrame.data": {"tf": 3.1622776601683795}, "vidformer.vf.UDFFrame.frame_type": {"tf": 3.1622776601683795}}, "df": 28, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"vidformer.vf.Spec.__init__": {"tf": 1}, "vidformer.vf.Loader.__init__": {"tf": 1}, "vidformer.vf.YrdenServer.__init__": {"tf": 1}}, "df": 3}}}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.vf.Spec.__init__": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"vidformer.vf.UDFFrame.__init__": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.vf.Spec.__init__": {"tf": 1}}, "df": 1}}}}, "f": {"docs": {"vidformer.vf.UDFFrame.__init__": {"tf": 1}}, "df": 1, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"vidformer.vf.Spec.__init__": {"tf": 1}}, "df": 1, "s": {"docs": {"vidformer.vf.Spec.__init__": {"tf": 1}}, "df": 1}}}}}}}}, "m": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.vf.Spec.__init__": {"tf": 1}, "vidformer.vf.UDFFrameType.__init__": {"tf": 1}}, "df": 2}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.Spec.play": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.vf.Spec.save": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"vidformer.vf.Filter.__init__": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.vf.FilterExpr.__init__": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.vf.Spec.__init__": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "f": {"docs": {"vidformer.vf.Spec.play": {"tf": 1}, "vidformer.vf.Spec.load": {"tf": 1}, "vidformer.vf.Spec.save": {"tf": 1}, "vidformer.vf.YrdenServer.hls_js_url": {"tf": 1}, "vidformer.vf.Source.fmt": {"tf": 1}, "vidformer.vf.Source.ts": {"tf": 1}, "vidformer.vf.Source.play": {"tf": 1}, "vidformer.vf.StorageService.as_json": {"tf": 1}, "vidformer.vf.UDF.filter": {"tf": 1}, "vidformer.vf.UDF.filter_type": {"tf": 1}, "vidformer.vf.UDF.into_filter": {"tf": 1}, "vidformer.vf.UDFFrameType.width": {"tf": 1}, "vidformer.vf.UDFFrameType.height": {"tf": 1}, "vidformer.vf.UDFFrameType.pix_fmt": {"tf": 1}, "vidformer.vf.UDFFrame.data": {"tf": 1}, "vidformer.vf.UDFFrame.frame_type": {"tf": 1}}, "df": 16}}, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.vf.Spec.play": {"tf": 1}, "vidformer.vf.Spec.load": {"tf": 1}, "vidformer.vf.Spec.save": {"tf": 1}, "vidformer.vf.Loader.__init__": {"tf": 1}, "vidformer.vf.Source.__init__": {"tf": 1}}, "df": 5}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.Source.__init__": {"tf": 1}, "vidformer.vf.StorageService.__init__": {"tf": 1}}, "df": 2}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.vf.Loader.__init__": {"tf": 1}, "vidformer.vf.Source.__init__": {"tf": 1.4142135623730951}, "vidformer.vf.StorageService.__init__": {"tf": 1}, "vidformer.vf.Filter.__init__": {"tf": 1}, "vidformer.vf.UDF.__init__": {"tf": 1}, "vidformer.vf.UDFFrameType.__init__": {"tf": 1}}, "df": 6, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {"vidformer.vf.Source.__init__": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.SourceExpr.__init__": {"tf": 1}, "vidformer.vf.SourceILoc.__init__": {"tf": 1}}, "df": 2}}}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {"vidformer.vf.Spec.play": {"tf": 1}}, "df": 1}}}}}}, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "l": {"docs": {"vidformer.vf.Spec.play": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.vf.YrdenServer.__init__": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.vf.UDFFrameType.__init__": {"tf": 1}}, "df": 1}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.Spec.play": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.vf.Source.__init__": {"tf": 1}, "vidformer.vf.FilterExpr.__init__": {"tf": 1}, "vidformer.vf.UDFFrame.__init__": {"tf": 1}}, "df": 3}}}}}}}}, "f": {"docs": {"vidformer.vf.Source.__init__": {"tf": 1}, "vidformer.vf.FilterExpr.__init__": {"tf": 1}, "vidformer.vf.UDFFrame.__init__": {"tf": 1}}, "df": 3}}, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"vidformer.vf.Spec.save": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.vf.YrdenServer.__init__": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "x": {"docs": {"vidformer.vf.YrdenServer.__init__": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"vidformer.vf.Source.__init__": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "x": {"docs": {"vidformer.vf.UDFFrameType.__init__": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.vf.Spec.save": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.Spec.save": {"tf": 1.7320508075688772}, "vidformer.vf.YrdenServer.__init__": {"tf": 2}, "vidformer.vf.Source.__init__": {"tf": 1}, "vidformer.vf.Filter.__init__": {"tf": 1}}, "df": 4}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.Source.__init__": {"tf": 1}, "vidformer.vf.Filter.__init__": {"tf": 1}, "vidformer.vf.UDF.__init__": {"tf": 1}}, "df": 3, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.Loader.__init__": {"tf": 1}}, "df": 1}}}}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"vidformer.vf.UDFFrame.__init__": {"tf": 1}}, "df": 1}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"vidformer.vf.UDFFrame.__init__": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.vf.Spec.save": {"tf": 1}}, "df": 1}}}}, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"vidformer.vf.YrdenServer.__init__": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "x": {"docs": {"vidformer.vf.SourceExpr.__init__": {"tf": 1}}, "df": 1}}, "s": {"docs": {"vidformer.vf.SourceExpr.__init__": {"tf": 1}}, "df": 1}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {"vidformer.vf.SourceExpr.__init__": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.vf.Source.__init__": {"tf": 1}, "vidformer.vf.UDFFrameType.__init__": {"tf": 1.4142135623730951}}, "df": 2}}}, "y": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.vf.Source.__init__": {"tf": 1}}, "df": 1}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.vf.Source.play": {"tf": 1}, "vidformer.vf.FilterExpr.__init__": {"tf": 1}, "vidformer.vf.UDF.filter": {"tf": 1}, "vidformer.vf.UDF.filter_type": {"tf": 1}}, "df": 4}}}}, "k": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.vf.Source.play": {"tf": 1}, "vidformer.vf.StorageService.__init__": {"tf": 1}, "vidformer.vf.Filter.__init__": {"tf": 1}, "vidformer.vf.FilterExpr.__init__": {"tf": 1}, "vidformer.vf.UDF.filter": {"tf": 1}, "vidformer.vf.UDF.filter_type": {"tf": 1}}, "df": 6}}}}}}, "t": {"docs": {}, "df": 0, "l": {"docs": {"vidformer.vf.Filter.__init__": {"tf": 1}}, "df": 1}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.UDFFrame.__init__": {"tf": 1}}, "df": 1}}}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"vidformer.vf.UDFFrameType.__init__": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.UDFFrame.__init__": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "bases": {"root": {"docs": {}, "df": 0}}, "doc": {"root": {"docs": {"vidformer.vf": {"tf": 5.830951894845301}, "vidformer.vf.Spec": {"tf": 2.8284271247461903}, "vidformer.vf.Spec.__init__": {"tf": 1.7320508075688772}, "vidformer.vf.Spec.play": {"tf": 1.7320508075688772}, "vidformer.vf.Spec.load": {"tf": 1.7320508075688772}, "vidformer.vf.Spec.save": {"tf": 1.7320508075688772}, "vidformer.vf.Loader": {"tf": 1.7320508075688772}, "vidformer.vf.Loader.__init__": {"tf": 1.7320508075688772}, "vidformer.vf.YrdenServer": {"tf": 2.449489742783178}, "vidformer.vf.YrdenServer.__init__": {"tf": 2.6457513110645907}, "vidformer.vf.YrdenServer.hls_js_url": {"tf": 1.4142135623730951}, "vidformer.vf.SourceExpr": {"tf": 1.7320508075688772}, "vidformer.vf.SourceExpr.__init__": {"tf": 1.7320508075688772}, "vidformer.vf.SourceILoc": {"tf": 1.7320508075688772}, "vidformer.vf.SourceILoc.__init__": {"tf": 1.7320508075688772}, "vidformer.vf.Source": {"tf": 1.7320508075688772}, "vidformer.vf.Source.__init__": {"tf": 1.7320508075688772}, "vidformer.vf.Source.iloc": {"tf": 1.7320508075688772}, "vidformer.vf.Source.fmt": {"tf": 1.7320508075688772}, "vidformer.vf.Source.ts": {"tf": 1.7320508075688772}, "vidformer.vf.Source.play": {"tf": 1.7320508075688772}, "vidformer.vf.StorageService": {"tf": 1.7320508075688772}, "vidformer.vf.StorageService.__init__": {"tf": 1.7320508075688772}, "vidformer.vf.StorageService.as_json": {"tf": 1.7320508075688772}, "vidformer.vf.Filter": {"tf": 1.7320508075688772}, "vidformer.vf.Filter.__init__": {"tf": 1.7320508075688772}, "vidformer.vf.FilterExpr": {"tf": 1.7320508075688772}, "vidformer.vf.FilterExpr.__init__": {"tf": 1.7320508075688772}, "vidformer.vf.UDF": {"tf": 1.4142135623730951}, "vidformer.vf.UDF.__init__": {"tf": 1.7320508075688772}, "vidformer.vf.UDF.filter": {"tf": 1.7320508075688772}, "vidformer.vf.UDF.filter_type": {"tf": 1.7320508075688772}, "vidformer.vf.UDF.into_filter": {"tf": 1.7320508075688772}, "vidformer.vf.UDFFrameType": {"tf": 1.7320508075688772}, "vidformer.vf.UDFFrameType.__init__": {"tf": 1.7320508075688772}, "vidformer.vf.UDFFrameType.width": {"tf": 1.7320508075688772}, "vidformer.vf.UDFFrameType.height": {"tf": 1.7320508075688772}, "vidformer.vf.UDFFrameType.pix_fmt": {"tf": 1.7320508075688772}, "vidformer.vf.UDFFrame": {"tf": 1.7320508075688772}, "vidformer.vf.UDFFrame.__init__": {"tf": 1.7320508075688772}, "vidformer.vf.UDFFrame.data": {"tf": 1.7320508075688772}, "vidformer.vf.UDFFrame.frame_type": {"tf": 1.7320508075688772}}, "df": 42, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.vf": {"tf": 2}, "vidformer.vf.YrdenServer": {"tf": 1}, "vidformer.vf.YrdenServer.__init__": {"tf": 1}}, "df": 3}}}}}}, "e": {"docs": {}, "df": 0, "o": {"docs": {"vidformer.vf.Spec": {"tf": 1}, "vidformer.vf.Spec.play": {"tf": 1}, "vidformer.vf.Spec.save": {"tf": 1}, "vidformer.vf.Source": {"tf": 1}, "vidformer.vf.Source.play": {"tf": 1}, "vidformer.vf.Filter": {"tf": 1}}, "df": 6}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.YrdenServer.__init__": {"tf": 1}}, "df": 1}}}}}}}}, "p": {"docs": {}, "df": 0, "y": {"docs": {"vidformer.vf": {"tf": 1.4142135623730951}}, "df": 1, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"vidformer.vf": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "i": {"docs": {"vidformer.vf": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"vidformer.vf.Spec.play": {"tf": 1}, "vidformer.vf.Source.play": {"tf": 1}}, "df": 2}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.vf.YrdenServer.__init__": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"vidformer.vf.YrdenServer.__init__": {"tf": 1.7320508075688772}}, "df": 1}}}}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.vf": {"tf": 1}, "vidformer.vf.YrdenServer": {"tf": 1}, "vidformer.vf.YrdenServer.__init__": {"tf": 1.4142135623730951}}, "df": 3}, "n": {"docs": {"vidformer.vf.Spec.play": {"tf": 1}, "vidformer.vf.Source.play": {"tf": 1}, "vidformer.vf.UDFFrameType": {"tf": 1}, "vidformer.vf.UDFFrame": {"tf": 1}}, "df": 4, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf": {"tf": 1}}, "df": 1}}}}}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"vidformer.vf.Spec": {"tf": 1}}, "df": 1}}}}}}}}}}, "o": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.vf.Spec": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}, "f": {"docs": {"vidformer.vf.YrdenServer.__init__": {"tf": 1.4142135623730951}}, "df": 1}}, "a": {"docs": {"vidformer.vf": {"tf": 1}, "vidformer.vf.Spec": {"tf": 1}, "vidformer.vf.Spec.save": {"tf": 1}, "vidformer.vf.YrdenServer": {"tf": 1.7320508075688772}, "vidformer.vf.YrdenServer.__init__": {"tf": 1.4142135623730951}, "vidformer.vf.Source": {"tf": 1}, "vidformer.vf.Filter": {"tf": 1}, "vidformer.vf.UDFFrame": {"tf": 1.4142135623730951}}, "df": 8, "p": {"docs": {}, "df": 0, "i": {"docs": {"vidformer.vf.YrdenServer": {"tf": 1}}, "df": 1}}, "n": {"docs": {"vidformer.vf.YrdenServer.__init__": {"tf": 1}}, "df": 1, "d": {"docs": {"vidformer.vf.YrdenServer.__init__": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.YrdenServer.__init__": {"tf": 1}}, "df": 1}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.vf": {"tf": 1}, "vidformer.vf.Spec": {"tf": 1}, "vidformer.vf.YrdenServer": {"tf": 1}, "vidformer.vf.UDFFrameType": {"tf": 1}, "vidformer.vf.UDFFrame": {"tf": 1}}, "df": 5}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.Spec.save": {"tf": 1}, "vidformer.vf.YrdenServer.hls_js_url": {"tf": 1}}, "df": 2}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.vf.Filter": {"tf": 1}, "vidformer.vf.UDF": {"tf": 1}}, "df": 2}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.UDFFrameType": {"tf": 1}, "vidformer.vf.UDFFrame": {"tf": 1}}, "df": 2}}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"vidformer.vf": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"vidformer.vf.YrdenServer.hls_js_url": {"tf": 1}}, "df": 1, "s": {"docs": {"vidformer.vf": {"tf": 1}}, "df": 1}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.Spec.play": {"tf": 1}, "vidformer.vf.Source.play": {"tf": 1}}, "df": 2}}}, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"vidformer.vf.YrdenServer": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"vidformer.vf": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"vidformer.vf.YrdenServer.__init__": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"vidformer.vf.UDF": {"tf": 1}}, "df": 1}}}}}}}, "c": {"docs": {}, "df": 0, "v": {"2": {"docs": {"vidformer.vf": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf": {"tf": 1}}, "df": 1}}, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.vf.YrdenServer.__init__": {"tf": 1.4142135623730951}}, "df": 1, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"vidformer.vf.YrdenServer": {"tf": 1}}, "df": 1}}}}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {"vidformer.vf.YrdenServer.__init__": {"tf": 1}}, "df": 1}}}, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf": {"tf": 1}, "vidformer.vf.Source": {"tf": 1}}, "df": 2}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"vidformer.vf.Spec": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.Spec": {"tf": 1}}, "df": 1}, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.vf.YrdenServer": {"tf": 1.4142135623730951}, "vidformer.vf.YrdenServer.__init__": {"tf": 1.7320508075688772}}, "df": 2}}}}}, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.Spec.save": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.vf.YrdenServer.__init__": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.vf.UDF": {"tf": 1}}, "df": 1}}}}}}}}}, "y": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"vidformer.vf.UDFFrame": {"tf": 1}}, "df": 1}}}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"vidformer.vf.Spec": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.Spec.play": {"tf": 1.4142135623730951}, "vidformer.vf.Spec.save": {"tf": 1}, "vidformer.vf.YrdenServer": {"tf": 1}, "vidformer.vf.YrdenServer.__init__": {"tf": 1.4142135623730951}, "vidformer.vf.YrdenServer.hls_js_url": {"tf": 1.4142135623730951}, "vidformer.vf.Source.play": {"tf": 1.4142135623730951}}, "df": 6}}, "o": {"docs": {"vidformer.vf.Spec.save": {"tf": 1}, "vidformer.vf.YrdenServer": {"tf": 1}, "vidformer.vf.YrdenServer.__init__": {"tf": 1.4142135623730951}, "vidformer.vf.YrdenServer.hls_js_url": {"tf": 1}, "vidformer.vf.UDFFrame": {"tf": 1}}, "df": 5}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.UDFFrameType": {"tf": 1}}, "df": 1}}}}, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, ":": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {"vidformer.vf.Spec": {"tf": 1}}, "df": 1}}}}}}}}}}}, "m": {"docs": {}, "df": 0, "l": {"docs": {"vidformer.vf.Spec": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"vidformer.vf.YrdenServer.hls_js_url": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.vf.YrdenServer.hls_js_url": {"tf": 1}}, "df": 1}}}, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "b": {"docs": {"vidformer.vf.Spec": {"tf": 1}}, "df": 1}}}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.Spec": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"vidformer.vf.YrdenServer": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {"vidformer.vf.YrdenServer.__init__": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "k": {"docs": {"vidformer.vf.Spec.play": {"tf": 1}, "vidformer.vf.Source.play": {"tf": 1}}, "df": 2}}}}}}}, "e": {"docs": {}, "df": 0, "w": {"docs": {"vidformer.vf.YrdenServer.__init__": {"tf": 1}}, "df": 1}}}, "y": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"vidformer.vf.YrdenServer": {"tf": 1.4142135623730951}, "vidformer.vf.YrdenServer.__init__": {"tf": 1}, "vidformer.vf.YrdenServer.hls_js_url": {"tf": 1}}, "df": 3}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.YrdenServer": {"tf": 1}, "vidformer.vf.UDFFrameType": {"tf": 1}, "vidformer.vf.UDFFrame": {"tf": 1}}, "df": 3, "d": {"docs": {"vidformer.vf.YrdenServer.__init__": {"tf": 1}}, "df": 1}, "r": {"docs": {"vidformer.vf.UDF": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"vidformer.vf.YrdenServer.__init__": {"tf": 1}}, "df": 1}}}}, "d": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.vf.UDFFrameType": {"tf": 1}, "vidformer.vf.UDFFrame": {"tf": 1}}, "df": 2}}}}, "o": {"docs": {}, "df": 0, "f": {"docs": {"vidformer.vf.YrdenServer": {"tf": 1}}, "df": 1}, "r": {"docs": {"vidformer.vf.YrdenServer.__init__": {"tf": 1.4142135623730951}}, "df": 1}}, "e": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"vidformer.vf.YrdenServer.__init__": {"tf": 1}}, "df": 1}}}}}, "x": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"vidformer.vf.YrdenServer.__init__": {"tf": 1}}, "df": 1}}}}}}}, "n": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"vidformer.vf.YrdenServer.__init__": {"tf": 1}}, "df": 1}}}}}}}}}}}, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"vidformer.vf.YrdenServer.__init__": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"vidformer.vf.YrdenServer.__init__": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {"vidformer.vf.YrdenServer.hls_js_url": {"tf": 1}}, "df": 1}}}}, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.vf.UDFFrame": {"tf": 1}}, "df": 1}}}}}}}}}, "j": {"docs": {}, "df": 0, "s": {"docs": {"vidformer.vf.YrdenServer.hls_js_url": {"tf": 1}}, "df": 1}}}}}, "pipeline": ["trimmer"], "_isPrebuiltIndex": true}; + + // mirrored in build-search-index.js (part 1) + // Also split on html tags. this is a cheap heuristic, but good enough. + elasticlunr.tokenizer.setSeperator(/[\s\-.;&_'"=,()]+|<[^>]*>/); + + let searchIndex; + if (docs._isPrebuiltIndex) { + console.info("using precompiled search index"); + searchIndex = elasticlunr.Index.load(docs); + } else { + console.time("building search index"); + // mirrored in build-search-index.js (part 2) + searchIndex = elasticlunr(function () { + this.pipeline.remove(elasticlunr.stemmer); + this.pipeline.remove(elasticlunr.stopWordFilter); + this.addField("qualname"); + this.addField("fullname"); + this.addField("annotation"); + this.addField("default_value"); + this.addField("signature"); + this.addField("bases"); + this.addField("doc"); + this.setRef("fullname"); + }); + for (let doc of docs) { + searchIndex.addDoc(doc); + } + console.timeEnd("building search index"); + } + + return (term) => searchIndex.search(term, { + fields: { + qualname: {boost: 4}, + fullname: {boost: 2}, + annotation: {boost: 2}, + default_value: {boost: 2}, + signature: {boost: 2}, + bases: {boost: 2}, + doc: {boost: 1}, + }, + expand: true + }); +})(); \ No newline at end of file diff --git a/vidformer-py/vidformer/vf.html b/vidformer-py/vidformer/vf.html new file mode 100644 index 0000000..f6bf39e --- /dev/null +++ b/vidformer-py/vidformer/vf.html @@ -0,0 +1,3117 @@ + + + + + + +
+vidformer.vf
+
+ vidformer-py is a Python 🐍 interface for vidformer.
+ +Quick links:
+ + +1""" + 2vidformer-py is a Python 🐍 interface for [vidformer](https://github.com/ixlab/vidformer). + 3 + 4**Quick links:** + 5* [📦 PyPI](https://pypi.org/project/vidformer/) + 6* [📘 Documentation - vidformer-py](https://ixlab.github.io/vidformer/vidformer-py/) + 7* [📘 Documentation - vidformer.cv2](https://ixlab.github.io/vidformer/vidformer-py-cv2/) + 8* [🧑💻 Source Code](https://github.com/ixlab/vidformer/tree/main/vidformer-py/) + 9""" + 10 + 11import subprocess + 12from fractions import Fraction + 13import random + 14import time + 15import json + 16import socket + 17import os + 18import sys + 19import multiprocessing + 20import uuid + 21import threading + 22import gzip + 23import base64 + 24import re + 25 + 26import requests + 27import msgpack + 28import numpy as np + 29 + 30from . import __version__ + 31 + 32_in_notebook = False + 33try: + 34 from IPython import get_ipython + 35 + 36 if "IPKernelApp" in get_ipython().config: + 37 _in_notebook = True + 38except: + 39 pass + 40 + 41 + 42def _check_hls_link_exists(url, max_attempts=150, delay=0.1): + 43 for attempt in range(max_attempts): + 44 try: + 45 response = requests.get(url) + 46 if response.status_code == 200: + 47 return response.text.strip() + 48 else: + 49 time.sleep(delay) + 50 except requests.exceptions.RequestException as e: + 51 time.sleep(delay) + 52 return None + 53 + 54 + 55class Spec: + 56 """ + 57 A video transformation specification. + 58 + 59 See https://ixlab.github.io/vidformer/concepts.html for more information. + 60 """ + 61 + 62 def __init__(self, domain: list[Fraction], render, fmt: dict): + 63 self._domain = domain + 64 self._render = render + 65 self._fmt = fmt + 66 + 67 def __repr__(self): + 68 if len(self._domain) <= 20: + 69 lines = [] + 70 for i, t in enumerate(self._domain): + 71 frame_expr = self._render(t, i) + 72 lines.append( + 73 f"{t.numerator}/{t.denominator} => {frame_expr}", + 74 ) + 75 return "\n".join(lines) + 76 else: + 77 lines = [] + 78 for i, t in enumerate(self._domain[:10]): + 79 frame_expr = self._render(t, i) + 80 lines.append( + 81 f"{t.numerator}/{t.denominator} => {frame_expr}", + 82 ) + 83 lines.append("...") + 84 for i, t in enumerate(self._domain[-10:]): + 85 frame_expr = self._render(t, i) + 86 lines.append( + 87 f"{t.numerator}/{t.denominator} => {frame_expr}", + 88 ) + 89 return "\n".join(lines) + 90 + 91 def _sources(self): + 92 s = set() + 93 for i, t in enumerate(self._domain): + 94 frame_expr = self._render(t, i) + 95 s = s.union(frame_expr._sources()) + 96 return s + 97 + 98 def _to_json_spec(self): + 99 frames = [] +100 s = set() +101 f = {} +102 for i, t in enumerate(self._domain): +103 frame_expr = self._render(t, i) +104 s = s.union(frame_expr._sources()) +105 f = {**f, **frame_expr._filters()} +106 frame = [[t.numerator, t.denominator], frame_expr._to_json_spec()] +107 frames.append(frame) +108 return {"frames": frames}, s, f +109 +110 def play(self, server, method="html", verbose=False): +111 """Play the video live in the notebook.""" +112 +113 spec, sources, filters = self._to_json_spec() +114 spec_json_bytes = json.dumps(spec).encode("utf-8") +115 spec_obj_json_gzip = gzip.compress(spec_json_bytes, compresslevel=1) +116 spec_obj_json_gzip_b64 = base64.b64encode(spec_obj_json_gzip).decode("utf-8") +117 +118 sources = [ +119 { +120 "name": s._name, +121 "path": s._path, +122 "stream": s._stream, +123 "service": s._service.as_json() if s._service is not None else None, +124 } +125 for s in sources +126 ] +127 filters = { +128 k: { +129 "filter": v._func, +130 "args": v._kwargs, +131 } +132 for k, v in filters.items() +133 } +134 arrays = [] +135 +136 if verbose: +137 print(f"Sending to server. Spec is {len(spec_obj_json_gzip_b64)} bytes") +138 +139 resp = server._new(spec_obj_json_gzip_b64, sources, filters, arrays, self._fmt) +140 hls_video_url = resp["stream_url"] +141 hls_player_url = resp["player_url"] +142 namespace = resp["namespace"] +143 hls_js_url = server.hls_js_url() +144 +145 if method == "link": +146 return hls_video_url +147 if method == "player": +148 return hls_player_url +149 if method == "iframe": +150 from IPython.display import IFrame +151 +152 return IFrame(hls_player_url, width=1280, height=720) +153 if method == "html": +154 from IPython.display import HTML +155 +156 # We add a namespace to the video element to avoid conflicts with other videos +157 html_code = f""" +158<!DOCTYPE html> +159<html> +160<head> +161 <title>HLS Video Player</title> +162 <!-- Include hls.js library --> +163 <script src="{hls_js_url}"></script> +164</head> +165<body> +166 <!-- Video element --> +167 <video id="video-{namespace}" controls width="640" height="360" autoplay></video> +168 <script> +169 var video = document.getElementById('video-{namespace}'); +170 var videoSrc = '{hls_video_url}'; +171 var hls = new Hls(); +172 hls.loadSource(videoSrc); +173 hls.attachMedia(video); +174 hls.on(Hls.Events.MANIFEST_PARSED, function() {{ +175 video.play(); +176 }}); +177 </script> +178</body> +179</html> +180""" +181 return HTML(data=html_code) +182 else: +183 return hls_player_url +184 +185 def load(self, server): +186 spec, sources, filters = self._to_json_spec() +187 spec_json_bytes = json.dumps(spec).encode("utf-8") +188 spec_obj_json_gzip = gzip.compress(spec_json_bytes, compresslevel=1) +189 spec_obj_json_gzip_b64 = base64.b64encode(spec_obj_json_gzip).decode("utf-8") +190 +191 sources = [ +192 { +193 "name": s._name, +194 "path": s._path, +195 "stream": s._stream, +196 "service": s._service.as_json() if s._service is not None else None, +197 } +198 for s in sources +199 ] +200 filters = { +201 k: { +202 "filter": v._func, +203 "args": v._kwargs, +204 } +205 for k, v in filters.items() +206 } +207 arrays = [] +208 +209 resp = server._new(spec_obj_json_gzip_b64, sources, filters, arrays, self._fmt) +210 namespace = resp["namespace"] +211 return Loader(server, namespace, self._domain) +212 +213 def save(self, server, pth, encoder=None, encoder_opts=None, format=None): +214 """Save the video to a file.""" +215 +216 assert encoder is None or type(encoder) == str +217 assert encoder_opts is None or type(encoder_opts) == dict +218 if encoder_opts is not None: +219 for k, v in encoder_opts.items(): +220 assert type(k) == str and type(v) == str +221 +222 spec, sources, filters = self._to_json_spec() +223 spec_json_bytes = json.dumps(spec).encode("utf-8") +224 spec_obj_json_gzip = gzip.compress(spec_json_bytes, compresslevel=1) +225 spec_obj_json_gzip_b64 = base64.b64encode(spec_obj_json_gzip).decode("utf-8") +226 +227 sources = [ +228 { +229 "name": s._name, +230 "path": s._path, +231 "stream": s._stream, +232 "service": s._service.as_json() if s._service is not None else None, +233 } +234 for s in sources +235 ] +236 filters = { +237 k: { +238 "filter": v._func, +239 "args": v._kwargs, +240 } +241 for k, v in filters.items() +242 } +243 arrays = [] +244 +245 resp = server._export( +246 pth, +247 spec_obj_json_gzip_b64, +248 sources, +249 filters, +250 arrays, +251 self._fmt, +252 encoder, +253 encoder_opts, +254 format, +255 ) +256 +257 return resp +258 +259 def _vrod_bench(self, server): +260 out = {} +261 pth = "spec.json" +262 start_t = time.time() +263 with open(pth, "w") as outfile: +264 spec, sources, filters = self._to_json_spec() +265 outfile.write(json.dumps(spec)) +266 +267 sources = [ +268 { +269 "name": s._name, +270 "path": s._path, +271 "stream": s._stream, +272 "service": s._service.as_json() if s._service is not None else None, +273 } +274 for s in sources +275 ] +276 filters = { +277 k: { +278 "filter": v._func, +279 "args": v._kwargs, +280 } +281 for k, v in filters.items() +282 } +283 arrays = [] +284 end_t = time.time() +285 out["vrod_create_spec"] = end_t - start_t +286 +287 start = time.time() +288 resp = server._new(pth, sources, filters, arrays, self._fmt) +289 end = time.time() +290 out["vrod_register"] = end - start +291 +292 stream_url = resp["stream_url"] +293 first_segment = stream_url.replace("stream.m3u8", "segment-0.ts") +294 +295 start = time.time() +296 r = requests.get(first_segment) +297 r.raise_for_status() +298 end = time.time() +299 out["vrod_first_segment"] = end - start +300 return out +301 +302 def _dve2_bench(self, server): +303 pth = "spec.json" +304 out = {} +305 start_t = time.time() +306 with open(pth, "w") as outfile: +307 spec, sources, filters = self._to_json_spec() +308 outfile.write(json.dumps(spec)) +309 +310 sources = [ +311 { +312 "name": s._name, +313 "path": s._path, +314 "stream": s._stream, +315 "service": s._service.as_json() if s._service is not None else None, +316 } +317 for s in sources +318 ] +319 filters = { +320 k: { +321 "filter": v._func, +322 "args": v._kwargs, +323 } +324 for k, v in filters.items() +325 } +326 arrays = [] +327 end_t = time.time() +328 out["dve2_create_spec"] = end_t - start_t +329 +330 start = time.time() +331 resp = server._export(pth, sources, filters, arrays, self._fmt, None, None) +332 end = time.time() +333 out["dve2_exec"] = end - start +334 return out +335 +336 +337class Loader: +338 def __init__(self, server, namespace: str, domain): +339 self._server = server +340 self._namespace = namespace +341 self._domain = domain +342 +343 def _chunk(self, start_i, end_i): +344 return self._server._raw(self._namespace, start_i, end_i) +345 +346 def __len__(self): +347 return len(self._domain) +348 +349 def _find_index_by_rational(self, value): +350 if value not in self._domain: +351 raise ValueError(f"Rational timestamp {value} is not in the domain") +352 return self._domain.index(value) +353 +354 def __getitem__(self, index): +355 if isinstance(index, slice): +356 start = index.start if index.start is not None else 0 +357 end = index.stop if index.stop is not None else len(self._domain) +358 assert start >= 0 and start < len(self._domain) +359 assert end >= 0 and end <= len(self._domain) +360 assert start <= end +361 num_frames = end - start +362 all_bytes = self._chunk(start, end - 1) +363 all_bytes_len = len(all_bytes) +364 assert all_bytes_len % num_frames == 0 +365 return [ +366 all_bytes[ +367 i +368 * all_bytes_len +369 // num_frames : (i + 1) +370 * all_bytes_len +371 // num_frames +372 ] +373 for i in range(num_frames) +374 ] +375 elif isinstance(index, int): +376 assert index >= 0 and index < len(self._domain) +377 return self._chunk(index, index) +378 else: +379 raise TypeError( +380 "Invalid argument type for iloc. Use a slice or an integer." +381 ) +382 +383 +384class YrdenServer: +385 """ +386 A connection to a Yrden server. +387 +388 A yrden server is the main API for local use of vidformer. +389 """ +390 +391 def __init__(self, domain=None, port=None, bin=None, hls_prefix=None): +392 """ +393 Connect to a Yrden server +394 +395 Can either connect to an existing server, if domain and port are provided, or start a new server using the provided binary. +396 If no domain or binary is provided, the `VIDFORMER_BIN` environment variable is used. +397 """ +398 +399 self._domain = domain +400 self._port = port +401 self._proc = None +402 if self._port is None: +403 if bin is None: +404 if os.getenv("VIDFORMER_BIN") is not None: +405 bin = os.getenv("VIDFORMER_BIN") +406 else: +407 bin = "vidformer-cli" +408 +409 self._domain = "localhost" +410 self._port = random.randint(49152, 65535) +411 cmd = [bin, "yrden", "--port", str(self._port)] +412 if _in_notebook: +413 # We need to print the URL in the notebook +414 # This is a trick to get VS Code to forward the port +415 cmd += ["--print-url"] +416 +417 if hls_prefix is not None: +418 if not type(hls_prefix) == str: +419 raise Exception("hls_prefix must be a string") +420 cmd += ["--hls-prefix", hls_prefix] +421 +422 self._proc = subprocess.Popen(cmd) +423 +424 version = _check_hls_link_exists(f"http://{self._domain}:{self._port}/") +425 if version is None: +426 raise Exception("Failed to connect to server") +427 +428 expected_version = f"vidformer-yrden v{__version__}" +429 if version != expected_version: +430 print( +431 f"Warning: Expected version `{expected_version}`, got `{version}`. API may not be compatible!" +432 ) +433 +434 def _source(self, name: str, path: str, stream: int, service): +435 r = requests.post( +436 f"http://{self._domain}:{self._port}/source", +437 json={ +438 "name": name, +439 "path": path, +440 "stream": stream, +441 "service": service.as_json() if service is not None else None, +442 }, +443 ) +444 if not r.ok: +445 raise Exception(r.text) +446 +447 resp = r.json() +448 resp["ts"] = [Fraction(x[0], x[1]) for x in resp["ts"]] +449 return resp +450 +451 def _new(self, spec, sources, filters, arrays, fmt): +452 req = { +453 "spec": spec, +454 "sources": sources, +455 "filters": filters, +456 "arrays": arrays, +457 "width": fmt["width"], +458 "height": fmt["height"], +459 "pix_fmt": fmt["pix_fmt"], +460 } +461 +462 r = requests.post(f"http://{self._domain}:{self._port}/new", json=req) +463 if not r.ok: +464 raise Exception(r.text) +465 +466 return r.json() +467 +468 def _export( +469 self, pth, spec, sources, filters, arrays, fmt, encoder, encoder_opts, format +470 ): +471 req = { +472 "spec": spec, +473 "sources": sources, +474 "filters": filters, +475 "arrays": arrays, +476 "width": fmt["width"], +477 "height": fmt["height"], +478 "pix_fmt": fmt["pix_fmt"], +479 "output_path": pth, +480 "encoder": encoder, +481 "encoder_opts": encoder_opts, +482 "format": format, +483 } +484 +485 r = requests.post(f"http://{self._domain}:{self._port}/export", json=req) +486 if not r.ok: +487 raise Exception(r.text) +488 +489 return r.json() +490 +491 def _raw(self, namespace, start_i, end_i): +492 r = requests.get( +493 f"http://{self._domain}:{self._port}/{namespace}/raw/{start_i}-{end_i}" +494 ) +495 if not r.ok: +496 raise Exception(r.text) +497 return r.content +498 +499 def hls_js_url(self): +500 """Return the link to the yrden-hosted hls.js file""" +501 return f"http://{self._domain}:{self._port}/hls.js" +502 +503 def __del__(self): +504 if self._proc is not None: +505 self._proc.kill() +506 +507 +508class SourceExpr: +509 def __init__(self, source, idx, is_iloc): +510 self._source = source +511 self._idx = idx +512 self._is_iloc = is_iloc +513 +514 def __repr__(self): +515 if self._is_iloc: +516 return f"{self._source._name}.iloc[{self._idx}]" +517 else: +518 return f"{self._source._name}[{self._idx}]" +519 +520 def _to_json_spec(self): +521 if self._is_iloc: +522 return { +523 "Source": { +524 "video": self._source._name, +525 "index": {"ILoc": int(self._idx)}, +526 } +527 } +528 else: +529 return { +530 "Source": { +531 "video": self._source._name, +532 "index": {"T": [self._idx.numerator, self._idx.denominator]}, +533 } +534 } +535 +536 def _sources(self): +537 return set([self._source]) +538 +539 def _filters(self): +540 return {} +541 +542 +543class SourceILoc: +544 def __init__(self, source): +545 self._source = source +546 +547 def __getitem__(self, idx): +548 if type(idx) != int: +549 raise Exception(f"Source iloc index must be an integer, got a {type(idx)}") +550 return SourceExpr(self._source, idx, True) +551 +552 +553class Source: +554 """A video source.""" +555 +556 def __init__( +557 self, server: YrdenServer, name: str, path: str, stream: int, service=None +558 ): +559 if service is None: +560 # check if path is a http URL and, if so, automatically set the service +561 # for example, the following code should work with just vf.Source(server, "tos_720p", "https://f.dominik.win/data/dve2/tos_720p.mp4") +562 # this creates a storage service with endpoint "https://f.dominik.win/" and path "data/dve2/tos_720p.mp4" +563 # don't use the root parameter in this case +564 +565 match = re.match(r"(http|https)://([^/]+)(.*)", path) +566 if match is not None: +567 endpoint = f"{match.group(1)}://{match.group(2)}" +568 path = match.group(3) +569 # remove leading slash +570 if path.startswith("/"): +571 path = path[1:] +572 service = StorageService("http", endpoint=endpoint) +573 +574 self._server = server +575 self._name = name +576 self._path = path +577 self._stream = stream +578 self._service = service +579 +580 self.iloc = SourceILoc(self) +581 +582 self._src = self._server._source( +583 self._name, self._path, self._stream, self._service +584 ) +585 +586 def fmt(self): +587 return { +588 "width": self._src["width"], +589 "height": self._src["height"], +590 "pix_fmt": self._src["pix_fmt"], +591 } +592 +593 def ts(self): +594 return self._src["ts"] +595 +596 def __len__(self): +597 return len(self._src["ts"]) +598 +599 def __getitem__(self, idx): +600 if type(idx) != Fraction: +601 raise Exception("Source index must be a Fraction") +602 return SourceExpr(self, idx, False) +603 +604 def play(self, *args, **kwargs): +605 """Play the video live in the notebook.""" +606 +607 domain = self.ts() +608 render = lambda t, i: self[t] +609 spec = Spec(domain, render, self.fmt()) +610 return spec.play(*args, **kwargs) +611 +612 +613class StorageService: +614 def __init__(self, service: str, **kwargs): +615 if type(service) != str: +616 raise Exception("Service name must be a string") +617 self._service = service +618 for k, v in kwargs.items(): +619 if type(v) != str: +620 raise Exception(f"Value of {k} must be a string") +621 self._config = kwargs +622 +623 def as_json(self): +624 return {"service": self._service, "config": self._config} +625 +626 def __repr__(self): +627 return f"{self._service}(config={self._config})" +628 +629 +630def _json_arg(arg, skip_data_anot=False): +631 if type(arg) == FilterExpr or type(arg) == SourceExpr: +632 return {"Frame": arg._to_json_spec()} +633 elif type(arg) == int: +634 if skip_data_anot: +635 return {"Int": arg} +636 return {"Data": {"Int": arg}} +637 elif type(arg) == str: +638 if skip_data_anot: +639 return {"String": arg} +640 return {"Data": {"String": arg}} +641 elif type(arg) == bytes: +642 arg = list(arg) +643 if skip_data_anot: +644 return {"Bytes": arg} +645 return {"Data": {"Bytes": arg}} +646 elif type(arg) == float: +647 if skip_data_anot: +648 return {"Float": arg} +649 return {"Data": {"Float": arg}} +650 elif type(arg) == bool: +651 if skip_data_anot: +652 return {"Bool": arg} +653 return {"Data": {"Bool": arg}} +654 elif type(arg) == tuple or type(arg) == list: +655 if skip_data_anot: +656 return {"List": [_json_arg(x, True) for x in list(arg)]} +657 return {"Data": {"List": [_json_arg(x, True) for x in list(arg)]}} +658 else: +659 raise Exception(f"Unknown arg type: {type(arg)}") +660 +661 +662class Filter: +663 """A video filter.""" +664 +665 def __init__(self, name: str, tl_func=None, **kwargs): +666 self._name = name +667 +668 # tl_func is the top level func, which is the true implementation, not just a pretty name +669 if tl_func is None: +670 self._func = name +671 else: +672 self._func = tl_func +673 +674 # filter infra args, not invocation args +675 for k, v in kwargs.items(): +676 if type(v) != str: +677 raise Exception(f"Value of {k} must be a string") +678 self._kwargs = kwargs +679 +680 def __call__(self, *args, **kwargs): +681 return FilterExpr(self, args, kwargs) +682 +683 +684class FilterExpr: +685 def __init__(self, filter: Filter, args, kwargs): +686 self._filter = filter +687 self._args = args +688 self._kwargs = kwargs +689 +690 def __repr__(self): +691 args = [] +692 for arg in self._args: +693 val = f'"{arg}"' if type(arg) == str else str(arg) +694 args.append(str(val)) +695 for k, v in self._kwargs.items(): +696 val = f'"{v}"' if type(v) == str else str(v) +697 args.append(f"{k}={val}") +698 return f"{self._filter._name}({', '.join(args)})" +699 +700 def _to_json_spec(self): +701 args = [] +702 for arg in self._args: +703 args.append(_json_arg(arg)) +704 kwargs = {} +705 for k, v in self._kwargs.items(): +706 kwargs[k] = _json_arg(v) +707 return {"Filter": {"name": self._filter._name, "args": args, "kwargs": kwargs}} +708 +709 def _sources(self): +710 s = set() +711 for arg in self._args: +712 if type(arg) == FilterExpr or type(arg) == SourceExpr: +713 s = s.union(arg._sources()) +714 for arg in self._kwargs.values(): +715 if type(arg) == FilterExpr or type(arg) == SourceExpr: +716 s = s.union(arg._sources()) +717 return s +718 +719 def _filters(self): +720 f = {self._filter._name: self._filter} +721 for arg in self._args: +722 if type(arg) == FilterExpr: +723 f = {**f, **arg._filters()} +724 for arg in self._kwargs.values(): +725 if type(arg) == FilterExpr: +726 f = {**f, **arg._filters()} +727 return f +728 +729 +730class UDF: +731 """User-defined filter superclass""" +732 +733 def __init__(self, name: str): +734 self._name = name +735 self._socket_path = None +736 self._p = None +737 +738 def filter(self, *args, **kwargs): +739 raise Exception("User must implement the filter method") +740 +741 def filter_type(self, *args, **kwargs): +742 raise Exception("User must implement the filter_type method") +743 +744 def into_filter(self): +745 assert self._socket_path is None +746 self._socket_path = f"/tmp/vidformer-{self._name}-{str(uuid.uuid4())}.sock" +747 self._p = multiprocessing.Process( +748 target=_run_udf_host, args=(self, self._socket_path) +749 ) +750 self._p.start() +751 return Filter( +752 name=self._name, tl_func="IPC", socket=self._socket_path, func=self._name +753 ) +754 +755 def _handle_connection(self, connection): +756 try: +757 while True: +758 frame_len = connection.recv(4) +759 if not frame_len or len(frame_len) != 4: +760 break +761 frame_len = int.from_bytes(frame_len, byteorder="big") +762 data = connection.recv(frame_len) +763 if not data: +764 break +765 +766 while len(data) < frame_len: +767 new_data = connection.recv(frame_len - len(data)) +768 if not new_data: +769 raise Exception("Partial data received") +770 data += new_data +771 +772 obj = msgpack.unpackb(data, raw=False) +773 f_func, f_op, f_args, f_kwargs = ( +774 obj["func"], +775 obj["op"], +776 obj["args"], +777 obj["kwargs"], +778 ) +779 +780 response = None +781 if f_op == "filter": +782 f_args = [self._deser_filter(x) for x in f_args] +783 f_kwargs = {k: self._deser_filter(v) for k, v in f_kwargs} +784 response = self.filter(*f_args, **f_kwargs) +785 if type(response) != UDFFrame: +786 raise Exception( +787 f"filter must return a UDFFrame, got {type(response)}" +788 ) +789 if response.frame_type().pix_fmt() != "rgb24": +790 raise Exception( +791 f"filter must return a frame with pix_fmt 'rgb24', got {response.frame_type().pix_fmt()}" +792 ) +793 +794 response = response._response_ser() +795 elif f_op == "filter_type": +796 f_args = [self._deser_filter_type(x) for x in f_args] +797 f_kwargs = {k: self._deser_filter_type(v) for k, v in f_kwargs} +798 response = self.filter_type(*f_args, **f_kwargs) +799 if type(response) != UDFFrameType: +800 raise Exception( +801 f"filter_type must return a UDFFrameType, got {type(response)}" +802 ) +803 if response.pix_fmt() != "rgb24": +804 raise Exception( +805 f"filter_type must return a frame with pix_fmt 'rgb24', got {response.pix_fmt()}" +806 ) +807 response = response._response_ser() +808 else: +809 raise Exception(f"Unknown operation: {f_op}") +810 +811 response = msgpack.packb(response, use_bin_type=True) +812 response_len = len(response).to_bytes(4, byteorder="big") +813 connection.sendall(response_len) +814 connection.sendall(response) +815 finally: +816 connection.close() +817 +818 def _deser_filter_type(self, obj): +819 assert type(obj) == dict +820 keys = list(obj.keys()) +821 assert len(keys) == 1 +822 type_key = keys[0] +823 assert type_key in ["FrameType", "String", "Int", "Bool"] +824 +825 if type_key == "FrameType": +826 frame = obj[type_key] +827 assert type(frame) == dict +828 assert "width" in frame +829 assert "height" in frame +830 assert "format" in frame +831 assert type(frame["width"]) == int +832 assert type(frame["height"]) == int +833 assert frame["format"] == 2 # AV_PIX_FMT_RGB24 +834 return UDFFrameType(frame["width"], frame["height"], "rgb24") +835 elif type_key == "String": +836 assert type(obj[type_key]) == str +837 return obj[type_key] +838 elif type_key == "Int": +839 assert type(obj[type_key]) == int +840 return obj[type_key] +841 elif type_key == "Bool": +842 assert type(obj[type_key]) == bool +843 return obj[type_key] +844 else: +845 assert False, f"Unknown type: {type_key}" +846 +847 def _deser_filter(self, obj): +848 assert type(obj) == dict +849 keys = list(obj.keys()) +850 assert len(keys) == 1 +851 type_key = keys[0] +852 assert type_key in ["Frame", "String", "Int", "Bool"] +853 +854 if type_key == "Frame": +855 frame = obj[type_key] +856 assert type(frame) == dict +857 assert "data" in frame +858 assert "width" in frame +859 assert "height" in frame +860 assert "format" in frame +861 assert type(frame["width"]) == int +862 assert type(frame["height"]) == int +863 assert frame["format"] == "rgb24" +864 assert type(frame["data"]) == bytes +865 +866 data = np.frombuffer(frame["data"], dtype=np.uint8) +867 data = data.reshape(frame["height"], frame["width"], 3) +868 return UDFFrame( +869 data, UDFFrameType(frame["width"], frame["height"], "rgb24") +870 ) +871 elif type_key == "String": +872 assert type(obj[type_key]) == str +873 return obj[type_key] +874 elif type_key == "Int": +875 assert type(obj[type_key]) == int +876 return obj[type_key] +877 elif type_key == "Bool": +878 assert type(obj[type_key]) == bool +879 return obj[type_key] +880 else: +881 assert False, f"Unknown type: {type_key}" +882 +883 def _host(self, socket_path: str): +884 if os.path.exists(socket_path): +885 os.remove(socket_path) +886 +887 # start listening on the socket +888 sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) +889 sock.bind(socket_path) +890 sock.listen(1) +891 +892 while True: +893 # accept incoming connection +894 connection, client_address = sock.accept() +895 thread = threading.Thread( +896 target=self._handle_connection, args=(connection,) +897 ) +898 thread.start() +899 +900 def __del__(self): +901 if self._socket_path is not None: +902 self._p.terminate() +903 if os.path.exists(self._socket_path): +904 # it's possible the process hasn't even created the socket yet +905 os.remove(self._socket_path) +906 +907 +908class UDFFrameType: +909 """ +910 Frame type for use in UDFs. +911 """ +912 +913 def __init__(self, width: int, height: int, pix_fmt: str): +914 assert type(width) == int +915 assert type(height) == int +916 assert type(pix_fmt) == str +917 +918 self._width = width +919 self._height = height +920 self._pix_fmt = pix_fmt +921 +922 def width(self): +923 return self._width +924 +925 def height(self): +926 return self._height +927 +928 def pix_fmt(self): +929 return self._pix_fmt +930 +931 def _response_ser(self): +932 return { +933 "frame_type": { +934 "width": self._width, +935 "height": self._height, +936 "format": 2, # AV_PIX_FMT_RGB24 +937 } +938 } +939 +940 def __repr__(self): +941 return f"FrameType<{self._width}x{self._height}, {self._pix_fmt}>" +942 +943 +944class UDFFrame: +945 """A symbolic reference to a frame for use in UDFs.""" +946 +947 def __init__(self, data: np.ndarray, f_type: UDFFrameType): +948 assert type(data) == np.ndarray +949 assert type(f_type) == UDFFrameType +950 +951 # We only support RGB24 for now +952 assert data.dtype == np.uint8 +953 assert data.shape[2] == 3 +954 +955 # check type matches +956 assert data.shape[0] == f_type.height() +957 assert data.shape[1] == f_type.width() +958 assert f_type.pix_fmt() == "rgb24" +959 +960 self._data = data +961 self._f_type = f_type +962 +963 def data(self): +964 return self._data +965 +966 def frame_type(self): +967 return self._f_type +968 +969 def _response_ser(self): +970 return { +971 "frame": { +972 "data": self._data.tobytes(), +973 "width": self._f_type.width(), +974 "height": self._f_type.height(), +975 "format": "rgb24", +976 } +977 } +978 +979 def __repr__(self): +980 return f"Frame<{self._f_type.width()}x{self._f_type.height()}, {self._f_type.pix_fmt()}>" +981 +982 +983def _run_udf_host(udf: UDF, socket_path: str): +984 udf._host(socket_path) +
+
+ class
+ Spec:
+
+
+
+
+
+ 56class Spec: + 57 """ + 58 A video transformation specification. + 59 + 60 See https://ixlab.github.io/vidformer/concepts.html for more information. + 61 """ + 62 + 63 def __init__(self, domain: list[Fraction], render, fmt: dict): + 64 self._domain = domain + 65 self._render = render + 66 self._fmt = fmt + 67 + 68 def __repr__(self): + 69 if len(self._domain) <= 20: + 70 lines = [] + 71 for i, t in enumerate(self._domain): + 72 frame_expr = self._render(t, i) + 73 lines.append( + 74 f"{t.numerator}/{t.denominator} => {frame_expr}", + 75 ) + 76 return "\n".join(lines) + 77 else: + 78 lines = [] + 79 for i, t in enumerate(self._domain[:10]): + 80 frame_expr = self._render(t, i) + 81 lines.append( + 82 f"{t.numerator}/{t.denominator} => {frame_expr}", + 83 ) + 84 lines.append("...") + 85 for i, t in enumerate(self._domain[-10:]): + 86 frame_expr = self._render(t, i) + 87 lines.append( + 88 f"{t.numerator}/{t.denominator} => {frame_expr}", + 89 ) + 90 return "\n".join(lines) + 91 + 92 def _sources(self): + 93 s = set() + 94 for i, t in enumerate(self._domain): + 95 frame_expr = self._render(t, i) + 96 s = s.union(frame_expr._sources()) + 97 return s + 98 + 99 def _to_json_spec(self): +100 frames = [] +101 s = set() +102 f = {} +103 for i, t in enumerate(self._domain): +104 frame_expr = self._render(t, i) +105 s = s.union(frame_expr._sources()) +106 f = {**f, **frame_expr._filters()} +107 frame = [[t.numerator, t.denominator], frame_expr._to_json_spec()] +108 frames.append(frame) +109 return {"frames": frames}, s, f +110 +111 def play(self, server, method="html", verbose=False): +112 """Play the video live in the notebook.""" +113 +114 spec, sources, filters = self._to_json_spec() +115 spec_json_bytes = json.dumps(spec).encode("utf-8") +116 spec_obj_json_gzip = gzip.compress(spec_json_bytes, compresslevel=1) +117 spec_obj_json_gzip_b64 = base64.b64encode(spec_obj_json_gzip).decode("utf-8") +118 +119 sources = [ +120 { +121 "name": s._name, +122 "path": s._path, +123 "stream": s._stream, +124 "service": s._service.as_json() if s._service is not None else None, +125 } +126 for s in sources +127 ] +128 filters = { +129 k: { +130 "filter": v._func, +131 "args": v._kwargs, +132 } +133 for k, v in filters.items() +134 } +135 arrays = [] +136 +137 if verbose: +138 print(f"Sending to server. Spec is {len(spec_obj_json_gzip_b64)} bytes") +139 +140 resp = server._new(spec_obj_json_gzip_b64, sources, filters, arrays, self._fmt) +141 hls_video_url = resp["stream_url"] +142 hls_player_url = resp["player_url"] +143 namespace = resp["namespace"] +144 hls_js_url = server.hls_js_url() +145 +146 if method == "link": +147 return hls_video_url +148 if method == "player": +149 return hls_player_url +150 if method == "iframe": +151 from IPython.display import IFrame +152 +153 return IFrame(hls_player_url, width=1280, height=720) +154 if method == "html": +155 from IPython.display import HTML +156 +157 # We add a namespace to the video element to avoid conflicts with other videos +158 html_code = f""" +159<!DOCTYPE html> +160<html> +161<head> +162 <title>HLS Video Player</title> +163 <!-- Include hls.js library --> +164 <script src="{hls_js_url}"></script> +165</head> +166<body> +167 <!-- Video element --> +168 <video id="video-{namespace}" controls width="640" height="360" autoplay></video> +169 <script> +170 var video = document.getElementById('video-{namespace}'); +171 var videoSrc = '{hls_video_url}'; +172 var hls = new Hls(); +173 hls.loadSource(videoSrc); +174 hls.attachMedia(video); +175 hls.on(Hls.Events.MANIFEST_PARSED, function() {{ +176 video.play(); +177 }}); +178 </script> +179</body> +180</html> +181""" +182 return HTML(data=html_code) +183 else: +184 return hls_player_url +185 +186 def load(self, server): +187 spec, sources, filters = self._to_json_spec() +188 spec_json_bytes = json.dumps(spec).encode("utf-8") +189 spec_obj_json_gzip = gzip.compress(spec_json_bytes, compresslevel=1) +190 spec_obj_json_gzip_b64 = base64.b64encode(spec_obj_json_gzip).decode("utf-8") +191 +192 sources = [ +193 { +194 "name": s._name, +195 "path": s._path, +196 "stream": s._stream, +197 "service": s._service.as_json() if s._service is not None else None, +198 } +199 for s in sources +200 ] +201 filters = { +202 k: { +203 "filter": v._func, +204 "args": v._kwargs, +205 } +206 for k, v in filters.items() +207 } +208 arrays = [] +209 +210 resp = server._new(spec_obj_json_gzip_b64, sources, filters, arrays, self._fmt) +211 namespace = resp["namespace"] +212 return Loader(server, namespace, self._domain) +213 +214 def save(self, server, pth, encoder=None, encoder_opts=None, format=None): +215 """Save the video to a file.""" +216 +217 assert encoder is None or type(encoder) == str +218 assert encoder_opts is None or type(encoder_opts) == dict +219 if encoder_opts is not None: +220 for k, v in encoder_opts.items(): +221 assert type(k) == str and type(v) == str +222 +223 spec, sources, filters = self._to_json_spec() +224 spec_json_bytes = json.dumps(spec).encode("utf-8") +225 spec_obj_json_gzip = gzip.compress(spec_json_bytes, compresslevel=1) +226 spec_obj_json_gzip_b64 = base64.b64encode(spec_obj_json_gzip).decode("utf-8") +227 +228 sources = [ +229 { +230 "name": s._name, +231 "path": s._path, +232 "stream": s._stream, +233 "service": s._service.as_json() if s._service is not None else None, +234 } +235 for s in sources +236 ] +237 filters = { +238 k: { +239 "filter": v._func, +240 "args": v._kwargs, +241 } +242 for k, v in filters.items() +243 } +244 arrays = [] +245 +246 resp = server._export( +247 pth, +248 spec_obj_json_gzip_b64, +249 sources, +250 filters, +251 arrays, +252 self._fmt, +253 encoder, +254 encoder_opts, +255 format, +256 ) +257 +258 return resp +259 +260 def _vrod_bench(self, server): +261 out = {} +262 pth = "spec.json" +263 start_t = time.time() +264 with open(pth, "w") as outfile: +265 spec, sources, filters = self._to_json_spec() +266 outfile.write(json.dumps(spec)) +267 +268 sources = [ +269 { +270 "name": s._name, +271 "path": s._path, +272 "stream": s._stream, +273 "service": s._service.as_json() if s._service is not None else None, +274 } +275 for s in sources +276 ] +277 filters = { +278 k: { +279 "filter": v._func, +280 "args": v._kwargs, +281 } +282 for k, v in filters.items() +283 } +284 arrays = [] +285 end_t = time.time() +286 out["vrod_create_spec"] = end_t - start_t +287 +288 start = time.time() +289 resp = server._new(pth, sources, filters, arrays, self._fmt) +290 end = time.time() +291 out["vrod_register"] = end - start +292 +293 stream_url = resp["stream_url"] +294 first_segment = stream_url.replace("stream.m3u8", "segment-0.ts") +295 +296 start = time.time() +297 r = requests.get(first_segment) +298 r.raise_for_status() +299 end = time.time() +300 out["vrod_first_segment"] = end - start +301 return out +302 +303 def _dve2_bench(self, server): +304 pth = "spec.json" +305 out = {} +306 start_t = time.time() +307 with open(pth, "w") as outfile: +308 spec, sources, filters = self._to_json_spec() +309 outfile.write(json.dumps(spec)) +310 +311 sources = [ +312 { +313 "name": s._name, +314 "path": s._path, +315 "stream": s._stream, +316 "service": s._service.as_json() if s._service is not None else None, +317 } +318 for s in sources +319 ] +320 filters = { +321 k: { +322 "filter": v._func, +323 "args": v._kwargs, +324 } +325 for k, v in filters.items() +326 } +327 arrays = [] +328 end_t = time.time() +329 out["dve2_create_spec"] = end_t - start_t +330 +331 start = time.time() +332 resp = server._export(pth, sources, filters, arrays, self._fmt, None, None) +333 end = time.time() +334 out["dve2_exec"] = end - start +335 return out +
A video transformation specification.
+ +See https://ixlab.github.io/vidformer/concepts.html for more information.
+
+
+
+
+
+
+
+
+
+
+
+ def
+ play(self, server, method='html', verbose=False):
+
+
+
+
+
+ 111 def play(self, server, method="html", verbose=False): +112 """Play the video live in the notebook.""" +113 +114 spec, sources, filters = self._to_json_spec() +115 spec_json_bytes = json.dumps(spec).encode("utf-8") +116 spec_obj_json_gzip = gzip.compress(spec_json_bytes, compresslevel=1) +117 spec_obj_json_gzip_b64 = base64.b64encode(spec_obj_json_gzip).decode("utf-8") +118 +119 sources = [ +120 { +121 "name": s._name, +122 "path": s._path, +123 "stream": s._stream, +124 "service": s._service.as_json() if s._service is not None else None, +125 } +126 for s in sources +127 ] +128 filters = { +129 k: { +130 "filter": v._func, +131 "args": v._kwargs, +132 } +133 for k, v in filters.items() +134 } +135 arrays = [] +136 +137 if verbose: +138 print(f"Sending to server. Spec is {len(spec_obj_json_gzip_b64)} bytes") +139 +140 resp = server._new(spec_obj_json_gzip_b64, sources, filters, arrays, self._fmt) +141 hls_video_url = resp["stream_url"] +142 hls_player_url = resp["player_url"] +143 namespace = resp["namespace"] +144 hls_js_url = server.hls_js_url() +145 +146 if method == "link": +147 return hls_video_url +148 if method == "player": +149 return hls_player_url +150 if method == "iframe": +151 from IPython.display import IFrame +152 +153 return IFrame(hls_player_url, width=1280, height=720) +154 if method == "html": +155 from IPython.display import HTML +156 +157 # We add a namespace to the video element to avoid conflicts with other videos +158 html_code = f""" +159<!DOCTYPE html> +160<html> +161<head> +162 <title>HLS Video Player</title> +163 <!-- Include hls.js library --> +164 <script src="{hls_js_url}"></script> +165</head> +166<body> +167 <!-- Video element --> +168 <video id="video-{namespace}" controls width="640" height="360" autoplay></video> +169 <script> +170 var video = document.getElementById('video-{namespace}'); +171 var videoSrc = '{hls_video_url}'; +172 var hls = new Hls(); +173 hls.loadSource(videoSrc); +174 hls.attachMedia(video); +175 hls.on(Hls.Events.MANIFEST_PARSED, function() {{ +176 video.play(); +177 }}); +178 </script> +179</body> +180</html> +181""" +182 return HTML(data=html_code) +183 else: +184 return hls_player_url +
Play the video live in the notebook.
+
+
+
+
+
+
+
+
+
+
+ def
+ load(self, server):
+
+
+
+
+
+ 186 def load(self, server): +187 spec, sources, filters = self._to_json_spec() +188 spec_json_bytes = json.dumps(spec).encode("utf-8") +189 spec_obj_json_gzip = gzip.compress(spec_json_bytes, compresslevel=1) +190 spec_obj_json_gzip_b64 = base64.b64encode(spec_obj_json_gzip).decode("utf-8") +191 +192 sources = [ +193 { +194 "name": s._name, +195 "path": s._path, +196 "stream": s._stream, +197 "service": s._service.as_json() if s._service is not None else None, +198 } +199 for s in sources +200 ] +201 filters = { +202 k: { +203 "filter": v._func, +204 "args": v._kwargs, +205 } +206 for k, v in filters.items() +207 } +208 arrays = [] +209 +210 resp = server._new(spec_obj_json_gzip_b64, sources, filters, arrays, self._fmt) +211 namespace = resp["namespace"] +212 return Loader(server, namespace, self._domain) +
+
+
+
+
+
+
+
+
+
+
+ def
+ save(self, server, pth, encoder=None, encoder_opts=None, format=None):
+
+
+
+
+
+ 214 def save(self, server, pth, encoder=None, encoder_opts=None, format=None): +215 """Save the video to a file.""" +216 +217 assert encoder is None or type(encoder) == str +218 assert encoder_opts is None or type(encoder_opts) == dict +219 if encoder_opts is not None: +220 for k, v in encoder_opts.items(): +221 assert type(k) == str and type(v) == str +222 +223 spec, sources, filters = self._to_json_spec() +224 spec_json_bytes = json.dumps(spec).encode("utf-8") +225 spec_obj_json_gzip = gzip.compress(spec_json_bytes, compresslevel=1) +226 spec_obj_json_gzip_b64 = base64.b64encode(spec_obj_json_gzip).decode("utf-8") +227 +228 sources = [ +229 { +230 "name": s._name, +231 "path": s._path, +232 "stream": s._stream, +233 "service": s._service.as_json() if s._service is not None else None, +234 } +235 for s in sources +236 ] +237 filters = { +238 k: { +239 "filter": v._func, +240 "args": v._kwargs, +241 } +242 for k, v in filters.items() +243 } +244 arrays = [] +245 +246 resp = server._export( +247 pth, +248 spec_obj_json_gzip_b64, +249 sources, +250 filters, +251 arrays, +252 self._fmt, +253 encoder, +254 encoder_opts, +255 format, +256 ) +257 +258 return resp +
Save the video to a file.
+
+
+ class
+ Loader:
+
+
+
+
+
+ 338class Loader: +339 def __init__(self, server, namespace: str, domain): +340 self._server = server +341 self._namespace = namespace +342 self._domain = domain +343 +344 def _chunk(self, start_i, end_i): +345 return self._server._raw(self._namespace, start_i, end_i) +346 +347 def __len__(self): +348 return len(self._domain) +349 +350 def _find_index_by_rational(self, value): +351 if value not in self._domain: +352 raise ValueError(f"Rational timestamp {value} is not in the domain") +353 return self._domain.index(value) +354 +355 def __getitem__(self, index): +356 if isinstance(index, slice): +357 start = index.start if index.start is not None else 0 +358 end = index.stop if index.stop is not None else len(self._domain) +359 assert start >= 0 and start < len(self._domain) +360 assert end >= 0 and end <= len(self._domain) +361 assert start <= end +362 num_frames = end - start +363 all_bytes = self._chunk(start, end - 1) +364 all_bytes_len = len(all_bytes) +365 assert all_bytes_len % num_frames == 0 +366 return [ +367 all_bytes[ +368 i +369 * all_bytes_len +370 // num_frames : (i + 1) +371 * all_bytes_len +372 // num_frames +373 ] +374 for i in range(num_frames) +375 ] +376 elif isinstance(index, int): +377 assert index >= 0 and index < len(self._domain) +378 return self._chunk(index, index) +379 else: +380 raise TypeError( +381 "Invalid argument type for iloc. Use a slice or an integer." +382 ) +
+
+ class
+ YrdenServer:
+
+
+
+
+
+ 385class YrdenServer: +386 """ +387 A connection to a Yrden server. +388 +389 A yrden server is the main API for local use of vidformer. +390 """ +391 +392 def __init__(self, domain=None, port=None, bin=None, hls_prefix=None): +393 """ +394 Connect to a Yrden server +395 +396 Can either connect to an existing server, if domain and port are provided, or start a new server using the provided binary. +397 If no domain or binary is provided, the `VIDFORMER_BIN` environment variable is used. +398 """ +399 +400 self._domain = domain +401 self._port = port +402 self._proc = None +403 if self._port is None: +404 if bin is None: +405 if os.getenv("VIDFORMER_BIN") is not None: +406 bin = os.getenv("VIDFORMER_BIN") +407 else: +408 bin = "vidformer-cli" +409 +410 self._domain = "localhost" +411 self._port = random.randint(49152, 65535) +412 cmd = [bin, "yrden", "--port", str(self._port)] +413 if _in_notebook: +414 # We need to print the URL in the notebook +415 # This is a trick to get VS Code to forward the port +416 cmd += ["--print-url"] +417 +418 if hls_prefix is not None: +419 if not type(hls_prefix) == str: +420 raise Exception("hls_prefix must be a string") +421 cmd += ["--hls-prefix", hls_prefix] +422 +423 self._proc = subprocess.Popen(cmd) +424 +425 version = _check_hls_link_exists(f"http://{self._domain}:{self._port}/") +426 if version is None: +427 raise Exception("Failed to connect to server") +428 +429 expected_version = f"vidformer-yrden v{__version__}" +430 if version != expected_version: +431 print( +432 f"Warning: Expected version `{expected_version}`, got `{version}`. API may not be compatible!" +433 ) +434 +435 def _source(self, name: str, path: str, stream: int, service): +436 r = requests.post( +437 f"http://{self._domain}:{self._port}/source", +438 json={ +439 "name": name, +440 "path": path, +441 "stream": stream, +442 "service": service.as_json() if service is not None else None, +443 }, +444 ) +445 if not r.ok: +446 raise Exception(r.text) +447 +448 resp = r.json() +449 resp["ts"] = [Fraction(x[0], x[1]) for x in resp["ts"]] +450 return resp +451 +452 def _new(self, spec, sources, filters, arrays, fmt): +453 req = { +454 "spec": spec, +455 "sources": sources, +456 "filters": filters, +457 "arrays": arrays, +458 "width": fmt["width"], +459 "height": fmt["height"], +460 "pix_fmt": fmt["pix_fmt"], +461 } +462 +463 r = requests.post(f"http://{self._domain}:{self._port}/new", json=req) +464 if not r.ok: +465 raise Exception(r.text) +466 +467 return r.json() +468 +469 def _export( +470 self, pth, spec, sources, filters, arrays, fmt, encoder, encoder_opts, format +471 ): +472 req = { +473 "spec": spec, +474 "sources": sources, +475 "filters": filters, +476 "arrays": arrays, +477 "width": fmt["width"], +478 "height": fmt["height"], +479 "pix_fmt": fmt["pix_fmt"], +480 "output_path": pth, +481 "encoder": encoder, +482 "encoder_opts": encoder_opts, +483 "format": format, +484 } +485 +486 r = requests.post(f"http://{self._domain}:{self._port}/export", json=req) +487 if not r.ok: +488 raise Exception(r.text) +489 +490 return r.json() +491 +492 def _raw(self, namespace, start_i, end_i): +493 r = requests.get( +494 f"http://{self._domain}:{self._port}/{namespace}/raw/{start_i}-{end_i}" +495 ) +496 if not r.ok: +497 raise Exception(r.text) +498 return r.content +499 +500 def hls_js_url(self): +501 """Return the link to the yrden-hosted hls.js file""" +502 return f"http://{self._domain}:{self._port}/hls.js" +503 +504 def __del__(self): +505 if self._proc is not None: +506 self._proc.kill() +
A connection to a Yrden server.
+ +A yrden server is the main API for local use of vidformer.
+
+
+
+
+
+
+
+
+
+
+
+
+ YrdenServer(domain=None, port=None, bin=None, hls_prefix=None)
+
+
+
+
+
+ 392 def __init__(self, domain=None, port=None, bin=None, hls_prefix=None): +393 """ +394 Connect to a Yrden server +395 +396 Can either connect to an existing server, if domain and port are provided, or start a new server using the provided binary. +397 If no domain or binary is provided, the `VIDFORMER_BIN` environment variable is used. +398 """ +399 +400 self._domain = domain +401 self._port = port +402 self._proc = None +403 if self._port is None: +404 if bin is None: +405 if os.getenv("VIDFORMER_BIN") is not None: +406 bin = os.getenv("VIDFORMER_BIN") +407 else: +408 bin = "vidformer-cli" +409 +410 self._domain = "localhost" +411 self._port = random.randint(49152, 65535) +412 cmd = [bin, "yrden", "--port", str(self._port)] +413 if _in_notebook: +414 # We need to print the URL in the notebook +415 # This is a trick to get VS Code to forward the port +416 cmd += ["--print-url"] +417 +418 if hls_prefix is not None: +419 if not type(hls_prefix) == str: +420 raise Exception("hls_prefix must be a string") +421 cmd += ["--hls-prefix", hls_prefix] +422 +423 self._proc = subprocess.Popen(cmd) +424 +425 version = _check_hls_link_exists(f"http://{self._domain}:{self._port}/") +426 if version is None: +427 raise Exception("Failed to connect to server") +428 +429 expected_version = f"vidformer-yrden v{__version__}" +430 if version != expected_version: +431 print( +432 f"Warning: Expected version `{expected_version}`, got `{version}`. API may not be compatible!" +433 ) +
Connect to a Yrden server
+ +Can either connect to an existing server, if domain and port are provided, or start a new server using the provided binary.
+If no domain or binary is provided, the VIDFORMER_BIN environment variable is used.
+
+ class
+ SourceExpr:
+
+
+
+
+
+ 509class SourceExpr: +510 def __init__(self, source, idx, is_iloc): +511 self._source = source +512 self._idx = idx +513 self._is_iloc = is_iloc +514 +515 def __repr__(self): +516 if self._is_iloc: +517 return f"{self._source._name}.iloc[{self._idx}]" +518 else: +519 return f"{self._source._name}[{self._idx}]" +520 +521 def _to_json_spec(self): +522 if self._is_iloc: +523 return { +524 "Source": { +525 "video": self._source._name, +526 "index": {"ILoc": int(self._idx)}, +527 } +528 } +529 else: +530 return { +531 "Source": { +532 "video": self._source._name, +533 "index": {"T": [self._idx.numerator, self._idx.denominator]}, +534 } +535 } +536 +537 def _sources(self): +538 return set([self._source]) +539 +540 def _filters(self): +541 return {} +
+
+ class
+ SourceILoc:
+
+
+
+
+
+
+
+
+
+
+
+
+
+ class
+ Source:
+
+
+
+
+
+ 554class Source: +555 """A video source.""" +556 +557 def __init__( +558 self, server: YrdenServer, name: str, path: str, stream: int, service=None +559 ): +560 if service is None: +561 # check if path is a http URL and, if so, automatically set the service +562 # for example, the following code should work with just vf.Source(server, "tos_720p", "https://f.dominik.win/data/dve2/tos_720p.mp4") +563 # this creates a storage service with endpoint "https://f.dominik.win/" and path "data/dve2/tos_720p.mp4" +564 # don't use the root parameter in this case +565 +566 match = re.match(r"(http|https)://([^/]+)(.*)", path) +567 if match is not None: +568 endpoint = f"{match.group(1)}://{match.group(2)}" +569 path = match.group(3) +570 # remove leading slash +571 if path.startswith("/"): +572 path = path[1:] +573 service = StorageService("http", endpoint=endpoint) +574 +575 self._server = server +576 self._name = name +577 self._path = path +578 self._stream = stream +579 self._service = service +580 +581 self.iloc = SourceILoc(self) +582 +583 self._src = self._server._source( +584 self._name, self._path, self._stream, self._service +585 ) +586 +587 def fmt(self): +588 return { +589 "width": self._src["width"], +590 "height": self._src["height"], +591 "pix_fmt": self._src["pix_fmt"], +592 } +593 +594 def ts(self): +595 return self._src["ts"] +596 +597 def __len__(self): +598 return len(self._src["ts"]) +599 +600 def __getitem__(self, idx): +601 if type(idx) != Fraction: +602 raise Exception("Source index must be a Fraction") +603 return SourceExpr(self, idx, False) +604 +605 def play(self, *args, **kwargs): +606 """Play the video live in the notebook.""" +607 +608 domain = self.ts() +609 render = lambda t, i: self[t] +610 spec = Spec(domain, render, self.fmt()) +611 return spec.play(*args, **kwargs) +
A video source.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Source( server: YrdenServer, name: str, path: str, stream: int, service=None)
+
+
+
+
+
+ 557 def __init__( +558 self, server: YrdenServer, name: str, path: str, stream: int, service=None +559 ): +560 if service is None: +561 # check if path is a http URL and, if so, automatically set the service +562 # for example, the following code should work with just vf.Source(server, "tos_720p", "https://f.dominik.win/data/dve2/tos_720p.mp4") +563 # this creates a storage service with endpoint "https://f.dominik.win/" and path "data/dve2/tos_720p.mp4" +564 # don't use the root parameter in this case +565 +566 match = re.match(r"(http|https)://([^/]+)(.*)", path) +567 if match is not None: +568 endpoint = f"{match.group(1)}://{match.group(2)}" +569 path = match.group(3) +570 # remove leading slash +571 if path.startswith("/"): +572 path = path[1:] +573 service = StorageService("http", endpoint=endpoint) +574 +575 self._server = server +576 self._name = name +577 self._path = path +578 self._stream = stream +579 self._service = service +580 +581 self.iloc = SourceILoc(self) +582 +583 self._src = self._server._source( +584 self._name, self._path, self._stream, self._service +585 ) +
+
+
+
+
+
+
+
+
+
+
+ def
+ play(self, *args, **kwargs):
+
+
+
+
+
+ 605 def play(self, *args, **kwargs): +606 """Play the video live in the notebook.""" +607 +608 domain = self.ts() +609 render = lambda t, i: self[t] +610 spec = Spec(domain, render, self.fmt()) +611 return spec.play(*args, **kwargs) +
Play the video live in the notebook.
+
+
+ class
+ StorageService:
+
+
+
+
+
+ 614class StorageService: +615 def __init__(self, service: str, **kwargs): +616 if type(service) != str: +617 raise Exception("Service name must be a string") +618 self._service = service +619 for k, v in kwargs.items(): +620 if type(v) != str: +621 raise Exception(f"Value of {k} must be a string") +622 self._config = kwargs +623 +624 def as_json(self): +625 return {"service": self._service, "config": self._config} +626 +627 def __repr__(self): +628 return f"{self._service}(config={self._config})" +
+
+
+
+
+
+
+
+
+
+
+ StorageService(service: str, **kwargs)
+
+
+
+
+
+ 615 def __init__(self, service: str, **kwargs): +616 if type(service) != str: +617 raise Exception("Service name must be a string") +618 self._service = service +619 for k, v in kwargs.items(): +620 if type(v) != str: +621 raise Exception(f"Value of {k} must be a string") +622 self._config = kwargs +
+
+ class
+ Filter:
+
+
+
+
+
+ 663class Filter: +664 """A video filter.""" +665 +666 def __init__(self, name: str, tl_func=None, **kwargs): +667 self._name = name +668 +669 # tl_func is the top level func, which is the true implementation, not just a pretty name +670 if tl_func is None: +671 self._func = name +672 else: +673 self._func = tl_func +674 +675 # filter infra args, not invocation args +676 for k, v in kwargs.items(): +677 if type(v) != str: +678 raise Exception(f"Value of {k} must be a string") +679 self._kwargs = kwargs +680 +681 def __call__(self, *args, **kwargs): +682 return FilterExpr(self, args, kwargs) +
A video filter.
+
+
+
+
+
+
+
+
+
+
+ Filter(name: str, tl_func=None, **kwargs)
+
+
+
+
+
+ 666 def __init__(self, name: str, tl_func=None, **kwargs): +667 self._name = name +668 +669 # tl_func is the top level func, which is the true implementation, not just a pretty name +670 if tl_func is None: +671 self._func = name +672 else: +673 self._func = tl_func +674 +675 # filter infra args, not invocation args +676 for k, v in kwargs.items(): +677 if type(v) != str: +678 raise Exception(f"Value of {k} must be a string") +679 self._kwargs = kwargs +
+
+ class
+ FilterExpr:
+
+
+
+
+
+ 685class FilterExpr: +686 def __init__(self, filter: Filter, args, kwargs): +687 self._filter = filter +688 self._args = args +689 self._kwargs = kwargs +690 +691 def __repr__(self): +692 args = [] +693 for arg in self._args: +694 val = f'"{arg}"' if type(arg) == str else str(arg) +695 args.append(str(val)) +696 for k, v in self._kwargs.items(): +697 val = f'"{v}"' if type(v) == str else str(v) +698 args.append(f"{k}={val}") +699 return f"{self._filter._name}({', '.join(args)})" +700 +701 def _to_json_spec(self): +702 args = [] +703 for arg in self._args: +704 args.append(_json_arg(arg)) +705 kwargs = {} +706 for k, v in self._kwargs.items(): +707 kwargs[k] = _json_arg(v) +708 return {"Filter": {"name": self._filter._name, "args": args, "kwargs": kwargs}} +709 +710 def _sources(self): +711 s = set() +712 for arg in self._args: +713 if type(arg) == FilterExpr or type(arg) == SourceExpr: +714 s = s.union(arg._sources()) +715 for arg in self._kwargs.values(): +716 if type(arg) == FilterExpr or type(arg) == SourceExpr: +717 s = s.union(arg._sources()) +718 return s +719 +720 def _filters(self): +721 f = {self._filter._name: self._filter} +722 for arg in self._args: +723 if type(arg) == FilterExpr: +724 f = {**f, **arg._filters()} +725 for arg in self._kwargs.values(): +726 if type(arg) == FilterExpr: +727 f = {**f, **arg._filters()} +728 return f +
+
+ class
+ UDF:
+
+
+
+
+
+ 731class UDF: +732 """User-defined filter superclass""" +733 +734 def __init__(self, name: str): +735 self._name = name +736 self._socket_path = None +737 self._p = None +738 +739 def filter(self, *args, **kwargs): +740 raise Exception("User must implement the filter method") +741 +742 def filter_type(self, *args, **kwargs): +743 raise Exception("User must implement the filter_type method") +744 +745 def into_filter(self): +746 assert self._socket_path is None +747 self._socket_path = f"/tmp/vidformer-{self._name}-{str(uuid.uuid4())}.sock" +748 self._p = multiprocessing.Process( +749 target=_run_udf_host, args=(self, self._socket_path) +750 ) +751 self._p.start() +752 return Filter( +753 name=self._name, tl_func="IPC", socket=self._socket_path, func=self._name +754 ) +755 +756 def _handle_connection(self, connection): +757 try: +758 while True: +759 frame_len = connection.recv(4) +760 if not frame_len or len(frame_len) != 4: +761 break +762 frame_len = int.from_bytes(frame_len, byteorder="big") +763 data = connection.recv(frame_len) +764 if not data: +765 break +766 +767 while len(data) < frame_len: +768 new_data = connection.recv(frame_len - len(data)) +769 if not new_data: +770 raise Exception("Partial data received") +771 data += new_data +772 +773 obj = msgpack.unpackb(data, raw=False) +774 f_func, f_op, f_args, f_kwargs = ( +775 obj["func"], +776 obj["op"], +777 obj["args"], +778 obj["kwargs"], +779 ) +780 +781 response = None +782 if f_op == "filter": +783 f_args = [self._deser_filter(x) for x in f_args] +784 f_kwargs = {k: self._deser_filter(v) for k, v in f_kwargs} +785 response = self.filter(*f_args, **f_kwargs) +786 if type(response) != UDFFrame: +787 raise Exception( +788 f"filter must return a UDFFrame, got {type(response)}" +789 ) +790 if response.frame_type().pix_fmt() != "rgb24": +791 raise Exception( +792 f"filter must return a frame with pix_fmt 'rgb24', got {response.frame_type().pix_fmt()}" +793 ) +794 +795 response = response._response_ser() +796 elif f_op == "filter_type": +797 f_args = [self._deser_filter_type(x) for x in f_args] +798 f_kwargs = {k: self._deser_filter_type(v) for k, v in f_kwargs} +799 response = self.filter_type(*f_args, **f_kwargs) +800 if type(response) != UDFFrameType: +801 raise Exception( +802 f"filter_type must return a UDFFrameType, got {type(response)}" +803 ) +804 if response.pix_fmt() != "rgb24": +805 raise Exception( +806 f"filter_type must return a frame with pix_fmt 'rgb24', got {response.pix_fmt()}" +807 ) +808 response = response._response_ser() +809 else: +810 raise Exception(f"Unknown operation: {f_op}") +811 +812 response = msgpack.packb(response, use_bin_type=True) +813 response_len = len(response).to_bytes(4, byteorder="big") +814 connection.sendall(response_len) +815 connection.sendall(response) +816 finally: +817 connection.close() +818 +819 def _deser_filter_type(self, obj): +820 assert type(obj) == dict +821 keys = list(obj.keys()) +822 assert len(keys) == 1 +823 type_key = keys[0] +824 assert type_key in ["FrameType", "String", "Int", "Bool"] +825 +826 if type_key == "FrameType": +827 frame = obj[type_key] +828 assert type(frame) == dict +829 assert "width" in frame +830 assert "height" in frame +831 assert "format" in frame +832 assert type(frame["width"]) == int +833 assert type(frame["height"]) == int +834 assert frame["format"] == 2 # AV_PIX_FMT_RGB24 +835 return UDFFrameType(frame["width"], frame["height"], "rgb24") +836 elif type_key == "String": +837 assert type(obj[type_key]) == str +838 return obj[type_key] +839 elif type_key == "Int": +840 assert type(obj[type_key]) == int +841 return obj[type_key] +842 elif type_key == "Bool": +843 assert type(obj[type_key]) == bool +844 return obj[type_key] +845 else: +846 assert False, f"Unknown type: {type_key}" +847 +848 def _deser_filter(self, obj): +849 assert type(obj) == dict +850 keys = list(obj.keys()) +851 assert len(keys) == 1 +852 type_key = keys[0] +853 assert type_key in ["Frame", "String", "Int", "Bool"] +854 +855 if type_key == "Frame": +856 frame = obj[type_key] +857 assert type(frame) == dict +858 assert "data" in frame +859 assert "width" in frame +860 assert "height" in frame +861 assert "format" in frame +862 assert type(frame["width"]) == int +863 assert type(frame["height"]) == int +864 assert frame["format"] == "rgb24" +865 assert type(frame["data"]) == bytes +866 +867 data = np.frombuffer(frame["data"], dtype=np.uint8) +868 data = data.reshape(frame["height"], frame["width"], 3) +869 return UDFFrame( +870 data, UDFFrameType(frame["width"], frame["height"], "rgb24") +871 ) +872 elif type_key == "String": +873 assert type(obj[type_key]) == str +874 return obj[type_key] +875 elif type_key == "Int": +876 assert type(obj[type_key]) == int +877 return obj[type_key] +878 elif type_key == "Bool": +879 assert type(obj[type_key]) == bool +880 return obj[type_key] +881 else: +882 assert False, f"Unknown type: {type_key}" +883 +884 def _host(self, socket_path: str): +885 if os.path.exists(socket_path): +886 os.remove(socket_path) +887 +888 # start listening on the socket +889 sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) +890 sock.bind(socket_path) +891 sock.listen(1) +892 +893 while True: +894 # accept incoming connection +895 connection, client_address = sock.accept() +896 thread = threading.Thread( +897 target=self._handle_connection, args=(connection,) +898 ) +899 thread.start() +900 +901 def __del__(self): +902 if self._socket_path is not None: +903 self._p.terminate() +904 if os.path.exists(self._socket_path): +905 # it's possible the process hasn't even created the socket yet +906 os.remove(self._socket_path) +
User-defined filter superclass
+
+
+
+
+
+
+
+
+
+
+ def
+ into_filter(self):
+
+
+
+
+
+ 745 def into_filter(self): +746 assert self._socket_path is None +747 self._socket_path = f"/tmp/vidformer-{self._name}-{str(uuid.uuid4())}.sock" +748 self._p = multiprocessing.Process( +749 target=_run_udf_host, args=(self, self._socket_path) +750 ) +751 self._p.start() +752 return Filter( +753 name=self._name, tl_func="IPC", socket=self._socket_path, func=self._name +754 ) +
+
+ class
+ UDFFrameType:
+
+
+
+
+
+ 909class UDFFrameType: +910 """ +911 Frame type for use in UDFs. +912 """ +913 +914 def __init__(self, width: int, height: int, pix_fmt: str): +915 assert type(width) == int +916 assert type(height) == int +917 assert type(pix_fmt) == str +918 +919 self._width = width +920 self._height = height +921 self._pix_fmt = pix_fmt +922 +923 def width(self): +924 return self._width +925 +926 def height(self): +927 return self._height +928 +929 def pix_fmt(self): +930 return self._pix_fmt +931 +932 def _response_ser(self): +933 return { +934 "frame_type": { +935 "width": self._width, +936 "height": self._height, +937 "format": 2, # AV_PIX_FMT_RGB24 +938 } +939 } +940 +941 def __repr__(self): +942 return f"FrameType<{self._width}x{self._height}, {self._pix_fmt}>" +
Frame type for use in UDFs.
+
+
+ class
+ UDFFrame:
+
+
+
+
+
+ 945class UDFFrame: +946 """A symbolic reference to a frame for use in UDFs.""" +947 +948 def __init__(self, data: np.ndarray, f_type: UDFFrameType): +949 assert type(data) == np.ndarray +950 assert type(f_type) == UDFFrameType +951 +952 # We only support RGB24 for now +953 assert data.dtype == np.uint8 +954 assert data.shape[2] == 3 +955 +956 # check type matches +957 assert data.shape[0] == f_type.height() +958 assert data.shape[1] == f_type.width() +959 assert f_type.pix_fmt() == "rgb24" +960 +961 self._data = data +962 self._f_type = f_type +963 +964 def data(self): +965 return self._data +966 +967 def frame_type(self): +968 return self._f_type +969 +970 def _response_ser(self): +971 return { +972 "frame": { +973 "data": self._data.tobytes(), +974 "width": self._f_type.width(), +975 "height": self._f_type.height(), +976 "format": "rgb24", +977 } +978 } +979 +980 def __repr__(self): +981 return f"Frame<{self._f_type.width()}x{self._f_type.height()}, {self._f_type.pix_fmt()}>" +
A symbolic reference to a frame for use in UDFs.
+
+
+
+
+
+
+
+
+
+
+
+
+ UDFFrame(data: numpy.ndarray, f_type: UDFFrameType)
+
+
+
+
+
+ 948 def __init__(self, data: np.ndarray, f_type: UDFFrameType): +949 assert type(data) == np.ndarray +950 assert type(f_type) == UDFFrameType +951 +952 # We only support RGB24 for now +953 assert data.dtype == np.uint8 +954 assert data.shape[2] == 3 +955 +956 # check type matches +957 assert data.shape[0] == f_type.height() +958 assert data.shape[1] == f_type.width() +959 assert f_type.pix_fmt() == "rgb24" +960 +961 self._data = data +962 self._f_type = f_type +
List of all items
Structs
- CodecDescriptor
- Config
- Context
- EncoderConfig
- Range
- Stats
- array::JsonArary
- filter::Frame
- filter::FrameType
- filter::builtin::Annotate
- filter::builtin::BoundingBox
- filter::builtin::BoundingBoxBound
- filter::builtin::Box
- filter::builtin::DrawBox
- filter::builtin::DrawText
- filter::builtin::HStack
- filter::builtin::IPC
- filter::builtin::InlineMat
- filter::builtin::Pad
- filter::builtin::PlaceholderFrame
- filter::builtin::Scale
- filter::builtin::SliceMat
- filter::builtin::SliceWriteMat
- filter::builtin::VStack
- filter::cv2::AddWeighted
- filter::cv2::ArrowedLine
- filter::cv2::Circle
- filter::cv2::Line
- filter::cv2::PutText
- filter::cv2::Rectangle
- filter::cv2::SetTo
- service::Service
- sir::FilterExpr
- sir::FrameSource
- source::SourceFileMeta
- source::SourceVideoStreamMeta
- spec::JsonSpec
Enums
Traits
Functions
Expand description
Arrays provide access to data.
+Arrays store conventional data (e.g. numbers, strings) and can be referenced by specs. +As with the rest of the vidformer data model, arrays are duel-indexed by a timestamp or a position. +Arrays can be backed by a variety of sources, such as a JSON file or a database.
+Structs§
- An array backed by a JSON file
Traits§
- A trait for an array
pub struct JsonArary { /* private fields */ }Expand description
An array backed by a JSON file
+Trait Implementations§
source§impl<'de> Deserialize<'de> for JsonArary
impl<'de> Deserialize<'de> for JsonArary
source§fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
Auto Trait Implementations§
impl Freeze for JsonArary
impl RefUnwindSafe for JsonArary
impl Send for JsonArary
impl Sync for JsonArary
impl Unpin for JsonArary
impl UnwindSafe for JsonArary
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> DeserializeOwned for Twhere
+ T: for<'de> Deserialize<'de>,
impl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub trait Array: Sync + Send {
+ // Required methods
+ fn domain(&self) -> Vec<Rational64>;
+ fn index(&self, idx: usize) -> DataExpr;
+ fn index_t(&self, idx: Rational64) -> DataExpr;
+}Expand description
A trait for an array
+Required Methods§
sourcefn domain(&self) -> Vec<Rational64>
fn domain(&self) -> Vec<Rational64>
Returns the domain of the array.
+The domain is the set of times at which the array is defined. +Each time corresponds to a single output value at that timestamp.
+The output must:
+-
+
- Be sorted in ascending order +
- Contain no duplicate values +
- Begin with 0 +
sourcefn index_t(&self, idx: Rational64) -> DataExpr
fn index_t(&self, idx: Rational64) -> DataExpr
Returns the value at a given time index.
+Implementors§
Redirecting to ../../vidformer/enum.Error.html...
+ + + \ No newline at end of file diff --git a/vidformer/dve/enum.RangeTsFormat.html b/vidformer/dve/enum.RangeTsFormat.html new file mode 100644 index 0000000..4a91491 --- /dev/null +++ b/vidformer/dve/enum.RangeTsFormat.html @@ -0,0 +1,11 @@ + + + + +Redirecting to ../../vidformer/enum.RangeTsFormat.html...
+ + + \ No newline at end of file diff --git a/vidformer/dve/fn.create_spec_hls.html b/vidformer/dve/fn.create_spec_hls.html new file mode 100644 index 0000000..b95240a --- /dev/null +++ b/vidformer/dve/fn.create_spec_hls.html @@ -0,0 +1,11 @@ + + + + +Redirecting to ../../vidformer/fn.create_spec_hls.html...
+ + + \ No newline at end of file diff --git a/vidformer/dve/fn.run.html b/vidformer/dve/fn.run.html new file mode 100644 index 0000000..a9d0161 --- /dev/null +++ b/vidformer/dve/fn.run.html @@ -0,0 +1,11 @@ + + + + +Redirecting to ../../vidformer/fn.run.html...
+ + + \ No newline at end of file diff --git a/vidformer/dve/fn.validate.html b/vidformer/dve/fn.validate.html new file mode 100644 index 0000000..19435e4 --- /dev/null +++ b/vidformer/dve/fn.validate.html @@ -0,0 +1,11 @@ + + + + +Redirecting to ../../vidformer/fn.validate.html...
+ + + \ No newline at end of file diff --git a/vidformer/dve/struct.Config.html b/vidformer/dve/struct.Config.html new file mode 100644 index 0000000..6e0d8c4 --- /dev/null +++ b/vidformer/dve/struct.Config.html @@ -0,0 +1,11 @@ + + + + +Redirecting to ../../vidformer/struct.Config.html...
+ + + \ No newline at end of file diff --git a/vidformer/dve/struct.Context.html b/vidformer/dve/struct.Context.html new file mode 100644 index 0000000..ac1c2d4 --- /dev/null +++ b/vidformer/dve/struct.Context.html @@ -0,0 +1,11 @@ + + + + +Redirecting to ../../vidformer/struct.Context.html...
+ + + \ No newline at end of file diff --git a/vidformer/dve/struct.EncoderConfig.html b/vidformer/dve/struct.EncoderConfig.html new file mode 100644 index 0000000..d242aec --- /dev/null +++ b/vidformer/dve/struct.EncoderConfig.html @@ -0,0 +1,11 @@ + + + + +Redirecting to ../../vidformer/struct.EncoderConfig.html...
+ + + \ No newline at end of file diff --git a/vidformer/dve/struct.Range.html b/vidformer/dve/struct.Range.html new file mode 100644 index 0000000..1a481e8 --- /dev/null +++ b/vidformer/dve/struct.Range.html @@ -0,0 +1,11 @@ + + + + +Redirecting to ../../vidformer/struct.Range.html...
+ + + \ No newline at end of file diff --git a/vidformer/dve/struct.Stats.html b/vidformer/dve/struct.Stats.html new file mode 100644 index 0000000..d48dc6a --- /dev/null +++ b/vidformer/dve/struct.Stats.html @@ -0,0 +1,11 @@ + + + + +Redirecting to ../../vidformer/struct.Stats.html...
+ + + \ No newline at end of file diff --git a/vidformer/enum.Error.html b/vidformer/enum.Error.html new file mode 100644 index 0000000..597fbfb --- /dev/null +++ b/vidformer/enum.Error.html @@ -0,0 +1,32 @@ +pub enum Error {
+ SourceNotFound(String),
+ IndexOutOfBounds(String, IndexConst),
+ MissingFilterArg,
+ InvalidFilterArgType(String, String, String),
+ InvalidFilterArgValue(String, String),
+ FilterInternalError(String),
+ InvalidOutputFrameType,
+ ConfigError(String),
+ AVError(String),
+ IOError(String),
+ Unknown(String),
+}Variants§
SourceNotFound(String)
IndexOutOfBounds(String, IndexConst)
MissingFilterArg
InvalidFilterArgType(String, String, String)
InvalidFilterArgValue(String, String)
FilterInternalError(String)
InvalidOutputFrameType
ConfigError(String)
AVError(String)
IOError(String)
Unknown(String)
Trait Implementations§
source§impl Error for Error
impl Error for Error
1.30.0 · source§fn source(&self) -> Option<&(dyn Error + 'static)>
fn source(&self) -> Option<&(dyn Error + 'static)>
Returns the lower-level source of this error, if any. Read more
1.0.0 · source§fn description(&self) -> &str
fn description(&self) -> &str
👎Deprecated since 1.42.0: use the Display impl or to_string()
Auto Trait Implementations§
impl Freeze for Error
impl RefUnwindSafe for Error
impl Send for Error
impl Sync for Error
impl Unpin for Error
impl UnwindSafe for Error
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub enum RangeTsFormat {
+ SegmentLocal,
+ StreamLocal,
+}Expand description
Select whether the output timestamps are local to the ranged segment or the entire output
+-
+
SegmentLocal: The output timestamps are in the same timebase as the ranged segment. Used for VOD.
+StreamLocal: The output timestamps are in the same timebase as the entire output.
+
Variants§
Trait Implementations§
source§impl Clone for RangeTsFormat
impl Clone for RangeTsFormat
source§fn clone(&self) -> RangeTsFormat
fn clone(&self) -> RangeTsFormat
Returns a copy of the value. Read more
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from
source. Read moreAuto Trait Implementations§
impl Freeze for RangeTsFormat
impl RefUnwindSafe for RangeTsFormat
impl Send for RangeTsFormat
impl Sync for RangeTsFormat
impl Unpin for RangeTsFormat
impl UnwindSafe for RangeTsFormat
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
source§impl<T> CloneToUninit for Twhere
+ T: Clone,
impl<T> CloneToUninit for Twhere
+ T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
🔬This is a nightly-only experimental API. (
clone_to_uninit)§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
Redirecting to ../../../../vidformer/filter/builtin/struct.IPC.html...
+ + + \ No newline at end of file diff --git a/vidformer/filter/builtin/sidebar-items.js b/vidformer/filter/builtin/sidebar-items.js new file mode 100644 index 0000000..e0a999c --- /dev/null +++ b/vidformer/filter/builtin/sidebar-items.js @@ -0,0 +1 @@ +window.SIDEBAR_ITEMS = {"fn":["filters"],"struct":["Annotate","BoundingBox","BoundingBoxBound","Box","DrawBox","DrawText","HStack","IPC","InlineMat","Pad","PlaceholderFrame","Scale","SliceMat","SliceWriteMat","VStack"]}; \ No newline at end of file diff --git a/vidformer/filter/builtin/struct.Annotate.html b/vidformer/filter/builtin/struct.Annotate.html new file mode 100644 index 0000000..dc79202 --- /dev/null +++ b/vidformer/filter/builtin/struct.Annotate.html @@ -0,0 +1,27 @@ +pub struct Annotate {}Trait Implementations§
Auto Trait Implementations§
impl Freeze for Annotate
impl RefUnwindSafe for Annotate
impl Send for Annotate
impl Sync for Annotate
impl Unpin for Annotate
impl UnwindSafe for Annotate
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct BoundingBox {}Trait Implementations§
Auto Trait Implementations§
impl Freeze for BoundingBox
impl RefUnwindSafe for BoundingBox
impl Send for BoundingBox
impl Sync for BoundingBox
impl Unpin for BoundingBox
impl UnwindSafe for BoundingBox
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct BoundingBoxBound { /* private fields */ }Trait Implementations§
source§impl Debug for BoundingBoxBound
impl Debug for BoundingBoxBound
source§impl<'de> Deserialize<'de> for BoundingBoxBound
impl<'de> Deserialize<'de> for BoundingBoxBound
source§fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
Auto Trait Implementations§
impl Freeze for BoundingBoxBound
impl RefUnwindSafe for BoundingBoxBound
impl Send for BoundingBoxBound
impl Sync for BoundingBoxBound
impl Unpin for BoundingBoxBound
impl UnwindSafe for BoundingBoxBound
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> DeserializeOwned for Twhere
+ T: for<'de> Deserialize<'de>,
impl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct Box {}Trait Implementations§
Auto Trait Implementations§
impl Freeze for Box
impl RefUnwindSafe for Box
impl Send for Box
impl Sync for Box
impl Unpin for Box
impl UnwindSafe for Box
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct DrawBox {}Trait Implementations§
Auto Trait Implementations§
impl Freeze for DrawBox
impl RefUnwindSafe for DrawBox
impl Send for DrawBox
impl Sync for DrawBox
impl Unpin for DrawBox
impl UnwindSafe for DrawBox
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct DrawText {}Trait Implementations§
Auto Trait Implementations§
impl Freeze for DrawText
impl RefUnwindSafe for DrawText
impl Send for DrawText
impl Sync for DrawText
impl Unpin for DrawText
impl UnwindSafe for DrawText
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct HStack {}Trait Implementations§
Auto Trait Implementations§
impl Freeze for HStack
impl RefUnwindSafe for HStack
impl Send for HStack
impl Sync for HStack
impl Unpin for HStack
impl UnwindSafe for HStack
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct IPC { /* private fields */ }Expand description
Filter over IPC Socket
+This filter sends requests to a filter server over a Unix socket. +TODO: Wire protocol documentation
+Implementations§
Trait Implementations§
Auto Trait Implementations§
impl !Freeze for IPC
impl !RefUnwindSafe for IPC
impl Send for IPC
impl Sync for IPC
impl Unpin for IPC
impl UnwindSafe for IPC
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct InlineMat;Trait Implementations§
Auto Trait Implementations§
impl Freeze for InlineMat
impl RefUnwindSafe for InlineMat
impl Send for InlineMat
impl Sync for InlineMat
impl Unpin for InlineMat
impl UnwindSafe for InlineMat
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct Pad {}Trait Implementations§
Auto Trait Implementations§
impl Freeze for Pad
impl RefUnwindSafe for Pad
impl Send for Pad
impl Sync for Pad
impl Unpin for Pad
impl UnwindSafe for Pad
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct PlaceholderFrame {}Trait Implementations§
source§impl Filter for PlaceholderFrame
impl Filter for PlaceholderFrame
Auto Trait Implementations§
impl Freeze for PlaceholderFrame
impl RefUnwindSafe for PlaceholderFrame
impl Send for PlaceholderFrame
impl Sync for PlaceholderFrame
impl Unpin for PlaceholderFrame
impl UnwindSafe for PlaceholderFrame
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct Scale {}Expand description
Scale & convert pixel format of a frame
+§Arguments
+-
+
width- Width of the output frame (optional, but required ifheightis provided)
+height- Height of the output frame (optional, but required ifwidthis provided)
+format- Pixel format of the output frame (optional)
+
Trait Implementations§
Auto Trait Implementations§
impl Freeze for Scale
impl RefUnwindSafe for Scale
impl Send for Scale
impl Sync for Scale
impl Unpin for Scale
impl UnwindSafe for Scale
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct SliceMat {}Trait Implementations§
Auto Trait Implementations§
impl Freeze for SliceMat
impl RefUnwindSafe for SliceMat
impl Send for SliceMat
impl Sync for SliceMat
impl Unpin for SliceMat
impl UnwindSafe for SliceMat
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct SliceWriteMat {}Trait Implementations§
source§impl Filter for SliceWriteMat
impl Filter for SliceWriteMat
Auto Trait Implementations§
impl Freeze for SliceWriteMat
impl RefUnwindSafe for SliceWriteMat
impl Send for SliceWriteMat
impl Sync for SliceWriteMat
impl Unpin for SliceWriteMat
impl UnwindSafe for SliceWriteMat
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct VStack {}Trait Implementations§
Auto Trait Implementations§
impl Freeze for VStack
impl RefUnwindSafe for VStack
impl Send for VStack
impl Sync for VStack
impl Unpin for VStack
impl UnwindSafe for VStack
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct AddWeighted {}Trait Implementations§
Auto Trait Implementations§
impl Freeze for AddWeighted
impl RefUnwindSafe for AddWeighted
impl Send for AddWeighted
impl Sync for AddWeighted
impl Unpin for AddWeighted
impl UnwindSafe for AddWeighted
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct ArrowedLine {}Trait Implementations§
Auto Trait Implementations§
impl Freeze for ArrowedLine
impl RefUnwindSafe for ArrowedLine
impl Send for ArrowedLine
impl Sync for ArrowedLine
impl Unpin for ArrowedLine
impl UnwindSafe for ArrowedLine
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct Circle {}Trait Implementations§
Auto Trait Implementations§
impl Freeze for Circle
impl RefUnwindSafe for Circle
impl Send for Circle
impl Sync for Circle
impl Unpin for Circle
impl UnwindSafe for Circle
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct Line {}Trait Implementations§
Auto Trait Implementations§
impl Freeze for Line
impl RefUnwindSafe for Line
impl Send for Line
impl Sync for Line
impl Unpin for Line
impl UnwindSafe for Line
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct PutText {}Trait Implementations§
Auto Trait Implementations§
impl Freeze for PutText
impl RefUnwindSafe for PutText
impl Send for PutText
impl Sync for PutText
impl Unpin for PutText
impl UnwindSafe for PutText
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct Rectangle {}Trait Implementations§
Auto Trait Implementations§
impl Freeze for Rectangle
impl RefUnwindSafe for Rectangle
impl Send for Rectangle
impl Sync for Rectangle
impl Unpin for Rectangle
impl UnwindSafe for Rectangle
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct SetTo {}Trait Implementations§
Auto Trait Implementations§
impl Freeze for SetTo
impl RefUnwindSafe for SetTo
impl Send for SetTo
impl Sync for SetTo
impl Unpin for SetTo
impl UnwindSafe for SetTo
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub enum Val {
+ Frame(Frame),
+ FrameType(FrameType),
+ Bool(bool),
+ Int(i64),
+ String(String),
+ Bytes(Vec<u8>),
+ Float(f64),
+ List(Vec<Val>),
+}Expand description
A value that can be passed to a filter
+This can be a either a video frame or a conventional data value
+Variants§
Frame(Frame)
FrameType(FrameType)
Bool(bool)
Int(i64)
String(String)
Bytes(Vec<u8>)
Float(f64)
List(Vec<Val>)
Implementations§
Trait Implementations§
Auto Trait Implementations§
impl Freeze for Val
impl RefUnwindSafe for Val
impl Send for Val
impl Sync for Val
impl Unpin for Val
impl UnwindSafe for Val
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
source§impl<T> CloneToUninit for Twhere
+ T: Clone,
impl<T> CloneToUninit for Twhere
+ T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
🔬This is a nightly-only experimental API. (
clone_to_uninit)§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
Expand description
Filters create and transform video frames
+A filter is a function that takes some inputs and returns a video frame.
+For example a filter could blur an input: MyBlur(frame, amount=5).
Modules§
- vidformer built-in filters
- vidformer cv2 filters
Structs§
- A decoded video frame
Enums§
- A value that can be passed to a filter
Traits§
- A filter that can create a video frame from some inputs
pub struct Frame {
+ pub width: i32,
+ pub height: i32,
+ pub format: AVPixelFormat,
+ /* private fields */
+}Expand description
A decoded video frame
+Fields§
§width: i32§height: i32§format: AVPixelFormatTrait Implementations§
source§impl<'de> Deserialize<'de> for Frame
impl<'de> Deserialize<'de> for Frame
source§fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>
Deserialize this value from the given Serde deserializer. Read more
Auto Trait Implementations§
impl Freeze for Frame
impl RefUnwindSafe for Frame
impl Send for Frame
impl Sync for Frame
impl Unpin for Frame
impl UnwindSafe for Frame
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
source§impl<T> CloneToUninit for Twhere
+ T: Clone,
impl<T> CloneToUninit for Twhere
+ T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
🔬This is a nightly-only experimental API. (
clone_to_uninit)§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> DeserializeOwned for Twhere
+ T: for<'de> Deserialize<'de>,
impl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct FrameType {
+ pub width: usize,
+ pub height: usize,
+ pub format: AVPixelFormat,
+}Fields§
§width: usize§height: usize§format: AVPixelFormatImplementations§
Trait Implementations§
source§impl<'de> Deserialize<'de> for FrameType
impl<'de> Deserialize<'de> for FrameType
source§fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
impl Eq for FrameType
impl StructuralPartialEq for FrameType
Auto Trait Implementations§
impl Freeze for FrameType
impl RefUnwindSafe for FrameType
impl Send for FrameType
impl Sync for FrameType
impl Unpin for FrameType
impl UnwindSafe for FrameType
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
source§impl<T> CloneToUninit for Twhere
+ T: Clone,
impl<T> CloneToUninit for Twhere
+ T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
🔬This is a nightly-only experimental API. (
clone_to_uninit)§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> DeserializeOwned for Twhere
+ T: for<'de> Deserialize<'de>,
impl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub trait Filter: Send + Sync {
+ // Required methods
+ fn filter(
+ &self,
+ args: &[Val],
+ kwargs: &BTreeMap<String, Val>,
+ ) -> Result<Frame, Error>;
+ fn filter_type(
+ &self,
+ args: &[Val],
+ kwargs: &BTreeMap<String, Val>,
+ ) -> Result<FrameType, Error>;
+}Expand description
A filter that can create a video frame from some inputs
+Required Methods§
sourcefn filter(
+ &self,
+ args: &[Val],
+ kwargs: &BTreeMap<String, Val>,
+) -> Result<Frame, Error>
fn filter( + &self, + args: &[Val], + kwargs: &BTreeMap<String, Val>, +) -> Result<Frame, Error>
Creates a video frame from some inputs
+The inputs are arbitrary and user provided. An input can either be +ordered (arg) or named (kwargs). This is similar to Python function calls.
+fn filter_type( + &self, + args: &[Val], + kwargs: &BTreeMap<String, Val>, +) -> Result<FrameType, Error>
Implementors§
impl Filter for Annotate
impl Filter for BoundingBox
impl Filter for Box
impl Filter for DrawBox
impl Filter for DrawText
impl Filter for HStack
impl Filter for IPC
impl Filter for InlineMat
impl Filter for Pad
impl Filter for PlaceholderFrame
impl Filter for Scale
impl Filter for SliceMat
impl Filter for SliceWriteMat
impl Filter for VStack
impl Filter for AddWeighted
impl Filter for ArrowedLine
impl Filter for Circle
impl Filter for Line
impl Filter for PutText
impl Filter for Rectangle
impl Filter for SetTo
pub fn codecs() -> Vec<CodecDescriptor>Expand description
List all available codecs
+pub fn create_spec_hls(
+ spec: &dyn Spec,
+ host_prefix: &str,
+ context: &Context,
+ _config: &Config,
+) -> (String, String, String, Vec<(Rational64, Rational64)>)Expand description
Create HLS artifacts for a spec
+-
+
spec- The spec to create HLS artifacts for
+host_prefix- The prefix to use for the host (e.g.,https://example.com:8000)
+context- The context to use for the spec
+config- The config to use for the spec
+
Returns a tuple of:
+-
+
- The namespace for the HLS artifacts +
- The text of the m3u8 playlist file +
- The text of the m3u8 stream file +
- A vector of tuples of the start and end timestamps of each segment +
pub fn init()Expand description
Instantiate FFmpeg logging
+Expand description
vidformer is a core video synthesis/transformation library. +It handles the movement, control flow, and processing of video and conventional (non-video) data.
+Quick links:
+ +Modules§
- Arrays provide access to data.
- Filters create and transform video frames
- Services provide access to media storage.
- Spec Intermediate Representation
- Specs declarativly define an edited video.
Structs§
- Config for a spesific run of a vidformer spec
- A context for a spec
- A range spesifier
- Stats from a run of a vidformer spec
Enums§
- Select whether the output timestamps are local to the ranged segment or the entire output
Functions§
- List all available codecs
- Create HLS artifacts for a spec
- Instantiate FFmpeg logging
- Execute a spec, or a range of a spec.
- Validate that a spec can be run.
pub struct Service { /* private fields */ }Implementations§
Trait Implementations§
source§impl<'de> Deserialize<'de> for Service
impl<'de> Deserialize<'de> for Service
source§fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
Auto Trait Implementations§
impl Freeze for Service
impl RefUnwindSafe for Service
impl Send for Service
impl Sync for Service
impl Unpin for Service
impl UnwindSafe for Service
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
source§impl<T> CloneToUninit for Twhere
+ T: Clone,
impl<T> CloneToUninit for Twhere
+ T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
🔬This is a nightly-only experimental API. (
clone_to_uninit)§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> DeserializeOwned for Twhere
+ T: for<'de> Deserialize<'de>,
impl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub enum DataExpr {
+ Bool(bool),
+ Int(i64),
+ String(String),
+ Bytes(Vec<u8>),
+ ArrayRef(String, IndexConst),
+ Float(f64),
+ List(Vec<DataExpr>),
+}Variants§
Bool(bool)
Int(i64)
String(String)
Bytes(Vec<u8>)
ArrayRef(String, IndexConst)
Float(f64)
List(Vec<DataExpr>)
Trait Implementations§
source§impl<'de> Deserialize<'de> for DataExpr
impl<'de> Deserialize<'de> for DataExpr
source§fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
Auto Trait Implementations§
impl Freeze for DataExpr
impl RefUnwindSafe for DataExpr
impl Send for DataExpr
impl Sync for DataExpr
impl Unpin for DataExpr
impl UnwindSafe for DataExpr
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
source§impl<T> CloneToUninit for Twhere
+ T: Clone,
impl<T> CloneToUninit for Twhere
+ T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
🔬This is a nightly-only experimental API. (
clone_to_uninit)§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> DeserializeOwned for Twhere
+ T: for<'de> Deserialize<'de>,
impl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub enum Expr {
+ Frame(FrameExpr),
+ Data(DataExpr),
+}Variants§
Trait Implementations§
source§impl<'de> Deserialize<'de> for Expr
impl<'de> Deserialize<'de> for Expr
source§fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
Auto Trait Implementations§
impl Freeze for Expr
impl RefUnwindSafe for Expr
impl Send for Expr
impl Sync for Expr
impl Unpin for Expr
impl UnwindSafe for Expr
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
source§impl<T> CloneToUninit for Twhere
+ T: Clone,
impl<T> CloneToUninit for Twhere
+ T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
🔬This is a nightly-only experimental API. (
clone_to_uninit)§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> DeserializeOwned for Twhere
+ T: for<'de> Deserialize<'de>,
impl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub enum FrameExpr {
+ Source(FrameSource),
+ Filter(FilterExpr),
+}Variants§
Source(FrameSource)
Filter(FilterExpr)
Trait Implementations§
source§impl<'de> Deserialize<'de> for FrameExpr
impl<'de> Deserialize<'de> for FrameExpr
source§fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
Auto Trait Implementations§
impl Freeze for FrameExpr
impl RefUnwindSafe for FrameExpr
impl Send for FrameExpr
impl Sync for FrameExpr
impl Unpin for FrameExpr
impl UnwindSafe for FrameExpr
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
source§impl<T> CloneToUninit for Twhere
+ T: Clone,
impl<T> CloneToUninit for Twhere
+ T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
🔬This is a nightly-only experimental API. (
clone_to_uninit)§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> DeserializeOwned for Twhere
+ T: for<'de> Deserialize<'de>,
impl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub enum IndexConst {
+ ILoc(usize),
+ T(Rational64),
+}Variants§
ILoc(usize)
T(Rational64)
Trait Implementations§
source§impl Clone for IndexConst
impl Clone for IndexConst
source§fn clone(&self) -> IndexConst
fn clone(&self) -> IndexConst
Returns a copy of the value. Read more
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from
source. Read moresource§impl Debug for IndexConst
impl Debug for IndexConst
source§impl<'de> Deserialize<'de> for IndexConst
impl<'de> Deserialize<'de> for IndexConst
source§fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
source§impl Display for IndexConst
impl Display for IndexConst
source§impl Ord for IndexConst
impl Ord for IndexConst
source§fn cmp(&self, other: &IndexConst) -> Ordering
fn cmp(&self, other: &IndexConst) -> Ordering
1.21.0 · source§fn max(self, other: Self) -> Selfwhere
+ Self: Sized,
fn max(self, other: Self) -> Selfwhere
+ Self: Sized,
Compares and returns the maximum of two values. Read more
source§impl PartialEq for IndexConst
impl PartialEq for IndexConst
source§impl PartialOrd for IndexConst
impl PartialOrd for IndexConst
source§impl Serialize for IndexConst
impl Serialize for IndexConst
impl Eq for IndexConst
impl StructuralPartialEq for IndexConst
Auto Trait Implementations§
impl Freeze for IndexConst
impl RefUnwindSafe for IndexConst
impl Send for IndexConst
impl Sync for IndexConst
impl Unpin for IndexConst
impl UnwindSafe for IndexConst
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
source§impl<T> CloneToUninit for Twhere
+ T: Clone,
impl<T> CloneToUninit for Twhere
+ T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
🔬This is a nightly-only experimental API. (
clone_to_uninit)§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> DeserializeOwned for Twhere
+ T: for<'de> Deserialize<'de>,
impl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct FilterExpr {
+ pub name: String,
+ pub args: Vec<Expr>,
+ pub kwargs: BTreeMap<String, Expr>,
+}Fields§
§name: String§args: Vec<Expr>§kwargs: BTreeMap<String, Expr>Trait Implementations§
source§impl Clone for FilterExpr
impl Clone for FilterExpr
source§fn clone(&self) -> FilterExpr
fn clone(&self) -> FilterExpr
Returns a copy of the value. Read more
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from
source. Read moresource§impl Debug for FilterExpr
impl Debug for FilterExpr
source§impl<'de> Deserialize<'de> for FilterExpr
impl<'de> Deserialize<'de> for FilterExpr
source§fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
Auto Trait Implementations§
impl Freeze for FilterExpr
impl RefUnwindSafe for FilterExpr
impl Send for FilterExpr
impl Sync for FilterExpr
impl Unpin for FilterExpr
impl UnwindSafe for FilterExpr
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
source§impl<T> CloneToUninit for Twhere
+ T: Clone,
impl<T> CloneToUninit for Twhere
+ T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
🔬This is a nightly-only experimental API. (
clone_to_uninit)§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> DeserializeOwned for Twhere
+ T: for<'de> Deserialize<'de>,
impl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct FrameSource { /* private fields */ }Implementations§
source§impl FrameSource
impl FrameSource
pub fn new(video: String, index: IndexConst) -> Self
pub fn video(&self) -> &str
pub fn index(&self) -> &IndexConst
Trait Implementations§
source§impl Clone for FrameSource
impl Clone for FrameSource
source§fn clone(&self) -> FrameSource
fn clone(&self) -> FrameSource
Returns a copy of the value. Read more
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from
source. Read moresource§impl Debug for FrameSource
impl Debug for FrameSource
source§impl<'de> Deserialize<'de> for FrameSource
impl<'de> Deserialize<'de> for FrameSource
source§fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
source§impl Ord for FrameSource
impl Ord for FrameSource
source§fn cmp(&self, other: &FrameSource) -> Ordering
fn cmp(&self, other: &FrameSource) -> Ordering
1.21.0 · source§fn max(self, other: Self) -> Selfwhere
+ Self: Sized,
fn max(self, other: Self) -> Selfwhere
+ Self: Sized,
Compares and returns the maximum of two values. Read more
source§impl PartialEq for FrameSource
impl PartialEq for FrameSource
source§impl PartialOrd for FrameSource
impl PartialOrd for FrameSource
source§impl Serialize for FrameSource
impl Serialize for FrameSource
impl Eq for FrameSource
impl StructuralPartialEq for FrameSource
Auto Trait Implementations§
impl Freeze for FrameSource
impl RefUnwindSafe for FrameSource
impl Send for FrameSource
impl Sync for FrameSource
impl Unpin for FrameSource
impl UnwindSafe for FrameSource
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
source§impl<T> CloneToUninit for Twhere
+ T: Clone,
impl<T> CloneToUninit for Twhere
+ T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
🔬This is a nightly-only experimental API. (
clone_to_uninit)§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> DeserializeOwned for Twhere
+ T: for<'de> Deserialize<'de>,
impl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub fn create_profile_file(streams: &[SourceVideoStreamMeta]) -> SourceFileMetapub struct SourceFileMeta { /* private fields */ }Trait Implementations§
source§impl Debug for SourceFileMeta
impl Debug for SourceFileMeta
source§impl<'de> Deserialize<'de> for SourceFileMeta
impl<'de> Deserialize<'de> for SourceFileMeta
source§fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
Auto Trait Implementations§
impl Freeze for SourceFileMeta
impl RefUnwindSafe for SourceFileMeta
impl Send for SourceFileMeta
impl Sync for SourceFileMeta
impl Unpin for SourceFileMeta
impl UnwindSafe for SourceFileMeta
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> DeserializeOwned for Twhere
+ T: for<'de> Deserialize<'de>,
impl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct SourceVideoStreamMeta {
+ pub name: String,
+ pub file_path: String,
+ pub stream_idx: usize,
+ pub service: Service,
+ pub file_size: u64,
+ pub resolution: (usize, usize),
+ pub codec: String,
+ pub pix_fmt: String,
+ pub ts: Vec<Rational64>,
+ pub keys: Vec<Rational64>,
+}Fields§
§name: String§file_path: String§stream_idx: usize§service: Service§file_size: u64§resolution: (usize, usize)§codec: String§pix_fmt: String§ts: Vec<Rational64>§keys: Vec<Rational64>Implementations§
Trait Implementations§
source§impl Clone for SourceVideoStreamMeta
impl Clone for SourceVideoStreamMeta
source§fn clone(&self) -> SourceVideoStreamMeta
fn clone(&self) -> SourceVideoStreamMeta
Returns a copy of the value. Read more
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from
source. Read moresource§impl Debug for SourceVideoStreamMeta
impl Debug for SourceVideoStreamMeta
source§impl<'de> Deserialize<'de> for SourceVideoStreamMeta
impl<'de> Deserialize<'de> for SourceVideoStreamMeta
source§fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
Auto Trait Implementations§
impl Freeze for SourceVideoStreamMeta
impl RefUnwindSafe for SourceVideoStreamMeta
impl Send for SourceVideoStreamMeta
impl Sync for SourceVideoStreamMeta
impl Unpin for SourceVideoStreamMeta
impl UnwindSafe for SourceVideoStreamMeta
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
source§impl<T> CloneToUninit for Twhere
+ T: Clone,
impl<T> CloneToUninit for Twhere
+ T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
🔬This is a nightly-only experimental API. (
clone_to_uninit)§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> DeserializeOwned for Twhere
+ T: for<'de> Deserialize<'de>,
impl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
Expand description
Specs declarativly define an edited video.
+A spec defines an output video (as a logical time-indexed array).
+It creates this array by defining its domain (the set of times at which the spec is defined) and a function that maps each time to a frame.
+The frame is represented as an FrameExpr expression.
Specs are stateless and immutable. They are intended to be smaller than just storing the entire output video as an array. +Additionally, this generic spec interface allows the general case of a video-editing DSL, as done in V2V, while allowing for whatever language the use case needs.
+Structs§
- A spec backed by a JSON file
Traits§
- A trait for a spec
- A trait for providing information to a spec during runtime
pub struct JsonSpec {
+ pub frames: Vec<(Rational64, FrameExpr)>,
+}Expand description
A spec backed by a JSON file
+Fields§
§frames: Vec<(Rational64, FrameExpr)>Trait Implementations§
source§impl<'de> Deserialize<'de> for JsonSpec
impl<'de> Deserialize<'de> for JsonSpec
source§fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
source§impl Spec for JsonSpec
impl Spec for JsonSpec
source§fn domain(&self, _context: &dyn SpecContext) -> Vec<Rational64>
fn domain(&self, _context: &dyn SpecContext) -> Vec<Rational64>
Returns the domain of the spec. Read more
source§fn render(&self, _context: &dyn SpecContext, t: &Rational64) -> FrameExpr
fn render(&self, _context: &dyn SpecContext, t: &Rational64) -> FrameExpr
Returns the “logically” rendered frame at a given time. Read more
Auto Trait Implementations§
impl Freeze for JsonSpec
impl RefUnwindSafe for JsonSpec
impl Send for JsonSpec
impl Sync for JsonSpec
impl Unpin for JsonSpec
impl UnwindSafe for JsonSpec
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> DeserializeOwned for Twhere
+ T: for<'de> Deserialize<'de>,
impl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub trait Spec: Sync + Send {
+ // Required methods
+ fn domain(&self, context: &dyn SpecContext) -> Vec<Rational64>;
+ fn render(&self, context: &dyn SpecContext, t: &Rational64) -> FrameExpr;
+}Expand description
A trait for a spec
+A spec defines a video from a sequence of transformations.
+A SpecContext is provided for information about the available source videos and arrays.
Required Methods§
sourcefn domain(&self, context: &dyn SpecContext) -> Vec<Rational64>
fn domain(&self, context: &dyn SpecContext) -> Vec<Rational64>
Returns the domain of the spec.
+The domain is the set of times at which the spec is defined. +Each time corresponds to a single output frame at that timestamp.
+The output must:
+-
+
- Be sorted in ascending order +
- Contain no duplicate values +
- Begin with 0 +
sourcefn render(&self, context: &dyn SpecContext, t: &Rational64) -> FrameExpr
fn render(&self, context: &dyn SpecContext, t: &Rational64) -> FrameExpr
Returns the “logically” rendered frame at a given time.
+This function should assume that the time is in the domain of the spec.
+Implementors§
pub struct CodecDescriptor {
+ pub name: String,
+ pub long_name: String,
+ pub format_id_pretty_name: String,
+ pub has_decoder: bool,
+ pub has_encoder: bool,
+}Fields§
§name: String§long_name: String§format_id_pretty_name: String§has_decoder: bool§has_encoder: boolTrait Implementations§
Auto Trait Implementations§
impl Freeze for CodecDescriptor
impl RefUnwindSafe for CodecDescriptor
impl Send for CodecDescriptor
impl Sync for CodecDescriptor
impl Unpin for CodecDescriptor
impl UnwindSafe for CodecDescriptor
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct Config {
+ pub decode_pool_size: usize,
+ pub decoder_view: usize,
+ pub decoders: usize,
+ pub filterers: usize,
+ pub output_width: usize,
+ pub output_height: usize,
+ pub output_pix_fmt: String,
+ pub encoder: Option<EncoderConfig>,
+ pub format: Option<String>,
+}Expand description
Config for a spesific run of a vidformer spec
+This is a collection of settings that are used to execute a spec. +This combines information about the output with internal performance knobs.
+The max number of frames in memory is roughly decoders + decode_pool_size + decoder_view
+Fields§
§decode_pool_size: usizeThe number of frames which can be fit in the decode pool
+decoder_view: usizeHow many output frames can be active at once +This also limits how many frames can be in the filters + encode buffer at once
+decoders: usizeHow many decoders can be active at once
+filterers: usizeHow many filter threads to run
+output_width: usize§output_height: usize§output_pix_fmt: String§encoder: Option<EncoderConfig>Configuration to use for output encoder
+format: Option<String>The name of the format to use for output. +If None, the format will be inferred from the output path.
+Trait Implementations§
source§impl<'de> Deserialize<'de> for Config
impl<'de> Deserialize<'de> for Config
source§fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
Auto Trait Implementations§
impl Freeze for Config
impl RefUnwindSafe for Config
impl Send for Config
impl Sync for Config
impl Unpin for Config
impl UnwindSafe for Config
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
source§impl<T> CloneToUninit for Twhere
+ T: Clone,
impl<T> CloneToUninit for Twhere
+ T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
🔬This is a nightly-only experimental API. (
clone_to_uninit)§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> DeserializeOwned for Twhere
+ T: for<'de> Deserialize<'de>,
impl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct Context { /* private fields */ }Expand description
A context for a spec
+This is a collection of sources, filters, and arrays that are used to execute a DVE spec. +It’s a pretty simple layout here, but if you really want to incorporate vidformer deep into a VDBMS, you +gut this object and make the sources and arrays backed directly through your DB.
+Implementations§
Auto Trait Implementations§
impl Freeze for Context
impl !RefUnwindSafe for Context
impl Send for Context
impl Sync for Context
impl Unpin for Context
impl !UnwindSafe for Context
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct EncoderConfig {
+ pub codec_name: String,
+ pub opts: Vec<(String, String)>,
+}Fields§
§codec_name: String§opts: Vec<(String, String)>Trait Implementations§
source§impl Clone for EncoderConfig
impl Clone for EncoderConfig
source§fn clone(&self) -> EncoderConfig
fn clone(&self) -> EncoderConfig
Returns a copy of the value. Read more
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from
source. Read moresource§impl Debug for EncoderConfig
impl Debug for EncoderConfig
source§impl<'de> Deserialize<'de> for EncoderConfig
impl<'de> Deserialize<'de> for EncoderConfig
source§fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
+ __D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
Auto Trait Implementations§
impl Freeze for EncoderConfig
impl RefUnwindSafe for EncoderConfig
impl Send for EncoderConfig
impl Sync for EncoderConfig
impl Unpin for EncoderConfig
impl UnwindSafe for EncoderConfig
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
source§impl<T> CloneToUninit for Twhere
+ T: Clone,
impl<T> CloneToUninit for Twhere
+ T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
🔬This is a nightly-only experimental API. (
clone_to_uninit)§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> DeserializeOwned for Twhere
+ T: for<'de> Deserialize<'de>,
impl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct Range {
+ pub start: Rational64,
+ pub end: Rational64,
+ pub ts_format: RangeTsFormat,
+}Expand description
A range spesifier
+start and end are the start and end of the range in the timebase of the input, inclusive.
Fields§
§start: Rational64§end: Rational64§ts_format: RangeTsFormatTrait Implementations§
Auto Trait Implementations§
impl Freeze for Range
impl RefUnwindSafe for Range
impl Send for Range
impl Sync for Range
impl Unpin for Range
impl UnwindSafe for Range
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
source§impl<T> CloneToUninit for Twhere
+ T: Clone,
impl<T> CloneToUninit for Twhere
+ T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
🔬This is a nightly-only experimental API. (
clone_to_uninit)§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
pub struct Stats {
+ pub max_decoder_count: usize,
+ pub max_encode_buffer_size: usize,
+ pub decoders_created: usize,
+ pub frames_written: usize,
+ pub frames_decoded: usize,
+ pub runtime: Duration,
+}Expand description
Stats from a run of a vidformer spec
+Fields§
§max_decoder_count: usize§max_encode_buffer_size: usize§decoders_created: usize§frames_written: usize§frames_decoded: usize§runtime: DurationTrait Implementations§
Auto Trait Implementations§
impl Freeze for Stats
impl RefUnwindSafe for Stats
impl Send for Stats
impl Sync for Stats
impl Unpin for Stats
impl UnwindSafe for Stats
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
impl<T> BorrowMut<T> for Twhere
+ T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
+ S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default
Subscriber to this type, returning a
+[WithDispatch] wrapper. Read moreimpl<T> ErasedDestructor for Twhere
+ T: 'static,
impl<T> MaybeSend for Twhere
+ T: Send,
impl<T> MaybeSendSync for T
Redirecting to ../../vidformer/fn.codecs.html...
+ + + \ No newline at end of file diff --git a/vidformer/util/fn.init.html b/vidformer/util/fn.init.html new file mode 100644 index 0000000..d880a1f --- /dev/null +++ b/vidformer/util/fn.init.html @@ -0,0 +1,11 @@ + + + + +Redirecting to ../../vidformer/fn.init.html...
+ + + \ No newline at end of file diff --git a/vidformer/util/struct.CodecDescriptor.html b/vidformer/util/struct.CodecDescriptor.html new file mode 100644 index 0000000..50aa2f9 --- /dev/null +++ b/vidformer/util/struct.CodecDescriptor.html @@ -0,0 +1,11 @@ + + + + +Redirecting to ../../vidformer/struct.CodecDescriptor.html...
+ + + \ No newline at end of file