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..91f4262
--- /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 + the yrden server +
- ./vidformer-igni: The second generation vidformer server +
- ./snake-pit: The main vidformer test suite +
- ./viper-den: Igni server 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..c4af5d2
--- /dev/null
+++ b/introduction.html
@@ -0,0 +1,281 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 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 + the yrden server +
- ./vidformer-igni: The second generation vidformer server +
- ./snake-pit: The main vidformer test suite +
- ./viper-den: Igni server 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..89d86e1
--- /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..743f736
--- /dev/null
+++ b/roadmap.html
@@ -0,0 +1,225 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 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 + the yrden server +
- ./vidformer-igni: The second generation vidformer server +
- ./snake-pit: The main vidformer test suite +
- ./viper-den: Igni server 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 server for local use
+-
+
- Designed for local single-tenant use +
- Enables broad drop-in
cv2compatability
+ - Supports basic Video on Demand hosting +
+ -
+
igni: A vidformer server for the cloud
+-
+
- An in progress multi-tenant scale-out server +
- Designed for Video on Demand only
+
-
+
- Does not support full-video exports +
- All video sources must be over the network, not local +
+ - Enables live streaming and waiting on external dependencies for even lower time-to-playback latency +
+
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.
+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:
+-
+
-
+
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..1e227c1
--- /dev/null
+++ b/search-index.js
@@ -0,0 +1,4 @@
+var searchIndex = new Map(JSON.parse('[["vidformer",{"t":"PFFPFFGPPPPPPPFGPPFPPCNNNNNNNNNNNNNNNNNNNNNNNNNNNNOHHOOOONNOOCONNNNNNOOOONNNNNNNNOOHNNNNNNNNOOOONOOOOHONNNCCCCNONNNNNNNNNNNNNNNNNNNNNONNNNNNNNHNNNNNNNNKFNNNMNNNMNMNNNNNNNPPKPFPFPPPPGNNNNNNCNNNNNNNNNCNNNMMNNNOONNNNOONNNNNNNNNNNNNNNNNNNNNNOOFFFFFFFFFFFFFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFFFFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFNNNNNNNNNNNNNNNNNPPPPGGPFPPGFPGPPPPPNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFNNNNNNNOHNNOONNNNNNOOONONNOONNNNNONNNNNFKKNNNMNNONNMNNNNNN","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","add_source_deps","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"],[633,"vidformer::source"],[674,"vidformer::spec"],[693,"vidformer::dve"],[694,"vidformer::util"],[695,"alloc::vec"],[696,"alloc::string"],[697,"num_rational"],[698,"core::result"],[699,"serde::de"],[700,"core::fmt"],[701,"alloc::boxed"],[702,"alloc::collections::btree::map"],[703,"alloc::sync"],[704,"core::option"],[705,"serde::ser"],[706,"core::any"],[707,"rusty_ffmpeg::ffi"],[708,"vidformer::filter::builtin::ipc"],[709,"std::collections::hash::map"],[710,"alloc::collections::btree::set"],[711,"core::cmp"]],"i":"Bf``0```0000000``j1`01`Aj2fhBl4lAb574326104361436143613``44424341`477432040225743261000`57432610022053444`2432````51436175743261057432610157432610`57432610``Db00C`1110101111111Dj0`0`0`0000`Dh1Dl120`120120120`100Cf023121231321231123123123123123123121```````````````EfEhEjElEnF`FbFdFfFhFjFlFnG`Ed>=<;:98765432100>=<;:987654321>=<;:987654321`0>=<;:9876543210>=<;:9876543210>>=<;:9876543210>=<;:9876543210>=<;:9876543210>>=<;:9876543210```````GbGdGfGhGjGlGn654321065432106543210`654321065432106543210654321065432106543210`H`0000000000000000Df00Hn``Hd`21``Hj`331301Hl1Hf14532014532014532014532014532020145320220144553320145302014531102020145320145324532014532014532014530201453``IbBn100000`100010101000000100001010010010```Id00Af111110111111","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{{bA`}n}000`{{}{{Ad{Ab}}}}{{{b{Af}}{b{Ah}}{b{Aj}}{b{f}}}{{B`{AlAlAl{Ad{{B`{AnAn}}}}}}}}````{c{{Bb{f}}}Bd}{c{{Bb{h}}}Bd}````{{{b{Bf}}{b{dBh}}}Bj}0{{{b{f}}{b{dBh}}}Bj}{{{b{h}}{b{dBh}}}Bj}{{{b{Bl}}{b{dBh}}}Bj}{{{b{Ab}}{b{dBh}}}Bj}````{cc{}}0000000``{{}n}{{}c{}}0000000````{{{Ad{Bn}}{Cd{Al{Cb{C`}}}}{Cd{Al{Cb{Cf}}}}}Aj}````{{{b{{Ch{{Cb{Af}}}}}}{b{Ah}}{b{{Ch{Aj}}}}{b{{Ch{f}}}}{b{{Cj{l}}}}}{{Bb{BlBf}}}}`{{{b{f}}c}BbCl}{{{b{h}}c}BbCl}{{{b{Bl}}c}BbCl}````{{{b{Aj}}}{{`{Cn}}}}`{bc{}}000{bAl}{c{{Bb{e}}}{}{}}0000000{{}{{Bb{c}}}{}}0000000`{bD`}0000000{{{b{{Ch{{Cb{Af}}}}}}{b{{Ch{Aj}}}}{b{{Ch{f}}}}}{{Bb{nBf}}}}{{}c{}}0000000``{b{{b{c}}}{}}{{{b{d}}}{{b{dc}}}{}}{c{{Bb{Db}}}Bd}{{{b{C`}}}{{Ad{An}}}}{{{b{Db}}}{{Ad{An}}}}{{{b{Db}}{b{dBh}}}Bj}{cc{}}{{{b{C`}}Dd}Df}{{{b{Db}}Dd}Df}{{{b{C`}}An}Df}{{{b{Db}}An}Df}{{}c{}}{{{b{Db}}c}BbCl}{c{{Bb{e}}}{}{}}{{}{{Bb{c}}}{}}{bD`}{{}c{}}````````````{b{{b{c}}}{}}00{{{b{d}}}{{b{dc}}}{}}00`{{{b{Dh}}}Dh}{{{b{Dj}}}Dj}{{{b{Dl}}}Dl}{{b{b{dc}}}n{}}00{{bA`}n}00`{c{{Bb{Dh}}}Bd}{c{{Bb{Dl}}}Bd}{{{b{Dl}}{b{Dl}}}Dn}{{{b{Cf}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DhBf}}}}{{{b{Cf}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DlBf}}}}{{{b{Dh}}{b{dBh}}}Bj}{{{b{Dj}}{b{dBh}}}Bj}{{{b{Dl}}{b{dBh}}}Bj}``{cc{}}00{{{b{Df}}{b{Aj}}}Dj}``{{}c{}}00{{DdDdEb}Dl}{{{b{Dh}}c}BbCl}{{{b{Dj}}c}BbCl}{{{b{Dl}}c}BbCl}{bc{}}00{c{{Bb{e}}}{}{}}00{{}{{Bb{c}}}{}}00{bD`}00{{}c{}}00`````````````````{b{{b{c}}}{}}00000000000000{{{b{d}}}{{b{dc}}}{}}00000000000000{c{{Bb{Ed}}}Bd}{{{b{Ef}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DhBf}}}}{{{b{Eh}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DhBf}}}}{{{b{Ej}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DhBf}}}}{{{b{El}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DhBf}}}}{{{b{En}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DhBf}}}}{{{b{F`}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DhBf}}}}{{{b{Fb}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DhBf}}}}{{{b{Fd}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DhBf}}}}{{{b{Ff}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DhBf}}}}{{{b{Fh}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DhBf}}}}{{{b{Fj}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DhBf}}}}{{{b{Fl}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DhBf}}}}{{{b{Fn}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DhBf}}}}{{{b{G`}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DhBf}}}}{{{b{Ef}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DlBf}}}}{{{b{Eh}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DlBf}}}}{{{b{Ej}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DlBf}}}}{{{b{El}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DlBf}}}}{{{b{En}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DlBf}}}}{{{b{F`}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DlBf}}}}{{{b{Fb}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DlBf}}}}{{{b{Fd}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DlBf}}}}{{{b{Ff}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DlBf}}}}{{{b{Fh}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DlBf}}}}{{{b{Fj}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DlBf}}}}{{{b{Fl}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DlBf}}}}{{{b{Fn}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DlBf}}}}{{{b{G`}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DlBf}}}}{{}{{Cd{Al{Cb{Cf}}}}}}{{{b{Ed}}{b{dBh}}}Bj}{cc{}}00000000000000{{}c{}}00000000000000{{AlAl}{{Bb{EfBf}}}}{c{{Bb{e}}}{}{}}00000000000000{{}{{Bb{c}}}{}}00000000000000{bD`}00000000000000{{{b{{Cd{AlAl}}}}}{{Bb{EfBf}}}}{{}c{}}00000000000000```````{b{{b{c}}}{}}000000{{{b{d}}}{{b{dc}}}{}}000000{{{b{Gb}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DhBf}}}}{{{b{Gd}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DhBf}}}}{{{b{Gf}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DhBf}}}}{{{b{Gh}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DhBf}}}}{{{b{Gj}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DhBf}}}}{{{b{Gl}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DhBf}}}}{{{b{Gn}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DhBf}}}}{{{b{Gb}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DlBf}}}}{{{b{Gd}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DlBf}}}}{{{b{Gf}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DlBf}}}}{{{b{Gh}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DlBf}}}}{{{b{Gj}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DlBf}}}}{{{b{Gl}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DlBf}}}}{{{b{Gn}}{b{{E`{Dj}}}}{b{{Cd{AlDj}}}}}{{Bb{DlBf}}}}{{}{{Cd{Al{Cb{Cf}}}}}}{cc{}}000000{{}c{}}000000{c{{Bb{e}}}{}{}}000000{{}{{Bb{c}}}{}}000000{bD`}000000{{}c{}}000000`{b{{b{c}}}{}}{{{b{d}}}{{b{dc}}}{}}{{{b{H`}}}H`}{{b{b{dc}}}n{}}{{bA`}n}{{}H`}{c{{Bb{H`}}}Bd}{{{b{H`}}{b{dBh}}}Bj}=<{{Al{Hb{AlAl}}}H`}{{{b{H`}}c}BbCl}{bc{}}>=<;```````````````````{{{b{Hd}}{b{d{Hh{{b{Hf}}}}}}}n}`;;;;;;::::::{{{b{Hj}}}Hj}{{{b{Hf}}}Hf}{{{b{Hl}}}Hl}{{{b{Hn}}}Hn}{{{b{Df}}}Df}{{{b{Hd}}}Hd}>>>>>>======{{{b{Hj}}{b{Hj}}}I`}{{{b{Hf}}{b{Hf}}}I`}{c{{Bb{Hj}}}Bd}{c{{Bb{Hf}}}Bd}{c{{Bb{Hl}}}Bd}{c{{Bb{Hn}}}Bd}{c{{Bb{Df}}}Bd}{c{{Bb{Hd}}}Bd}{{{b{Hj}}{b{Hj}}}Dn}{{{b{Hf}}{b{Hf}}}Dn}{{{b{Hj}}{b{dBh}}}Bj}0{{{b{Hf}}{b{dBh}}}Bj}{{{b{Hl}}{b{dBh}}}Bj}{{{b{Hn}}{b{dBh}}}Bj}0{{{b{Df}}{b{dBh}}}Bj}0{{{b{Hd}}{b{dBh}}}Bj}0{cc{}}00000{{{b{Hf}}}{{b{Hj}}}}{{}c{}}00000``{{AlHj}Hf}{{{b{Hj}}{b{Hj}}}{{Cj{I`}}}}{{{b{Hf}}{b{Hf}}}{{Cj{I`}}}}{{{b{Hj}}c}BbCl}{{{b{Hf}}c}BbCl}{{{b{Hl}}c}BbCl}{{{b{Hn}}c}BbCl}{{{b{Df}}c}BbCl}{{{b{Hd}}c}BbCl}{bc{}}00000{bAl}000{c{{Bb{e}}}{}{}}00000{{}{{Bb{c}}}{}}00000{bD`}00000{{{b{Hf}}}{{b{Ah}}}}{{}c{}}00000``{b{{b{c}}}{}}0{{{b{d}}}{{b{dc}}}{}}0{{{b{Bn}}}Bn}{{b{b{dc}}}n{}}{{bA`}n}`{{{b{{E`{Bn}}}}}Ib}{c{{Bb{Ib}}}Bd}{c{{Bb{Bn}}}Bd}``{{{b{Ib}}{b{dBh}}}Bj}{{{b{Bn}}{b{dBh}}}Bj}{cc{}}0{{}c{}}0```{{{b{Ah}}{b{Ah}}Dd{b{H`}}}{{Bb{BnBf}}}}`{{{b{Ib}}c}BbCl}{{{b{Bn}}c}BbCl}``{bc{}}{c{{Bb{e}}}{}{}}0{{}{{Bb{c}}}{}}0`{bD`}0{{{b{Ah}}{b{Ah}}Dd{b{H`}}}n}{{}c{}}0```{b{{b{c}}}{}}{{{b{d}}}{{b{dc}}}{}}{c{{Bb{Id}}}Bd}{{{b{Af}}{b{Cn}}}{{Ad{An}}}}{{{b{Id}}{b{Cn}}}{{Ad{An}}}}{{{b{Id}}{b{dBh}}}Bj}`{cc{}}{{}c{}}{{{b{Af}}{b{Cn}}{b{An}}}Hd}{{{b{Id}}{b{Cn}}{b{An}}}Hd}{{{b{Id}}c}BbCl}?>=;","D":"A@f","p":[[1,"reference",null,null,1],[0,"mut"],[5,"Config",0,693],[5,"EncoderConfig",0,693],[6,"RangeTsFormat",0,693],[5,"Range",0,693],[1,"unit"],[1,"u8"],[5,"CodecDescriptor",0,694],[5,"Vec",695],[10,"Spec",674],[1,"str"],[5,"Context",0,693],[5,"String",696],[8,"Rational64",697],[1,"tuple",null,null,1],[6,"Result",698,null,1],[10,"Deserializer",699],[6,"Error",0,693],[5,"Formatter",700],[8,"Result",700],[5,"Stats",0,693],[5,"SourceVideoStreamMeta",633],[10,"Array",151],[5,"Box",701,null,1],[5,"BTreeMap",702],[10,"Filter",170],[5,"Arc",703,null,1],[6,"Option",704,null,1],[10,"Serializer",705],[10,"SpecContext",674],[5,"TypeId",706],[5,"JsonArary",151],[1,"usize"],[6,"DataExpr",503],[5,"Frame",170],[6,"Val",170],[5,"FrameType",170],[1,"bool"],[1,"slice"],[8,"AVPixelFormat",707],[5,"BoundingBoxBound",239],[5,"IPC",239,708],[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",709],[6,"FrameExpr",503],[5,"FrameSource",503],[5,"BTreeSet",710],[6,"IndexConst",503],[5,"FilterExpr",503],[6,"Expr",503],[6,"Ordering",711],[5,"SourceFileMeta",633],[5,"JsonSpec",674]],"r":[[1,694],[2,693],[4,693],[5,693],[6,693],[14,693],[15,693],[18,693],[51,694],[52,693],[83,694],[101,693],[142,693],[246,708]],"b":[[63,"impl-Debug-for-Error"],[64,"impl-Display-for-Error"],[564,"impl-Display-for-IndexConst"],[565,"impl-Debug-for-IndexConst"],[568,"impl-Debug-for-Expr"],[569,"impl-Display-for-Expr"],[570,"impl-Display-for-DataExpr"],[571,"impl-Debug-for-DataExpr"],[572,"impl-Display-for-FrameExpr"],[573,"impl-Debug-for-FrameExpr"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAADICKgABAAEABAAAAAYACAARAAEAFAABABcAHAA5AAIAPQAAAEAABQBHAAIAUgABAF0ACABnAAMAbQAAAG8AHwCQAAcAmgACAJ4AAQCiAAAApAAAAKYABgCuAAAAsAAFALcABQC+AAgAyAACAMwABQDVAAIA2wAbAPgAAgD8AD0AOwEAAFoBYADKASQA8QEZAAwCMgBFAgAATAI+AI8CEwCmAgIAqgICALACBQA=","P":[[22,"T"],[38,""],[42,"T"],[46,""],[57,"__D"],[63,""],[73,"T"],[83,""],[84,"U"],[96,""],[103,"__S"],[110,""],[112,"T"],[116,""],[117,"U,T"],[125,"U"],[134,""],[143,"V"],[153,"T"],[155,"__D"],[156,""],[159,"T"],[160,""],[164,"U"],[165,"__S"],[166,"U,T"],[167,"U"],[168,""],[169,"V"],[182,"T"],[189,""],[192,"T"],[195,""],[199,"D"],[200,"__D"],[201,""],[209,"T"],[212,""],[215,"U"],[218,""],[219,"S"],[220,"__S"],[222,"T"],[225,"U,T"],[228,"U"],[231,""],[234,"V"],[254,"T"],[284,"__D"],[285,""],[315,"T"],[330,"U"],[345,""],[346,"U,T"],[361,"U"],[376,""],[392,"V"],[414,"T"],[428,""],[443,"T"],[450,"U"],[457,"U,T"],[464,"U"],[471,""],[478,"V"],[486,"T"],[488,""],[489,"T"],[490,""],[492,"__D"],[493,""],[494,"T"],[495,"U"],[496,""],[497,"__S"],[498,"T"],[499,"U,T"],[500,"U"],[501,""],[502,"V"],[522,""],[524,"T"],[536,""],[542,"T"],[548,""],[556,"__D"],[562,""],[574,"T"],[580,""],[581,"U"],[589,""],[592,"__S"],[598,"T"],[604,""],[608,"U,T"],[614,"U"],[620,""],[627,"V"],[635,"T"],[639,""],[640,"T"],[641,""],[644,"__D"],[648,""],[650,"T"],[652,"U"],[657,""],[659,"__S"],[663,"T"],[664,"U,T"],[666,"U"],[669,""],[672,"V"],[677,"T"],[679,"__D"],[680,""],[684,"T"],[685,"U"],[686,""],[688,"__S"],[689,"U,T"],[690,"U"],[691,""],[692,"V"]]}]]'));
+if (typeof exports !== 'undefined') exports.searchIndex = searchIndex;
+else if (window.initSearch) window.initSearch(searchIndex);
+//{"start":39,"fragment_lengths":[15436]}
\ 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..f862999
--- /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:
+-
+
-
+
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).\nAdd all referenced frame sources to a set.\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_source_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 +1970 +1971 +1972 +1973 +1974 +1975 +1976 +1977 +1978 +1979 +1980 +1981 +1982 +1983 +1984 +1985 +1986 +1987 +1988 +1989 +1990 +1991 +1992 +1993 +1994 +1995 +1996 +1997 +1998 +1999 +2000 +2001 +2002 +2003 +2004
//! 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 compression = match kwargs.get("compression") {
+ Some(Val::String(s)) => Option::Some(s),
+ _ => Option::None,
+ };
+
+ let mut data = match &args[0] {
+ Val::Bytes(b) => b,
+ _ => panic!("Expected bytes"),
+ };
+
+ let mut decompressed: Vec<u8> = Vec::new();
+ if let Some(compression) = compression {
+ assert_eq!(compression, "zlib");
+
+ let mut decoder = flate2::read::ZlibDecoder::new(&data[..]);
+ use std::io::Read;
+ decoder.read_to_end(&mut decompressed).unwrap();
+ data = &decompressed;
+ if data.len() != width as usize * height as usize * 3 {
+ return Err(Error::InvalidFilterArgValue(
+ format!("{:?}", data.len()),
+ "Invalid data length".to_string(),
+ ));
+ }
+ }
+
+ 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),
+ };
+
+ let compression = match kwargs.get("compression") {
+ Some(Val::String(s)) => Option::Some(s),
+ _ => Option::None,
+ };
+
+ if let Some(compression) = compression {
+ if compression != "zlib" {
+ return Err(Error::InvalidFilterArgValue(
+ compression.clone(),
+ "Invalid compression".to_string(),
+ ));
+ }
+ }
+
+ 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 compression.is_none() && 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 +222
//! 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_source_deps<'a>(&'a self, deps: &mut BTreeSet<&'a FrameSource>) {
+ match self {
+ Expr::Frame(frame) => {
+ frame.add_source_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 {
+ /// Add all referenced frame sources to a set.
+ pub fn add_source_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_source_deps(deps);
+ }
+ for arg in filter.kwargs.values() {
+ arg.add_source_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);if(item.displayTypeSignature){const{type,mappedNames,whereClause}=await item.displayTypeSignature;const displayType=document.createElement("div");type.forEach((value,index)=>{if(index%2!==0){const highlight=document.createElement("strong");highlight.appendChild(document.createTextNode(value));displayType.appendChild(highlight)}else{displayType.appendChild(document.createTextNode(value))}});if(mappedNames.size>0||whereClause.size>0){let addWhereLineFn=()=>{const line=document.createElement("div");line.className="where";line.appendChild(document.createTextNode("where"));displayType.appendChild(line);addWhereLineFn=()=>{}};for(const[qname,name]of mappedNames){if(name===qname){continue}addWhereLineFn();const line=document.createElement("div");line.className="where";line.appendChild(document.createTextNode(` ${qname} matches `));const lineStrong=document.createElement("strong");lineStrong.appendChild(document.createTextNode(name));line.appendChild(lineStrong);displayType.appendChild(line)}for(const[name,innerType]of whereClause){if(innerType.length<=1){continue}addWhereLineFn();const line=document.createElement("div");line.className="where";line.appendChild(document.createTextNode(` ${name}: `));innerType.forEach((value,index)=>{if(index%2!==0){const highlight=document.createElement("strong");highlight.appendChild(document.createTextNode(value));line.appendChild(highlight)}else{line.appendChild(document.createTextNode(value))}});displayType.appendChild(line)}}displayType.className="type-signature";link.appendChild(displayType)}link.appendChild(description);return link}));lis.then(lis=>{for(const li of lis){output.appendChild(li)}})}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",results.others.length)+"
";currentTab=0}else if(results.query.foundElems<=1&&results.query.returned.length===0){output+=""+makeTabHeader(0,"In Names",results.others.length)+makeTabHeader(1,"In Parameters",results.in_args.length)+makeTabHeader(2,"In Return Types",results.returned.length)+"
"}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,results.others.length)+"
";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[ret_others,ret_in_args,ret_returned]=await Promise.all([addTab(results.others,results.query,currentTab===0),addTab(results.in_args,results.query,currentTab===1),addTab(results.returned,results.query,currentTab===2),]);const resultsElem=document.createElement("div");resultsElem.id="results";resultsElem.appendChild(ret_others);resultsElem.appendChild(ret_in_args);resultsElem.appendChild(ret_returned);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.userQuery+"\" Search - Rust";updateSearchHistory(buildUrl(query.userQuery,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-56102188.js b/static.files/src-script-56102188.js
new file mode 100644
index 0000000..d0aebb8
--- /dev/null
+++ b/static.files/src-script-56102188.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..ee7e99a
--- /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..1a23db7
--- /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..5bbeb20
--- /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..650cc31
--- /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..9ba96bd
--- /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..7e8d8d3
--- /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..39ced82
--- /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..66a4fc7
--- /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..7062c65
--- /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..87fcd48
--- /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..93d275d
--- /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..cc822a6
--- /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..d0ac297
--- /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..061fdfc
--- /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..af8807a
--- /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..9cbf5c5
--- /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..81a5077
--- /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..e1b2c22
--- /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 server for local use
+-
+
- Designed for local single-tenant use +
- Enables broad drop-in
cv2compatability
+ - Supports basic Video on Demand hosting +
+ -
+
igni: A vidformer server for the cloud
+-
+
- An in progress multi-tenant scale-out server +
- Designed for Video on Demand only
+
-
+
- Does not support full-video exports +
- All video sources must be over the network, not local +
+ - Enables live streaming and waiting on external dependencies for even lower time-to-playback latency +
+
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.
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
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..272a628
--- /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):", "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": "(*args, **kwargs)"}, "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, *args, **kwargs):", "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, *args, **kwargs):", "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, *args, **kwargs):", "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": 11, "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": 18, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.VideoWriter.write": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 25, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.VideoWriter.release": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 25, "bases": 0, "doc": 3}, "vidformer.cv2.vf_cv2.VideoWriter.spec": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 25, "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": 3.1622776601683795}, "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}, "vidformer.cv2.vf_cv2.VideoWriter.write": {"tf": 4.69041575982343}, "vidformer.cv2.vf_cv2.VideoWriter.release": {"tf": 4.69041575982343}, "vidformer.cv2.vf_cv2.VideoWriter.spec": {"tf": 4.69041575982343}, "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}}}, "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}}}, "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}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {"vidformer.cv2.vf_cv2.frameify": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "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, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"vidformer.cv2.vf_cv2.VideoCapture.__init__": {"tf": 1}, "vidformer.cv2.vf_cv2.imread": {"tf": 1}, "vidformer.cv2.vf_cv2.imwrite": {"tf": 1}}, "df": 3}}}, "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}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"vidformer.cv2.vf_cv2.VideoCapture.set": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "o": {"docs": {"vidformer.cv2.vf_cv2.vidplay": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"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.__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": 18}}}, "l": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {"vidformer.cv2.vf_cv2.addWeighted": {"tf": 1}}, "df": 1}}}}}, "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.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.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": 15}}}}}}, "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}}}, "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..1e0d3c5 --- /dev/null +++ b/vidformer-py-cv2/vidformer/cv2/vf_cv2.html @@ -0,0 +1,2525 @@ + + + + + + +
+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 + 14from .. import igni + 15 + 16try: + 17 import cv2 as _opencv2 + 18except: + 19 _opencv2 = None + 20 + 21import numpy as np + 22 + 23import uuid + 24from fractions import Fraction + 25from bisect import bisect_right + 26import zlib + 27 + 28CAP_PROP_POS_MSEC = 0 + 29CAP_PROP_POS_FRAMES = 1 + 30CAP_PROP_FRAME_WIDTH = 3 + 31CAP_PROP_FRAME_HEIGHT = 4 + 32CAP_PROP_FPS = 5 + 33CAP_PROP_FRAME_COUNT = 7 + 34 + 35FONT_HERSHEY_SIMPLEX = 0 + 36FONT_HERSHEY_PLAIN = 1 + 37FONT_HERSHEY_DUPLEX = 2 + 38FONT_HERSHEY_COMPLEX = 3 + 39FONT_HERSHEY_TRIPLEX = 4 + 40FONT_HERSHEY_COMPLEX_SMALL = 5 + 41FONT_HERSHEY_SCRIPT_SIMPLEX = 6 + 42FONT_HERSHEY_SCRIPT_COMPLEX = 7 + 43FONT_ITALIC = 16 + 44 + 45FILLED = -1 + 46LINE_4 = 4 + 47LINE_8 = 8 + 48LINE_AA = 16 + 49 + 50_inline_mat = vf.Filter("_inline_mat") + 51_slice_mat = vf.Filter("_slice_mat") + 52_slice_write_mat = vf.Filter("_slice_write_mat") + 53 + 54 + 55_filter_scale = vf.Filter("Scale") + 56_filter_rectangle = vf.Filter("cv2.rectangle") + 57_filter_putText = vf.Filter("cv2.putText") + 58_filter_arrowedLine = vf.Filter("cv2.arrowedLine") + 59_filter_line = vf.Filter("cv2.line") + 60_filter_circle = vf.Filter("cv2.circle") + 61_filter_addWeighted = vf.Filter("cv2.addWeighted") + 62 + 63 + 64def _ts_to_fps(timestamps): + 65 return int(1 / (timestamps[1] - timestamps[0])) # TODO: Fix for non-integer fps + 66 + 67 + 68def _fps_to_ts(fps, n_frames): + 69 assert type(fps) == int + 70 return [Fraction(i, fps) for i in range(n_frames)] + 71 + 72 + 73_global_cv2_server = None + 74 + 75 + 76def _server(): + 77 global _global_cv2_server + 78 if _global_cv2_server is None: + 79 _global_cv2_server = vf.YrdenServer() + 80 return _global_cv2_server + 81 + 82 + 83def set_cv2_server(server): + 84 """Set the server to use for the cv2 frontend.""" + 85 global _global_cv2_server + 86 assert isinstance(server, vf.YrdenServer) or isinstance(server, igni.IgniServer) + 87 _global_cv2_server = server + 88 + 89 + 90class Frame: + 91 def __init__(self, f, fmt): + 92 self._f = f + 93 self._fmt = fmt + 94 self.shape = (fmt["height"], fmt["width"], 3) + 95 + 96 # denotes that the frame has not yet been modified + 97 # when a frame is modified, it is converted to rgb24 first + 98 self._modified = False + 99 +100 def _mut(self): +101 if self._modified: +102 assert self._fmt["pix_fmt"] == "rgb24" +103 return +104 +105 self._modified = True +106 if self._fmt["pix_fmt"] != "rgb24": +107 self._f = _filter_scale(self._f, pix_fmt="rgb24") +108 self._fmt["pix_fmt"] = "rgb24" +109 +110 def numpy(self): +111 """ +112 Return the frame as a numpy array. +113 """ +114 +115 self._mut() +116 spec = vf.Spec([Fraction(0, 1)], lambda t, i: self._f, self._fmt) +117 loader = spec.load(_server()) +118 +119 frame_raster_rgb24 = loader[0] +120 assert type(frame_raster_rgb24) == bytes +121 assert len(frame_raster_rgb24) == self.shape[0] * self.shape[1] * 3 +122 raw_data_array = np.frombuffer(frame_raster_rgb24, dtype=np.uint8) +123 frame = raw_data_array.reshape(self.shape) +124 frame = frame[:, :, ::-1] # convert RGB to BGR +125 return frame +126 +127 def __getitem__(self, key): +128 if not isinstance(key, tuple): +129 raise NotImplementedError("Only 2D slicing is supported") +130 +131 if len(key) != 2: +132 raise NotImplementedError("Only 2D slicing is supported") +133 +134 if not all(isinstance(x, slice) for x in key): +135 raise NotImplementedError("Only 2D slicing is supported") +136 +137 miny = key[0].start if key[0].start is not None else 0 +138 maxy = key[0].stop if key[0].stop is not None else self.shape[0] +139 minx = key[1].start if key[1].start is not None else 0 +140 maxx = key[1].stop if key[1].stop is not None else self.shape[1] +141 +142 # handle negative indices +143 if miny < 0: +144 miny = self.shape[0] + miny +145 if maxy < 0: +146 maxy = self.shape[0] + maxy +147 if minx < 0: +148 minx = self.shape[1] + minx +149 if maxx < 0: +150 maxx = self.shape[1] + maxx +151 +152 if ( +153 maxy <= miny +154 or maxx <= minx +155 or miny < 0 +156 or minx < 0 +157 or maxy > self.shape[0] +158 or maxx > self.shape[1] +159 ): +160 raise NotImplementedError("Invalid slice") +161 +162 f = _slice_mat(self._f, miny, maxy, minx, maxx) +163 fmt = self._fmt.copy() +164 fmt["width"] = maxx - minx +165 fmt["height"] = maxy - miny +166 return Frame(f, fmt) +167 +168 def __setitem__(self, key, value): +169 value = frameify(value, "value") +170 +171 if not isinstance(key, tuple): +172 raise NotImplementedError("Only 2D slicing is supported") +173 +174 if len(key) != 2: +175 raise NotImplementedError("Only 2D slicing is supported") +176 +177 if not all(isinstance(x, slice) for x in key): +178 raise NotImplementedError("Only 2D slicing is supported") +179 +180 miny = key[0].start if key[0].start is not None else 0 +181 maxy = key[0].stop if key[0].stop is not None else self.shape[0] +182 minx = key[1].start if key[1].start is not None else 0 +183 maxx = key[1].stop if key[1].stop is not None else self.shape[1] +184 +185 # handle negative indices +186 if miny < 0: +187 miny = self.shape[0] + miny +188 if maxy < 0: +189 maxy = self.shape[0] + maxy +190 if minx < 0: +191 minx = self.shape[1] + minx +192 if maxx < 0: +193 maxx = self.shape[1] + maxx +194 +195 if ( +196 maxy <= miny +197 or maxx <= minx +198 or miny < 0 +199 or minx < 0 +200 or maxy > self.shape[0] +201 or maxx > self.shape[1] +202 ): +203 raise NotImplementedError("Invalid slice") +204 +205 if value.shape[0] != maxy - miny or value.shape[1] != maxx - minx: +206 raise NotImplementedError("Shape mismatch") +207 +208 self._mut() +209 value._mut() +210 +211 self._f = _slice_write_mat(self._f, value._f, miny, maxy, minx, maxx) +212 +213 +214def _inline_frame(arr): +215 if arr.dtype != np.uint8: +216 raise Exception("Only uint8 arrays are supported") +217 if len(arr.shape) != 3: +218 raise Exception("Only 3D arrays are supported") +219 if arr.shape[2] != 3: +220 raise Exception("To inline a frame, the array must have 3 channels") +221 +222 arr = arr[:, :, ::-1] +223 if not arr.flags["C_CONTIGUOUS"]: +224 arr = np.ascontiguousarray(arr) +225 +226 width = arr.shape[1] +227 height = arr.shape[0] +228 pix_fmt = "rgb24" +229 +230 data_gzip = zlib.compress(memoryview(arr), level=1) +231 +232 f = _inline_mat( +233 data_gzip, width=width, height=height, pix_fmt=pix_fmt, compression="zlib" +234 ) +235 fmt = {"width": width, "height": height, "pix_fmt": pix_fmt} +236 +237 # Return the resulting Frame object +238 return Frame(f, fmt) +239 +240 +241class VideoCapture: +242 def __init__(self, path): +243 server = _server() +244 if type(path) == str: +245 assert isinstance(server, vf.YrdenServer) +246 self._path = path +247 self._source = vf.Source(server, str(uuid.uuid4()), path, 0) +248 elif isinstance(path, igni.IgniSource): +249 assert isinstance(server, igni.IgniServer) +250 self._path = path._name +251 self._source = path +252 self._next_frame_idx = 0 +253 +254 def isOpened(self): +255 return True +256 +257 def get(self, prop): +258 if prop == CAP_PROP_FPS: +259 return _ts_to_fps(self._source.ts()) +260 elif prop == CAP_PROP_FRAME_WIDTH: +261 return self._source.fmt()["width"] +262 elif prop == CAP_PROP_FRAME_HEIGHT: +263 return self._source.fmt()["height"] +264 elif prop == CAP_PROP_FRAME_COUNT: +265 return len(self._source.ts()) +266 elif prop == CAP_PROP_POS_FRAMES: +267 return self._next_frame_idx +268 +269 raise Exception(f"Unknown property {prop}") +270 +271 def set(self, prop, value): +272 if prop == CAP_PROP_POS_FRAMES: +273 assert value >= 0 and value < len(self._source.ts()) +274 self._next_frame_idx = value +275 elif prop == CAP_PROP_POS_MSEC: +276 t = Fraction(value, 1000) +277 ts = self._source.ts() +278 next_frame_idx = bisect_right(ts, t) +279 self._next_frame_idx = next_frame_idx +280 else: +281 raise Exception(f"Unsupported property {prop}") +282 +283 def read(self): +284 if self._next_frame_idx >= len(self._source): +285 return False, None +286 frame = self._source.iloc[self._next_frame_idx] +287 self._next_frame_idx += 1 +288 frame = Frame(frame, self._source.fmt()) +289 return True, frame +290 +291 def release(self): +292 pass +293 +294 +295class VideoWriter: +296 def __init__(self, *args, **kwargs): +297 server = _server() +298 if isinstance(server, vf.YrdenServer): +299 self._writer = _YrdenVideoWriter(*args, **kwargs) +300 elif isinstance(server, igni.IgniServer): +301 self._writer = _IgniVideoWriter(*args, **kwargs) +302 else: +303 raise Exception("Unsupported server type") +304 +305 def write(self, *args, **kwargs): +306 return self._writer.write(*args, **kwargs) +307 +308 def release(self, *args, **kwargs): +309 return self._writer.release(*args, **kwargs) +310 +311 def spec(self, *args, **kwargs): +312 return self._writer.spec(*args, **kwargs) +313 +314 +315class _IgniVideoWriter: +316 def __init__(self, spec, _fourcc, fps, size, batch_size=128): +317 server = _server() +318 assert isinstance(spec, igni.IgniSpec) +319 assert isinstance(server, igni.IgniServer) +320 self._spec = spec +321 if isinstance(fps, int): +322 self._f_time = Fraction(1, fps) +323 elif isinstance(fps, Fraction): +324 self._f_time = 1 / fps +325 else: +326 raise Exception("fps must be an integer or a Fraction") +327 +328 assert isinstance(size, tuple) or isinstance(size, list) +329 assert len(size) == 2 +330 assert size[0] == spec._fmt["width"] +331 assert size[1] == spec._fmt["height"] +332 +333 self._batch_size = batch_size +334 self._idx = 0 +335 self._frame_buffer = [] +336 +337 def _flush(self, terminal=False): +338 server = _server() +339 server.push_spec_part( +340 self._spec, +341 self._idx - len(self._frame_buffer), +342 self._frame_buffer, +343 terminal=terminal, +344 ) +345 self._frame_buffer = [] +346 +347 def _explicit_terminate(self): +348 server = _server() +349 server.push_spec_part(self._spec._id, self._idx, [], terminal=True) +350 +351 def write(self, frame): +352 if frame is not None: +353 frame = frameify(frame, "frame") +354 if frame._fmt["width"] != self._spec._fmt["width"]: +355 raise Exception( +356 f"Frame type error; expected width {self._spec._fmt['width']}, got {frame._fmt['width']}" +357 ) +358 if frame._fmt["height"] != self._spec._fmt["height"]: +359 raise Exception( +360 f"Frame type error; expected height {self._spec._fmt['height']}, got {frame._fmt['height']}" +361 ) +362 if frame._fmt["pix_fmt"] != self._spec._fmt["pix_fmt"]: +363 f_obj = _filter_scale(frame._f, pix_fmt=self._spec._fmt["pix_fmt"]) +364 frame = Frame(f_obj, self._spec._fmt) +365 t = self._f_time * self._idx +366 self._frame_buffer.append((t, frame._f if frame is not None else None)) +367 self._idx += 1 +368 +369 if len(self._frame_buffer) >= self._batch_size: +370 self._flush() +371 +372 def release(self): +373 if len(self._frame_buffer) > 0: +374 self._flush(True) +375 else: +376 self._explicit_terminate() +377 +378 +379class _YrdenVideoWriter: +380 def __init__(self, path, fourcc, fps, size): +381 assert isinstance(fourcc, VideoWriter_fourcc) +382 if path is not None and not isinstance(path, str): +383 raise Exception("path must be a string or None") +384 self._path = path +385 self._fourcc = fourcc +386 self._fps = fps +387 self._size = size +388 +389 self._frames = [] +390 self._pix_fmt = "yuv420p" +391 +392 def write(self, frame): +393 frame = frameify(frame, "frame") +394 +395 if frame._fmt["pix_fmt"] != self._pix_fmt: +396 f_obj = _filter_scale(frame._f, pix_fmt=self._pix_fmt) +397 self._frames.append(f_obj) +398 else: +399 self._frames.append(frame._f) +400 +401 def release(self): +402 if self._path is None: +403 return +404 +405 spec = self.spec() +406 server = _server() +407 spec.save(server, self._path) +408 +409 def spec(self) -> vf.Spec: +410 fmt = { +411 "width": self._size[0], +412 "height": self._size[1], +413 "pix_fmt": self._pix_fmt, +414 } +415 domain = _fps_to_ts(self._fps, len(self._frames)) +416 spec = vf.Spec(domain, lambda t, i: self._frames[i], fmt) +417 return spec +418 +419 +420class VideoWriter_fourcc: +421 def __init__(self, *args): +422 self._args = args +423 +424 +425def frameify(obj, field_name=None): +426 """ +427 Turn an object (e.g., ndarray) into a Frame. +428 """ +429 +430 if isinstance(obj, Frame): +431 return obj +432 elif isinstance(obj, np.ndarray): +433 return _inline_frame(obj) +434 else: +435 if field_name is not None: +436 raise Exception( +437 f"Unsupported type for field {field_name}, expected Frame or np.ndarray" +438 ) +439 else: +440 raise Exception("Unsupported type, expected Frame or np.ndarray") +441 +442 +443def imread(path, *args): +444 if len(args) > 0: +445 raise NotImplementedError("imread does not support additional arguments") +446 +447 assert path.lower().endswith((".jpg", ".jpeg", ".png")) +448 server = _server() +449 source = vf.Source(server, str(uuid.uuid4()), path, 0) +450 frame = Frame(source.iloc[0], source.fmt()) +451 return frame +452 +453 +454def imwrite(path, img, *args): +455 if len(args) > 0: +456 raise NotImplementedError("imwrite does not support additional arguments") +457 +458 img = frameify(img) +459 +460 fmt = img._fmt.copy() +461 width = fmt["width"] +462 height = fmt["height"] +463 f = img._f +464 +465 domain = [Fraction(0, 1)] +466 +467 if path.lower().endswith(".png"): +468 img._mut() # Make sure it's in rgb24 +469 spec = vf.Spec( +470 domain, +471 lambda t, i: img._f, +472 {"width": width, "height": height, "pix_fmt": "rgb24"}, +473 ) +474 spec.save(_server(), path, encoder="png") +475 elif path.lower().endswith((".jpg", ".jpeg")): +476 if img._modified: +477 # it's rgb24, we need to convert to something jpeg can handle +478 f = _filter_scale(img._f, pix_fmt="yuv420p") +479 fmt["pix_fmt"] = "yuv420p" +480 else: +481 if fmt["pix_fmt"] not in ["yuvj420p", "yuvj422p", "yuvj444p"]: +482 f = _filter_scale(img._f, pix_fmt="yuvj420p") +483 fmt["pix_fmt"] = "yuvj420p" +484 +485 spec = vf.Spec(domain, lambda t, i: f, fmt) +486 spec.save(_server(), path, encoder="mjpeg") +487 else: +488 raise Exception("Unsupported image format") +489 +490 +491def vidplay(video, *args, **kwargs): +492 """ +493 Play a vidformer video specification. +494 +495 Args: +496 video: one of [vidformer.Spec, vidformer.Source, vidformer.cv2.VideoWriter] +497 """ +498 +499 if isinstance(video, vf.Spec): +500 return video.play(_server(), *args, **kwargs) +501 elif isinstance(video, vf.Source): +502 return video.play(_server(), *args, **kwargs) +503 elif isinstance(video, VideoWriter): +504 return video.spec().play(_server(), *args, **kwargs) +505 elif isinstance(video, igni.IgniSpec): +506 return video.play(*args, **kwargs) +507 else: +508 raise Exception("Unsupported video type to vidplay") +509 +510 +511def rectangle(img, pt1, pt2, color, thickness=None, lineType=None, shift=None): +512 """ +513 cv.rectangle( img, pt1, pt2, color[, thickness[, lineType[, shift]]] ) +514 """ +515 +516 img = frameify(img) +517 img._mut() +518 +519 assert len(pt1) == 2 +520 assert len(pt2) == 2 +521 assert all(isinstance(x, int) for x in pt1) +522 assert all(isinstance(x, int) for x in pt2) +523 +524 assert len(color) == 3 or len(color) == 4 +525 color = [float(x) for x in color] +526 if len(color) == 3: +527 color.append(255.0) +528 +529 args = [] +530 if thickness is not None: +531 assert isinstance(thickness, int) +532 args.append(thickness) +533 if lineType is not None: +534 assert isinstance(lineType, int) +535 assert thickness is not None +536 args.append(lineType) +537 if shift is not None: +538 assert isinstance(shift, int) +539 assert shift is not None +540 args.append(shift) +541 +542 img._f = _filter_rectangle(img._f, pt1, pt2, color, *args) +543 +544 +545def putText( +546 img, +547 text, +548 org, +549 fontFace, +550 fontScale, +551 color, +552 thickness=None, +553 lineType=None, +554 bottomLeftOrigin=None, +555): +556 """ +557 cv.putText( img, text, org, fontFace, fontScale, color[, thickness[, lineType[, bottomLeftOrigin]]] ) +558 """ +559 +560 img = frameify(img) +561 img._mut() +562 +563 assert isinstance(text, str) +564 +565 assert len(org) == 2 +566 assert all(isinstance(x, int) for x in org) +567 +568 assert isinstance(fontFace, int) +569 assert isinstance(fontScale, float) or isinstance(fontScale, int) +570 fontScale = float(fontScale) +571 +572 assert len(color) == 3 or len(color) == 4 +573 color = [float(x) for x in color] +574 if len(color) == 3: +575 color.append(255.0) +576 +577 args = [] +578 if thickness is not None: +579 assert isinstance(thickness, int) +580 args.append(thickness) +581 if lineType is not None: +582 assert isinstance(lineType, int) +583 assert thickness is not None +584 args.append(lineType) +585 if bottomLeftOrigin is not None: +586 assert isinstance(bottomLeftOrigin, bool) +587 assert lineType is not None +588 args.append(bottomLeftOrigin) +589 +590 img._f = _filter_putText(img._f, text, org, fontFace, fontScale, color, *args) +591 +592 +593def arrowedLine( +594 img, pt1, pt2, color, thickness=None, line_type=None, shift=None, tipLength=None +595): +596 """ +597 cv.arrowedLine( img, pt1, pt2, color[, thickness[, line_type[, shift[, tipLength]]]] ) +598 """ +599 img = frameify(img) +600 img._mut() +601 +602 assert len(pt1) == 2 +603 assert len(pt2) == 2 +604 assert all(isinstance(x, int) for x in pt1) +605 assert all(isinstance(x, int) for x in pt2) +606 +607 assert len(color) == 3 or len(color) == 4 +608 color = [float(x) for x in color] +609 if len(color) == 3: +610 color.append(255.0) +611 +612 args = [] +613 if thickness is not None: +614 assert isinstance(thickness, int) +615 args.append(thickness) +616 if line_type is not None: +617 assert isinstance(line_type, int) +618 assert thickness is not None +619 args.append(line_type) +620 if shift is not None: +621 assert isinstance(shift, int) +622 assert shift is not None +623 args.append(shift) +624 if tipLength is not None: +625 assert isinstance(tipLength, float) +626 assert shift is not None +627 args.append(tipLength) +628 +629 img._f = _filter_arrowedLine(img._f, pt1, pt2, color, *args) +630 +631 +632def line(img, pt1, pt2, color, thickness=None, lineType=None, shift=None): +633 img = frameify(img) +634 img._mut() +635 +636 assert len(pt1) == 2 +637 assert len(pt2) == 2 +638 assert all(isinstance(x, int) for x in pt1) +639 assert all(isinstance(x, int) for x in pt2) +640 +641 assert len(color) == 3 or len(color) == 4 +642 color = [float(x) for x in color] +643 if len(color) == 3: +644 color.append(255.0) +645 +646 args = [] +647 if thickness is not None: +648 assert isinstance(thickness, int) +649 args.append(thickness) +650 if lineType is not None: +651 assert isinstance(lineType, int) +652 assert thickness is not None +653 args.append(lineType) +654 if shift is not None: +655 assert isinstance(shift, int) +656 assert shift is not None +657 args.append(shift) +658 +659 img._f = _filter_line(img._f, pt1, pt2, color, *args) +660 +661 +662def circle(img, center, radius, color, thickness=None, lineType=None, shift=None): +663 img = frameify(img) +664 img._mut() +665 +666 assert len(center) == 2 +667 assert all(isinstance(x, int) for x in center) +668 +669 assert isinstance(radius, int) +670 +671 assert len(color) == 3 or len(color) == 4 +672 color = [float(x) for x in color] +673 if len(color) == 3: +674 color.append(255.0) +675 +676 args = [] +677 if thickness is not None: +678 assert isinstance(thickness, int) +679 args.append(thickness) +680 if lineType is not None: +681 assert isinstance(lineType, int) +682 assert thickness is not None +683 args.append(lineType) +684 if shift is not None: +685 assert isinstance(shift, int) +686 assert shift is not None +687 args.append(shift) +688 +689 img._f = _filter_circle(img._f, center, radius, color, *args) +690 +691 +692def getFontScaleFromHeight(*args, **kwargs): +693 """ +694 cv.getFontScaleFromHeight( fontFace, pixelHeight[, thickness] ) +695 """ +696 if _opencv2 is None: +697 raise NotImplementedError("getFontScaleFromHeight requires the cv2 module") +698 return _opencv2.getFontScaleFromHeight(*args, **kwargs) +699 +700 +701def getTextSize(*args, **kwargs): +702 """ +703 cv.getTextSize( text, fontFace, fontScale, thickness ) +704 """ +705 if _opencv2 is None: +706 raise NotImplementedError("getTextSize requires the cv2 module") +707 return _opencv2.getTextSize(*args, **kwargs) +708 +709 +710def addWeighted(src1, alpha, src2, beta, gamma, dst=None, dtype=-1): +711 """ +712 cv.addWeighted( src1, alpha, src2, beta, gamma[, dst[, dtype]] ) -> dst +713 """ +714 src1 = frameify(src1, "src1") +715 src2 = frameify(src2, "src2") +716 src1._mut() +717 src2._mut() +718 +719 if dst is None: +720 dst = Frame(src1._f, src1._fmt.copy()) +721 else: +722 assert isinstance(dst, Frame), "dst must be a Frame" +723 dst._mut() +724 +725 assert isinstance(alpha, float) or isinstance(alpha, int) +726 assert isinstance(beta, float) or isinstance(beta, int) +727 assert isinstance(gamma, float) or isinstance(gamma, int) +728 alpha = float(alpha) +729 beta = float(beta) +730 gamma = float(gamma) +731 +732 if dtype != -1: +733 raise Exception("addWeighted does not support the dtype argument") +734 +735 dst._f = _filter_addWeighted(src1._f, alpha, src2._f, beta, gamma) +736 return dst +737 +738 +739# Stubs for unimplemented functions +740 +741 +742def clipLine(*args, **kwargs): +743 raise NotImplementedError("clipLine is not yet implemented in the cv2 frontend") +744 +745 +746def drawContours(*args, **kwargs): +747 raise NotImplementedError("drawContours is not yet implemented in the cv2 frontend") +748 +749 +750def drawMarker(*args, **kwargs): +751 raise NotImplementedError("drawMarker is not yet implemented in the cv2 frontend") +752 +753 +754def ellipse(*args, **kwargs): +755 raise NotImplementedError("ellipse is not yet implemented in the cv2 frontend") +756 +757 +758def ellipse2Poly(*args, **kwargs): +759 raise NotImplementedError("ellipse2Poly is not yet implemented in the cv2 frontend") +760 +761 +762def fillConvexPoly(*args, **kwargs): +763 raise NotImplementedError( +764 "fillConvexPoly is not yet implemented in the cv2 frontend" +765 ) +766 +767 +768def fillPoly(*args, **kwargs): +769 raise NotImplementedError("fillPoly is not yet implemented in the cv2 frontend") +770 +771 +772def polylines(*args, **kwargs): +773 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):
+
+
+
+
+
+ 84def set_cv2_server(server): +85 """Set the server to use for the cv2 frontend.""" +86 global _global_cv2_server +87 assert isinstance(server, vf.YrdenServer) or isinstance(server, igni.IgniServer) +88 _global_cv2_server = server +
Set the server to use for the cv2 frontend.
+
+
+ class
+ Frame:
+
+
+
+
+
+ 91class Frame: + 92 def __init__(self, f, fmt): + 93 self._f = f + 94 self._fmt = fmt + 95 self.shape = (fmt["height"], fmt["width"], 3) + 96 + 97 # denotes that the frame has not yet been modified + 98 # when a frame is modified, it is converted to rgb24 first + 99 self._modified = False +100 +101 def _mut(self): +102 if self._modified: +103 assert self._fmt["pix_fmt"] == "rgb24" +104 return +105 +106 self._modified = True +107 if self._fmt["pix_fmt"] != "rgb24": +108 self._f = _filter_scale(self._f, pix_fmt="rgb24") +109 self._fmt["pix_fmt"] = "rgb24" +110 +111 def numpy(self): +112 """ +113 Return the frame as a numpy array. +114 """ +115 +116 self._mut() +117 spec = vf.Spec([Fraction(0, 1)], lambda t, i: self._f, self._fmt) +118 loader = spec.load(_server()) +119 +120 frame_raster_rgb24 = loader[0] +121 assert type(frame_raster_rgb24) == bytes +122 assert len(frame_raster_rgb24) == self.shape[0] * self.shape[1] * 3 +123 raw_data_array = np.frombuffer(frame_raster_rgb24, dtype=np.uint8) +124 frame = raw_data_array.reshape(self.shape) +125 frame = frame[:, :, ::-1] # convert RGB to BGR +126 return frame +127 +128 def __getitem__(self, key): +129 if not isinstance(key, tuple): +130 raise NotImplementedError("Only 2D slicing is supported") +131 +132 if len(key) != 2: +133 raise NotImplementedError("Only 2D slicing is supported") +134 +135 if not all(isinstance(x, slice) for x in key): +136 raise NotImplementedError("Only 2D slicing is supported") +137 +138 miny = key[0].start if key[0].start is not None else 0 +139 maxy = key[0].stop if key[0].stop is not None else self.shape[0] +140 minx = key[1].start if key[1].start is not None else 0 +141 maxx = key[1].stop if key[1].stop is not None else self.shape[1] +142 +143 # handle negative indices +144 if miny < 0: +145 miny = self.shape[0] + miny +146 if maxy < 0: +147 maxy = self.shape[0] + maxy +148 if minx < 0: +149 minx = self.shape[1] + minx +150 if maxx < 0: +151 maxx = self.shape[1] + maxx +152 +153 if ( +154 maxy <= miny +155 or maxx <= minx +156 or miny < 0 +157 or minx < 0 +158 or maxy > self.shape[0] +159 or maxx > self.shape[1] +160 ): +161 raise NotImplementedError("Invalid slice") +162 +163 f = _slice_mat(self._f, miny, maxy, minx, maxx) +164 fmt = self._fmt.copy() +165 fmt["width"] = maxx - minx +166 fmt["height"] = maxy - miny +167 return Frame(f, fmt) +168 +169 def __setitem__(self, key, value): +170 value = frameify(value, "value") +171 +172 if not isinstance(key, tuple): +173 raise NotImplementedError("Only 2D slicing is supported") +174 +175 if len(key) != 2: +176 raise NotImplementedError("Only 2D slicing is supported") +177 +178 if not all(isinstance(x, slice) for x in key): +179 raise NotImplementedError("Only 2D slicing is supported") +180 +181 miny = key[0].start if key[0].start is not None else 0 +182 maxy = key[0].stop if key[0].stop is not None else self.shape[0] +183 minx = key[1].start if key[1].start is not None else 0 +184 maxx = key[1].stop if key[1].stop is not None else self.shape[1] +185 +186 # handle negative indices +187 if miny < 0: +188 miny = self.shape[0] + miny +189 if maxy < 0: +190 maxy = self.shape[0] + maxy +191 if minx < 0: +192 minx = self.shape[1] + minx +193 if maxx < 0: +194 maxx = self.shape[1] + maxx +195 +196 if ( +197 maxy <= miny +198 or maxx <= minx +199 or miny < 0 +200 or minx < 0 +201 or maxy > self.shape[0] +202 or maxx > self.shape[1] +203 ): +204 raise NotImplementedError("Invalid slice") +205 +206 if value.shape[0] != maxy - miny or value.shape[1] != maxx - minx: +207 raise NotImplementedError("Shape mismatch") +208 +209 self._mut() +210 value._mut() +211 +212 self._f = _slice_write_mat(self._f, value._f, miny, maxy, minx, maxx) +
+
+
+
+
+
+
+
+
+
+
+ def
+ numpy(self):
+
+
+
+
+
+ 111 def numpy(self): +112 """ +113 Return the frame as a numpy array. +114 """ +115 +116 self._mut() +117 spec = vf.Spec([Fraction(0, 1)], lambda t, i: self._f, self._fmt) +118 loader = spec.load(_server()) +119 +120 frame_raster_rgb24 = loader[0] +121 assert type(frame_raster_rgb24) == bytes +122 assert len(frame_raster_rgb24) == self.shape[0] * self.shape[1] * 3 +123 raw_data_array = np.frombuffer(frame_raster_rgb24, dtype=np.uint8) +124 frame = raw_data_array.reshape(self.shape) +125 frame = frame[:, :, ::-1] # convert RGB to BGR +126 return frame +
Return the frame as a numpy array.
+
+
+ class
+ VideoCapture:
+
+
+
+
+
+ 242class VideoCapture: +243 def __init__(self, path): +244 server = _server() +245 if type(path) == str: +246 assert isinstance(server, vf.YrdenServer) +247 self._path = path +248 self._source = vf.Source(server, str(uuid.uuid4()), path, 0) +249 elif isinstance(path, igni.IgniSource): +250 assert isinstance(server, igni.IgniServer) +251 self._path = path._name +252 self._source = path +253 self._next_frame_idx = 0 +254 +255 def isOpened(self): +256 return True +257 +258 def get(self, prop): +259 if prop == CAP_PROP_FPS: +260 return _ts_to_fps(self._source.ts()) +261 elif prop == CAP_PROP_FRAME_WIDTH: +262 return self._source.fmt()["width"] +263 elif prop == CAP_PROP_FRAME_HEIGHT: +264 return self._source.fmt()["height"] +265 elif prop == CAP_PROP_FRAME_COUNT: +266 return len(self._source.ts()) +267 elif prop == CAP_PROP_POS_FRAMES: +268 return self._next_frame_idx +269 +270 raise Exception(f"Unknown property {prop}") +271 +272 def set(self, prop, value): +273 if prop == CAP_PROP_POS_FRAMES: +274 assert value >= 0 and value < len(self._source.ts()) +275 self._next_frame_idx = value +276 elif prop == CAP_PROP_POS_MSEC: +277 t = Fraction(value, 1000) +278 ts = self._source.ts() +279 next_frame_idx = bisect_right(ts, t) +280 self._next_frame_idx = next_frame_idx +281 else: +282 raise Exception(f"Unsupported property {prop}") +283 +284 def read(self): +285 if self._next_frame_idx >= len(self._source): +286 return False, None +287 frame = self._source.iloc[self._next_frame_idx] +288 self._next_frame_idx += 1 +289 frame = Frame(frame, self._source.fmt()) +290 return True, frame +291 +292 def release(self): +293 pass +
+
+
+
+
+
+
+
+
+
+
+ VideoCapture(path)
+
+
+
+
+
+ 243 def __init__(self, path): +244 server = _server() +245 if type(path) == str: +246 assert isinstance(server, vf.YrdenServer) +247 self._path = path +248 self._source = vf.Source(server, str(uuid.uuid4()), path, 0) +249 elif isinstance(path, igni.IgniSource): +250 assert isinstance(server, igni.IgniServer) +251 self._path = path._name +252 self._source = path +253 self._next_frame_idx = 0 +
+
+
+
+
+
+
+
+
+
+ def
+ get(self, prop):
+
+
+
+
+
+ 258 def get(self, prop): +259 if prop == CAP_PROP_FPS: +260 return _ts_to_fps(self._source.ts()) +261 elif prop == CAP_PROP_FRAME_WIDTH: +262 return self._source.fmt()["width"] +263 elif prop == CAP_PROP_FRAME_HEIGHT: +264 return self._source.fmt()["height"] +265 elif prop == CAP_PROP_FRAME_COUNT: +266 return len(self._source.ts()) +267 elif prop == CAP_PROP_POS_FRAMES: +268 return self._next_frame_idx +269 +270 raise Exception(f"Unknown property {prop}") +
+
+
+
+
+
+
+
+
+
+
+
+ def
+ set(self, prop, value):
+
+
+
+
+
+ 272 def set(self, prop, value): +273 if prop == CAP_PROP_POS_FRAMES: +274 assert value >= 0 and value < len(self._source.ts()) +275 self._next_frame_idx = value +276 elif prop == CAP_PROP_POS_MSEC: +277 t = Fraction(value, 1000) +278 ts = self._source.ts() +279 next_frame_idx = bisect_right(ts, t) +280 self._next_frame_idx = next_frame_idx +281 else: +282 raise Exception(f"Unsupported property {prop}") +
+
+ class
+ VideoWriter:
+
+
+
+
+
+ 296class VideoWriter: +297 def __init__(self, *args, **kwargs): +298 server = _server() +299 if isinstance(server, vf.YrdenServer): +300 self._writer = _YrdenVideoWriter(*args, **kwargs) +301 elif isinstance(server, igni.IgniServer): +302 self._writer = _IgniVideoWriter(*args, **kwargs) +303 else: +304 raise Exception("Unsupported server type") +305 +306 def write(self, *args, **kwargs): +307 return self._writer.write(*args, **kwargs) +308 +309 def release(self, *args, **kwargs): +310 return self._writer.release(*args, **kwargs) +311 +312 def spec(self, *args, **kwargs): +313 return self._writer.spec(*args, **kwargs) +
+
+
+
+
+
+
+
+
+
+
+
+
+ VideoWriter(*args, **kwargs)
+
+
+
+
+
+ 297 def __init__(self, *args, **kwargs): +298 server = _server() +299 if isinstance(server, vf.YrdenServer): +300 self._writer = _YrdenVideoWriter(*args, **kwargs) +301 elif isinstance(server, igni.IgniServer): +302 self._writer = _IgniVideoWriter(*args, **kwargs) +303 else: +304 raise Exception("Unsupported server type") +
+
+ class
+ VideoWriter_fourcc:
+
+
+
+
+
+
+
+
+
+
+
+
+
+ def
+ frameify(obj, field_name=None):
+
+
+
+
+
+ 426def frameify(obj, field_name=None): +427 """ +428 Turn an object (e.g., ndarray) into a Frame. +429 """ +430 +431 if isinstance(obj, Frame): +432 return obj +433 elif isinstance(obj, np.ndarray): +434 return _inline_frame(obj) +435 else: +436 if field_name is not None: +437 raise Exception( +438 f"Unsupported type for field {field_name}, expected Frame or np.ndarray" +439 ) +440 else: +441 raise Exception("Unsupported type, expected Frame or np.ndarray") +
Turn an object (e.g., ndarray) into a Frame.
+
+
+ def
+ imread(path, *args):
+
+
+
+
+
+ 444def imread(path, *args): +445 if len(args) > 0: +446 raise NotImplementedError("imread does not support additional arguments") +447 +448 assert path.lower().endswith((".jpg", ".jpeg", ".png")) +449 server = _server() +450 source = vf.Source(server, str(uuid.uuid4()), path, 0) +451 frame = Frame(source.iloc[0], source.fmt()) +452 return frame +
+
+ def
+ imwrite(path, img, *args):
+
+
+
+
+
+ 455def imwrite(path, img, *args): +456 if len(args) > 0: +457 raise NotImplementedError("imwrite does not support additional arguments") +458 +459 img = frameify(img) +460 +461 fmt = img._fmt.copy() +462 width = fmt["width"] +463 height = fmt["height"] +464 f = img._f +465 +466 domain = [Fraction(0, 1)] +467 +468 if path.lower().endswith(".png"): +469 img._mut() # Make sure it's in rgb24 +470 spec = vf.Spec( +471 domain, +472 lambda t, i: img._f, +473 {"width": width, "height": height, "pix_fmt": "rgb24"}, +474 ) +475 spec.save(_server(), path, encoder="png") +476 elif path.lower().endswith((".jpg", ".jpeg")): +477 if img._modified: +478 # it's rgb24, we need to convert to something jpeg can handle +479 f = _filter_scale(img._f, pix_fmt="yuv420p") +480 fmt["pix_fmt"] = "yuv420p" +481 else: +482 if fmt["pix_fmt"] not in ["yuvj420p", "yuvj422p", "yuvj444p"]: +483 f = _filter_scale(img._f, pix_fmt="yuvj420p") +484 fmt["pix_fmt"] = "yuvj420p" +485 +486 spec = vf.Spec(domain, lambda t, i: f, fmt) +487 spec.save(_server(), path, encoder="mjpeg") +488 else: +489 raise Exception("Unsupported image format") +
+
+ def
+ vidplay(video, *args, **kwargs):
+
+
+
+
+
+ 492def vidplay(video, *args, **kwargs): +493 """ +494 Play a vidformer video specification. +495 +496 Args: +497 video: one of [vidformer.Spec, vidformer.Source, vidformer.cv2.VideoWriter] +498 """ +499 +500 if isinstance(video, vf.Spec): +501 return video.play(_server(), *args, **kwargs) +502 elif isinstance(video, vf.Source): +503 return video.play(_server(), *args, **kwargs) +504 elif isinstance(video, VideoWriter): +505 return video.spec().play(_server(), *args, **kwargs) +506 elif isinstance(video, igni.IgniSpec): +507 return video.play(*args, **kwargs) +508 else: +509 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):
+
+
+
+
+
+ 512def rectangle(img, pt1, pt2, color, thickness=None, lineType=None, shift=None): +513 """ +514 cv.rectangle( img, pt1, pt2, color[, thickness[, lineType[, shift]]] ) +515 """ +516 +517 img = frameify(img) +518 img._mut() +519 +520 assert len(pt1) == 2 +521 assert len(pt2) == 2 +522 assert all(isinstance(x, int) for x in pt1) +523 assert all(isinstance(x, int) for x in pt2) +524 +525 assert len(color) == 3 or len(color) == 4 +526 color = [float(x) for x in color] +527 if len(color) == 3: +528 color.append(255.0) +529 +530 args = [] +531 if thickness is not None: +532 assert isinstance(thickness, int) +533 args.append(thickness) +534 if lineType is not None: +535 assert isinstance(lineType, int) +536 assert thickness is not None +537 args.append(lineType) +538 if shift is not None: +539 assert isinstance(shift, int) +540 assert shift is not None +541 args.append(shift) +542 +543 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):
+
+
+
+
+
+ 546def putText( +547 img, +548 text, +549 org, +550 fontFace, +551 fontScale, +552 color, +553 thickness=None, +554 lineType=None, +555 bottomLeftOrigin=None, +556): +557 """ +558 cv.putText( img, text, org, fontFace, fontScale, color[, thickness[, lineType[, bottomLeftOrigin]]] ) +559 """ +560 +561 img = frameify(img) +562 img._mut() +563 +564 assert isinstance(text, str) +565 +566 assert len(org) == 2 +567 assert all(isinstance(x, int) for x in org) +568 +569 assert isinstance(fontFace, int) +570 assert isinstance(fontScale, float) or isinstance(fontScale, int) +571 fontScale = float(fontScale) +572 +573 assert len(color) == 3 or len(color) == 4 +574 color = [float(x) for x in color] +575 if len(color) == 3: +576 color.append(255.0) +577 +578 args = [] +579 if thickness is not None: +580 assert isinstance(thickness, int) +581 args.append(thickness) +582 if lineType is not None: +583 assert isinstance(lineType, int) +584 assert thickness is not None +585 args.append(lineType) +586 if bottomLeftOrigin is not None: +587 assert isinstance(bottomLeftOrigin, bool) +588 assert lineType is not None +589 args.append(bottomLeftOrigin) +590 +591 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):
+
+
+
+
+
+ 594def arrowedLine( +595 img, pt1, pt2, color, thickness=None, line_type=None, shift=None, tipLength=None +596): +597 """ +598 cv.arrowedLine( img, pt1, pt2, color[, thickness[, line_type[, shift[, tipLength]]]] ) +599 """ +600 img = frameify(img) +601 img._mut() +602 +603 assert len(pt1) == 2 +604 assert len(pt2) == 2 +605 assert all(isinstance(x, int) for x in pt1) +606 assert all(isinstance(x, int) for x in pt2) +607 +608 assert len(color) == 3 or len(color) == 4 +609 color = [float(x) for x in color] +610 if len(color) == 3: +611 color.append(255.0) +612 +613 args = [] +614 if thickness is not None: +615 assert isinstance(thickness, int) +616 args.append(thickness) +617 if line_type is not None: +618 assert isinstance(line_type, int) +619 assert thickness is not None +620 args.append(line_type) +621 if shift is not None: +622 assert isinstance(shift, int) +623 assert shift is not None +624 args.append(shift) +625 if tipLength is not None: +626 assert isinstance(tipLength, float) +627 assert shift is not None +628 args.append(tipLength) +629 +630 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):
+
+
+
+
+
+ 633def line(img, pt1, pt2, color, thickness=None, lineType=None, shift=None): +634 img = frameify(img) +635 img._mut() +636 +637 assert len(pt1) == 2 +638 assert len(pt2) == 2 +639 assert all(isinstance(x, int) for x in pt1) +640 assert all(isinstance(x, int) for x in pt2) +641 +642 assert len(color) == 3 or len(color) == 4 +643 color = [float(x) for x in color] +644 if len(color) == 3: +645 color.append(255.0) +646 +647 args = [] +648 if thickness is not None: +649 assert isinstance(thickness, int) +650 args.append(thickness) +651 if lineType is not None: +652 assert isinstance(lineType, int) +653 assert thickness is not None +654 args.append(lineType) +655 if shift is not None: +656 assert isinstance(shift, int) +657 assert shift is not None +658 args.append(shift) +659 +660 img._f = _filter_line(img._f, pt1, pt2, color, *args) +
+
+ def
+ circle( img, center, radius, color, thickness=None, lineType=None, shift=None):
+
+
+
+
+
+ 663def circle(img, center, radius, color, thickness=None, lineType=None, shift=None): +664 img = frameify(img) +665 img._mut() +666 +667 assert len(center) == 2 +668 assert all(isinstance(x, int) for x in center) +669 +670 assert isinstance(radius, int) +671 +672 assert len(color) == 3 or len(color) == 4 +673 color = [float(x) for x in color] +674 if len(color) == 3: +675 color.append(255.0) +676 +677 args = [] +678 if thickness is not None: +679 assert isinstance(thickness, int) +680 args.append(thickness) +681 if lineType is not None: +682 assert isinstance(lineType, int) +683 assert thickness is not None +684 args.append(lineType) +685 if shift is not None: +686 assert isinstance(shift, int) +687 assert shift is not None +688 args.append(shift) +689 +690 img._f = _filter_circle(img._f, center, radius, color, *args) +
+
+ def
+ getFontScaleFromHeight(*args, **kwargs):
+
+
+
+
+
+ 693def getFontScaleFromHeight(*args, **kwargs): +694 """ +695 cv.getFontScaleFromHeight( fontFace, pixelHeight[, thickness] ) +696 """ +697 if _opencv2 is None: +698 raise NotImplementedError("getFontScaleFromHeight requires the cv2 module") +699 return _opencv2.getFontScaleFromHeight(*args, **kwargs) +
cv.getFontScaleFromHeight( fontFace, pixelHeight[, thickness] )
+
+
+ def
+ getTextSize(*args, **kwargs):
+
+
+
+
+
+ 702def getTextSize(*args, **kwargs): +703 """ +704 cv.getTextSize( text, fontFace, fontScale, thickness ) +705 """ +706 if _opencv2 is None: +707 raise NotImplementedError("getTextSize requires the cv2 module") +708 return _opencv2.getTextSize(*args, **kwargs) +
cv.getTextSize( text, fontFace, fontScale, thickness )
+
+
+ def
+ addWeighted(src1, alpha, src2, beta, gamma, dst=None, dtype=-1):
+
+
+
+
+
+ 711def addWeighted(src1, alpha, src2, beta, gamma, dst=None, dtype=-1): +712 """ +713 cv.addWeighted( src1, alpha, src2, beta, gamma[, dst[, dtype]] ) -> dst +714 """ +715 src1 = frameify(src1, "src1") +716 src2 = frameify(src2, "src2") +717 src1._mut() +718 src2._mut() +719 +720 if dst is None: +721 dst = Frame(src1._f, src1._fmt.copy()) +722 else: +723 assert isinstance(dst, Frame), "dst must be a Frame" +724 dst._mut() +725 +726 assert isinstance(alpha, float) or isinstance(alpha, int) +727 assert isinstance(beta, float) or isinstance(beta, int) +728 assert isinstance(gamma, float) or isinstance(gamma, int) +729 alpha = float(alpha) +730 beta = float(beta) +731 gamma = float(gamma) +732 +733 if dtype != -1: +734 raise Exception("addWeighted does not support the dtype argument") +735 +736 dst._f = _filter_addWeighted(src1._f, alpha, src2._f, beta, gamma) +737 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..785e62b --- /dev/null +++ b/vidformer-py/vidformer/vf.html @@ -0,0 +1,3245 @@ + + + + + + +
+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 + 55def _play(namespace, hls_video_url, hls_js_url, method="html", status_url=None): + 56 # The namespace is so multiple videos in one tab don't conflict + 57 + 58 if method == "html": + 59 from IPython.display import HTML + 60 + 61 if not status_url: + 62 html_code = f""" + 63<!DOCTYPE html> + 64<html> + 65<head> + 66 <title>HLS Video Player</title> + 67 <!-- Include hls.js library --> + 68 <script src="{hls_js_url}"></script> + 69</head> + 70<body> + 71 <video id="video-{namespace}" controls width="640" height="360" autoplay></video> + 72 <script> + 73 var video = document.getElementById('video-{namespace}'); + 74 var videoSrc = '{hls_video_url}'; + 75 + 76 if (Hls.isSupported()) {{ + 77 var hls = new Hls(); + 78 hls.loadSource(videoSrc); + 79 hls.attachMedia(video); + 80 hls.on(Hls.Events.MANIFEST_PARSED, function() {{ + 81 video.play(); + 82 }}); + 83 }} else if (video.canPlayType('application/vnd.apple.mpegurl')) {{ + 84 video.src = videoSrc; + 85 video.addEventListener('loadedmetadata', function() {{ + 86 video.play(); + 87 }}); + 88 }} else {{ + 89 console.error('This browser does not appear to support HLS.'); + 90 }} + 91 </script> + 92</body> + 93</html> + 94""" + 95 return HTML(data=html_code) + 96 else: + 97 html_code = f""" + 98<!DOCTYPE html> + 99<html> + 100<head> + 101 <title>HLS Video Player</title> + 102 <script src="{hls_js_url}"></script> + 103</head> + 104<body> + 105 <div id="container"></div> + 106 <script> + 107 var statusUrl = '{status_url}'; + 108 var videoSrc = '{hls_video_url}'; + 109 var videoNamespace = '{namespace}'; + 110 + 111 function showWaiting() {{ + 112 document.getElementById('container').textContent = 'Waiting...'; + 113 pollStatus(); + 114 }} + 115 + 116 function pollStatus() {{ + 117 setTimeout(function() {{ + 118 fetch(statusUrl) + 119 .then(r => r.json()) + 120 .then(res => {{ + 121 if (res.ready) {{ + 122 document.getElementById('container').textContent = ''; + 123 attachHls(); + 124 }} else {{ + 125 pollStatus(); + 126 }} + 127 }}) + 128 .catch(e => {{ + 129 console.error(e); + 130 pollStatus(); + 131 }}); + 132 }}, 250); + 133 }} + 134 + 135 function attachHls() {{ + 136 var container = document.getElementById('container'); + 137 container.textContent = ''; + 138 var video = document.createElement('video'); + 139 video.id = 'video-' + videoNamespace; + 140 video.controls = true; + 141 video.width = 640; + 142 video.height = 360; + 143 container.appendChild(video); + 144 if (Hls.isSupported()) {{ + 145 var hls = new Hls(); + 146 hls.loadSource(videoSrc); + 147 hls.attachMedia(video); + 148 hls.on(Hls.Events.MANIFEST_PARSED, function() {{ + 149 video.play(); + 150 }}); + 151 }} else if (video.canPlayType('application/vnd.apple.mpegurl')) {{ + 152 video.src = videoSrc; + 153 video.addEventListener('loadedmetadata', function() {{ + 154 video.play(); + 155 }}); + 156 }} + 157 }} + 158 + 159 fetch(statusUrl) + 160 .then(r => r.json()) + 161 .then(res => {{ + 162 if (res.ready) {{ + 163 attachHls(); + 164 }} else {{ + 165 showWaiting(); + 166 }} + 167 }}) + 168 .catch(e => {{ + 169 console.error(e); + 170 showWaiting(); + 171 }}); + 172 </script> + 173</body> + 174</html> + 175""" + 176 return HTML(data=html_code) + 177 elif method == "link": + 178 return hls_video_url + 179 else: + 180 raise ValueError("Invalid method") + 181 + 182 + 183class Spec: + 184 """ + 185 A video transformation specification. + 186 + 187 See https://ixlab.github.io/vidformer/concepts.html for more information. + 188 """ + 189 + 190 def __init__(self, domain: list[Fraction], render, fmt: dict): + 191 self._domain = domain + 192 self._render = render + 193 self._fmt = fmt + 194 + 195 def __repr__(self): + 196 if len(self._domain) <= 20: + 197 lines = [] + 198 for i, t in enumerate(self._domain): + 199 frame_expr = self._render(t, i) + 200 lines.append( + 201 f"{t.numerator}/{t.denominator} => {frame_expr}", + 202 ) + 203 return "\n".join(lines) + 204 else: + 205 lines = [] + 206 for i, t in enumerate(self._domain[:10]): + 207 frame_expr = self._render(t, i) + 208 lines.append( + 209 f"{t.numerator}/{t.denominator} => {frame_expr}", + 210 ) + 211 lines.append("...") + 212 for i, t in enumerate(self._domain[-10:]): + 213 frame_expr = self._render(t, i) + 214 lines.append( + 215 f"{t.numerator}/{t.denominator} => {frame_expr}", + 216 ) + 217 return "\n".join(lines) + 218 + 219 def _sources(self): + 220 s = set() + 221 for i, t in enumerate(self._domain): + 222 frame_expr = self._render(t, i) + 223 s = s.union(frame_expr._sources()) + 224 return s + 225 + 226 def _to_json_spec(self): + 227 frames = [] + 228 s = set() + 229 f = {} + 230 for i, t in enumerate(self._domain): + 231 frame_expr = self._render(t, i) + 232 s = s.union(frame_expr._sources()) + 233 f = {**f, **frame_expr._filters()} + 234 frame = [[t.numerator, t.denominator], frame_expr._to_json_spec()] + 235 frames.append(frame) + 236 return {"frames": frames}, s, f + 237 + 238 def play(self, server, method="html", verbose=False): + 239 """Play the video live in the notebook.""" + 240 + 241 spec, sources, filters = self._to_json_spec() + 242 spec_json_bytes = json.dumps(spec).encode("utf-8") + 243 spec_obj_json_gzip = gzip.compress(spec_json_bytes, compresslevel=1) + 244 spec_obj_json_gzip_b64 = base64.b64encode(spec_obj_json_gzip).decode("utf-8") + 245 + 246 sources = [ + 247 { + 248 "name": s._name, + 249 "path": s._path, + 250 "stream": s._stream, + 251 "service": s._service.as_json() if s._service is not None else None, + 252 } + 253 for s in sources + 254 ] + 255 filters = { + 256 k: { + 257 "filter": v._func, + 258 "args": v._kwargs, + 259 } + 260 for k, v in filters.items() + 261 } + 262 arrays = [] + 263 + 264 if verbose: + 265 print(f"Sending to server. Spec is {len(spec_obj_json_gzip_b64)} bytes") + 266 + 267 resp = server._new(spec_obj_json_gzip_b64, sources, filters, arrays, self._fmt) + 268 hls_video_url = resp["stream_url"] + 269 hls_player_url = resp["player_url"] + 270 namespace = resp["namespace"] + 271 hls_js_url = server.hls_js_url() + 272 + 273 if method == "link": + 274 return hls_video_url + 275 if method == "player": + 276 return hls_player_url + 277 if method == "iframe": + 278 from IPython.display import IFrame + 279 + 280 return IFrame(hls_player_url, width=1280, height=720) + 281 if method == "html": + 282 from IPython.display import HTML + 283 + 284 # We add a namespace to the video element to avoid conflicts with other videos + 285 html_code = f""" + 286<!DOCTYPE html> + 287<html> + 288<head> + 289 <title>HLS Video Player</title> + 290 <!-- Include hls.js library --> + 291 <script src="{hls_js_url}"></script> + 292</head> + 293<body> + 294 <!-- Video element --> + 295 <video id="video-{namespace}" controls width="640" height="360" autoplay></video> + 296 <script> + 297 var video = document.getElementById('video-{namespace}'); + 298 var videoSrc = '{hls_video_url}'; + 299 var hls = new Hls(); + 300 hls.loadSource(videoSrc); + 301 hls.attachMedia(video); + 302 hls.on(Hls.Events.MANIFEST_PARSED, function() {{ + 303 video.play(); + 304 }}); + 305 </script> + 306</body> + 307</html> + 308""" + 309 return HTML(data=html_code) + 310 else: + 311 return hls_player_url + 312 + 313 def load(self, server): + 314 spec, sources, filters = self._to_json_spec() + 315 spec_json_bytes = json.dumps(spec).encode("utf-8") + 316 spec_obj_json_gzip = gzip.compress(spec_json_bytes, compresslevel=1) + 317 spec_obj_json_gzip_b64 = base64.b64encode(spec_obj_json_gzip).decode("utf-8") + 318 + 319 sources = [ + 320 { + 321 "name": s._name, + 322 "path": s._path, + 323 "stream": s._stream, + 324 "service": s._service.as_json() if s._service is not None else None, + 325 } + 326 for s in sources + 327 ] + 328 filters = { + 329 k: { + 330 "filter": v._func, + 331 "args": v._kwargs, + 332 } + 333 for k, v in filters.items() + 334 } + 335 arrays = [] + 336 + 337 resp = server._new(spec_obj_json_gzip_b64, sources, filters, arrays, self._fmt) + 338 namespace = resp["namespace"] + 339 return Loader(server, namespace, self._domain) + 340 + 341 def save(self, server, pth, encoder=None, encoder_opts=None, format=None): + 342 """Save the video to a file.""" + 343 + 344 assert encoder is None or type(encoder) == str + 345 assert encoder_opts is None or type(encoder_opts) == dict + 346 if encoder_opts is not None: + 347 for k, v in encoder_opts.items(): + 348 assert type(k) == str and type(v) == str + 349 + 350 spec, sources, filters = self._to_json_spec() + 351 spec_json_bytes = json.dumps(spec).encode("utf-8") + 352 spec_obj_json_gzip = gzip.compress(spec_json_bytes, compresslevel=1) + 353 spec_obj_json_gzip_b64 = base64.b64encode(spec_obj_json_gzip).decode("utf-8") + 354 + 355 sources = [ + 356 { + 357 "name": s._name, + 358 "path": s._path, + 359 "stream": s._stream, + 360 "service": s._service.as_json() if s._service is not None else None, + 361 } + 362 for s in sources + 363 ] + 364 filters = { + 365 k: { + 366 "filter": v._func, + 367 "args": v._kwargs, + 368 } + 369 for k, v in filters.items() + 370 } + 371 arrays = [] + 372 + 373 resp = server._export( + 374 pth, + 375 spec_obj_json_gzip_b64, + 376 sources, + 377 filters, + 378 arrays, + 379 self._fmt, + 380 encoder, + 381 encoder_opts, + 382 format, + 383 ) + 384 + 385 return resp + 386 + 387 def _vrod_bench(self, server): + 388 out = {} + 389 pth = "spec.json" + 390 start_t = time.time() + 391 with open(pth, "w") as outfile: + 392 spec, sources, filters = self._to_json_spec() + 393 outfile.write(json.dumps(spec)) + 394 + 395 sources = [ + 396 { + 397 "name": s._name, + 398 "path": s._path, + 399 "stream": s._stream, + 400 "service": s._service.as_json() if s._service is not None else None, + 401 } + 402 for s in sources + 403 ] + 404 filters = { + 405 k: { + 406 "filter": v._func, + 407 "args": v._kwargs, + 408 } + 409 for k, v in filters.items() + 410 } + 411 arrays = [] + 412 end_t = time.time() + 413 out["vrod_create_spec"] = end_t - start_t + 414 + 415 start = time.time() + 416 resp = server._new(pth, sources, filters, arrays, self._fmt) + 417 end = time.time() + 418 out["vrod_register"] = end - start + 419 + 420 stream_url = resp["stream_url"] + 421 first_segment = stream_url.replace("stream.m3u8", "segment-0.ts") + 422 + 423 start = time.time() + 424 r = requests.get(first_segment) + 425 r.raise_for_status() + 426 end = time.time() + 427 out["vrod_first_segment"] = end - start + 428 return out + 429 + 430 def _dve2_bench(self, server): + 431 pth = "spec.json" + 432 out = {} + 433 start_t = time.time() + 434 with open(pth, "w") as outfile: + 435 spec, sources, filters = self._to_json_spec() + 436 outfile.write(json.dumps(spec)) + 437 + 438 sources = [ + 439 { + 440 "name": s._name, + 441 "path": s._path, + 442 "stream": s._stream, + 443 "service": s._service.as_json() if s._service is not None else None, + 444 } + 445 for s in sources + 446 ] + 447 filters = { + 448 k: { + 449 "filter": v._func, + 450 "args": v._kwargs, + 451 } + 452 for k, v in filters.items() + 453 } + 454 arrays = [] + 455 end_t = time.time() + 456 out["dve2_create_spec"] = end_t - start_t + 457 + 458 start = time.time() + 459 resp = server._export(pth, sources, filters, arrays, self._fmt, None, None) + 460 end = time.time() + 461 out["dve2_exec"] = end - start + 462 return out + 463 + 464 + 465class Loader: + 466 def __init__(self, server, namespace: str, domain): + 467 self._server = server + 468 self._namespace = namespace + 469 self._domain = domain + 470 + 471 def _chunk(self, start_i, end_i): + 472 return self._server._raw(self._namespace, start_i, end_i) + 473 + 474 def __len__(self): + 475 return len(self._domain) + 476 + 477 def _find_index_by_rational(self, value): + 478 if value not in self._domain: + 479 raise ValueError(f"Rational timestamp {value} is not in the domain") + 480 return self._domain.index(value) + 481 + 482 def __getitem__(self, index): + 483 if isinstance(index, slice): + 484 start = index.start if index.start is not None else 0 + 485 end = index.stop if index.stop is not None else len(self._domain) + 486 assert start >= 0 and start < len(self._domain) + 487 assert end >= 0 and end <= len(self._domain) + 488 assert start <= end + 489 num_frames = end - start + 490 all_bytes = self._chunk(start, end - 1) + 491 all_bytes_len = len(all_bytes) + 492 assert all_bytes_len % num_frames == 0 + 493 return [ + 494 all_bytes[ + 495 i + 496 * all_bytes_len + 497 // num_frames : (i + 1) + 498 * all_bytes_len + 499 // num_frames + 500 ] + 501 for i in range(num_frames) + 502 ] + 503 elif isinstance(index, int): + 504 assert index >= 0 and index < len(self._domain) + 505 return self._chunk(index, index) + 506 else: + 507 raise TypeError( + 508 "Invalid argument type for iloc. Use a slice or an integer." + 509 ) + 510 + 511 + 512class YrdenServer: + 513 """ + 514 A connection to a Yrden server. + 515 + 516 A yrden server is the main API for local use of vidformer. + 517 """ + 518 + 519 def __init__(self, domain=None, port=None, bin=None, hls_prefix=None): + 520 """ + 521 Connect to a Yrden server + 522 + 523 Can either connect to an existing server, if domain and port are provided, or start a new server using the provided binary. + 524 If no domain or binary is provided, the `VIDFORMER_BIN` environment variable is used. + 525 """ + 526 + 527 self._domain = domain + 528 self._port = port + 529 self._proc = None + 530 if self._port is None: + 531 if bin is None: + 532 if os.getenv("VIDFORMER_BIN") is not None: + 533 bin = os.getenv("VIDFORMER_BIN") + 534 else: + 535 bin = "vidformer-cli" + 536 + 537 self._domain = "localhost" + 538 self._port = random.randint(49152, 65535) + 539 cmd = [bin, "yrden", "--port", str(self._port)] + 540 if _in_notebook: + 541 # We need to print the URL in the notebook + 542 # This is a trick to get VS Code to forward the port + 543 cmd += ["--print-url"] + 544 + 545 if hls_prefix is not None: + 546 if not type(hls_prefix) == str: + 547 raise Exception("hls_prefix must be a string") + 548 cmd += ["--hls-prefix", hls_prefix] + 549 + 550 self._proc = subprocess.Popen(cmd) + 551 + 552 version = _check_hls_link_exists(f"http://{self._domain}:{self._port}/") + 553 if version is None: + 554 raise Exception("Failed to connect to server") + 555 + 556 expected_version = f"vidformer-yrden v{__version__}" + 557 if version != expected_version: + 558 print( + 559 f"Warning: Expected version `{expected_version}`, got `{version}`. API may not be compatible!" + 560 ) + 561 + 562 def _source(self, name: str, path: str, stream: int, service): + 563 r = requests.post( + 564 f"http://{self._domain}:{self._port}/source", + 565 json={ + 566 "name": name, + 567 "path": path, + 568 "stream": stream, + 569 "service": service.as_json() if service is not None else None, + 570 }, + 571 ) + 572 if not r.ok: + 573 raise Exception(r.text) + 574 + 575 resp = r.json() + 576 resp["ts"] = [Fraction(x[0], x[1]) for x in resp["ts"]] + 577 return resp + 578 + 579 def _new(self, spec, sources, filters, arrays, fmt): + 580 req = { + 581 "spec": spec, + 582 "sources": sources, + 583 "filters": filters, + 584 "arrays": arrays, + 585 "width": fmt["width"], + 586 "height": fmt["height"], + 587 "pix_fmt": fmt["pix_fmt"], + 588 } + 589 + 590 r = requests.post(f"http://{self._domain}:{self._port}/new", json=req) + 591 if not r.ok: + 592 raise Exception(r.text) + 593 + 594 return r.json() + 595 + 596 def _export( + 597 self, pth, spec, sources, filters, arrays, fmt, encoder, encoder_opts, format + 598 ): + 599 req = { + 600 "spec": spec, + 601 "sources": sources, + 602 "filters": filters, + 603 "arrays": arrays, + 604 "width": fmt["width"], + 605 "height": fmt["height"], + 606 "pix_fmt": fmt["pix_fmt"], + 607 "output_path": pth, + 608 "encoder": encoder, + 609 "encoder_opts": encoder_opts, + 610 "format": format, + 611 } + 612 + 613 r = requests.post(f"http://{self._domain}:{self._port}/export", json=req) + 614 if not r.ok: + 615 raise Exception(r.text) + 616 + 617 return r.json() + 618 + 619 def _raw(self, namespace, start_i, end_i): + 620 r = requests.get( + 621 f"http://{self._domain}:{self._port}/{namespace}/raw/{start_i}-{end_i}" + 622 ) + 623 if not r.ok: + 624 raise Exception(r.text) + 625 return r.content + 626 + 627 def hls_js_url(self): + 628 """Return the link to the yrden-hosted hls.js file""" + 629 return f"http://{self._domain}:{self._port}/hls.js" + 630 + 631 def __del__(self): + 632 if self._proc is not None: + 633 self._proc.kill() + 634 + 635 + 636class SourceExpr: + 637 def __init__(self, source, idx, is_iloc): + 638 self._source = source + 639 self._idx = idx + 640 self._is_iloc = is_iloc + 641 + 642 def __repr__(self): + 643 if self._is_iloc: + 644 return f"{self._source._name}.iloc[{self._idx}]" + 645 else: + 646 return f"{self._source._name}[{self._idx}]" + 647 + 648 def _to_json_spec(self): + 649 if self._is_iloc: + 650 return { + 651 "Source": { + 652 "video": self._source._name, + 653 "index": {"ILoc": int(self._idx)}, + 654 } + 655 } + 656 else: + 657 return { + 658 "Source": { + 659 "video": self._source._name, + 660 "index": {"T": [self._idx.numerator, self._idx.denominator]}, + 661 } + 662 } + 663 + 664 def _sources(self): + 665 return set([self._source]) + 666 + 667 def _filters(self): + 668 return {} + 669 + 670 + 671class SourceILoc: + 672 def __init__(self, source): + 673 self._source = source + 674 + 675 def __getitem__(self, idx): + 676 if type(idx) != int: + 677 raise Exception(f"Source iloc index must be an integer, got a {type(idx)}") + 678 return SourceExpr(self._source, idx, True) + 679 + 680 + 681class Source: + 682 """A video source.""" + 683 + 684 def __init__( + 685 self, server: YrdenServer, name: str, path: str, stream: int, service=None + 686 ): + 687 if service is None: + 688 # check if path is a http URL and, if so, automatically set the service + 689 # for example, the following code should work with just vf.Source(server, "tos_720p", "https://f.dominik.win/data/dve2/tos_720p.mp4") + 690 # this creates a storage service with endpoint "https://f.dominik.win/" and path "data/dve2/tos_720p.mp4" + 691 # don't use the root parameter in this case + 692 + 693 match = re.match(r"(http|https)://([^/]+)(.*)", path) + 694 if match is not None: + 695 endpoint = f"{match.group(1)}://{match.group(2)}" + 696 path = match.group(3) + 697 # remove leading slash + 698 if path.startswith("/"): + 699 path = path[1:] + 700 service = StorageService("http", endpoint=endpoint) + 701 + 702 self._server = server + 703 self._name = name + 704 self._path = path + 705 self._stream = stream + 706 self._service = service + 707 + 708 self.iloc = SourceILoc(self) + 709 + 710 self._src = self._server._source( + 711 self._name, self._path, self._stream, self._service + 712 ) + 713 + 714 def fmt(self): + 715 return { + 716 "width": self._src["width"], + 717 "height": self._src["height"], + 718 "pix_fmt": self._src["pix_fmt"], + 719 } + 720 + 721 def ts(self): + 722 return self._src["ts"] + 723 + 724 def __len__(self): + 725 return len(self._src["ts"]) + 726 + 727 def __getitem__(self, idx): + 728 if type(idx) != Fraction: + 729 raise Exception("Source index must be a Fraction") + 730 return SourceExpr(self, idx, False) + 731 + 732 def play(self, *args, **kwargs): + 733 """Play the video live in the notebook.""" + 734 + 735 domain = self.ts() + 736 render = lambda t, i: self[t] + 737 spec = Spec(domain, render, self.fmt()) + 738 return spec.play(*args, **kwargs) + 739 + 740 + 741class StorageService: + 742 def __init__(self, service: str, **kwargs): + 743 if type(service) != str: + 744 raise Exception("Service name must be a string") + 745 self._service = service + 746 for k, v in kwargs.items(): + 747 if type(v) != str: + 748 raise Exception(f"Value of {k} must be a string") + 749 self._config = kwargs + 750 + 751 def as_json(self): + 752 return {"service": self._service, "config": self._config} + 753 + 754 def __repr__(self): + 755 return f"{self._service}(config={self._config})" + 756 + 757 + 758def _json_arg(arg, skip_data_anot=False): + 759 if type(arg) == FilterExpr or type(arg) == SourceExpr: + 760 return {"Frame": arg._to_json_spec()} + 761 elif type(arg) == int: + 762 if skip_data_anot: + 763 return {"Int": arg} + 764 return {"Data": {"Int": arg}} + 765 elif type(arg) == str: + 766 if skip_data_anot: + 767 return {"String": arg} + 768 return {"Data": {"String": arg}} + 769 elif type(arg) == bytes: + 770 arg = list(arg) + 771 if skip_data_anot: + 772 return {"Bytes": arg} + 773 return {"Data": {"Bytes": arg}} + 774 elif type(arg) == float: + 775 if skip_data_anot: + 776 return {"Float": arg} + 777 return {"Data": {"Float": arg}} + 778 elif type(arg) == bool: + 779 if skip_data_anot: + 780 return {"Bool": arg} + 781 return {"Data": {"Bool": arg}} + 782 elif type(arg) == tuple or type(arg) == list: + 783 if skip_data_anot: + 784 return {"List": [_json_arg(x, True) for x in list(arg)]} + 785 return {"Data": {"List": [_json_arg(x, True) for x in list(arg)]}} + 786 else: + 787 raise Exception(f"Unknown arg type: {type(arg)}") + 788 + 789 + 790class Filter: + 791 """A video filter.""" + 792 + 793 def __init__(self, name: str, tl_func=None, **kwargs): + 794 self._name = name + 795 + 796 # tl_func is the top level func, which is the true implementation, not just a pretty name + 797 if tl_func is None: + 798 self._func = name + 799 else: + 800 self._func = tl_func + 801 + 802 # filter infra args, not invocation args + 803 for k, v in kwargs.items(): + 804 if type(v) != str: + 805 raise Exception(f"Value of {k} must be a string") + 806 self._kwargs = kwargs + 807 + 808 def __call__(self, *args, **kwargs): + 809 return FilterExpr(self, args, kwargs) + 810 + 811 + 812class FilterExpr: + 813 def __init__(self, filter: Filter, args, kwargs): + 814 self._filter = filter + 815 self._args = args + 816 self._kwargs = kwargs + 817 + 818 def __repr__(self): + 819 args = [] + 820 for arg in self._args: + 821 val = f'"{arg}"' if type(arg) == str else str(arg) + 822 args.append(str(val)) + 823 for k, v in self._kwargs.items(): + 824 val = f'"{v}"' if type(v) == str else str(v) + 825 args.append(f"{k}={val}") + 826 return f"{self._filter._name}({', '.join(args)})" + 827 + 828 def _to_json_spec(self): + 829 args = [] + 830 for arg in self._args: + 831 args.append(_json_arg(arg)) + 832 kwargs = {} + 833 for k, v in self._kwargs.items(): + 834 kwargs[k] = _json_arg(v) + 835 return {"Filter": {"name": self._filter._name, "args": args, "kwargs": kwargs}} + 836 + 837 def _sources(self): + 838 s = set() + 839 for arg in self._args: + 840 if type(arg) == FilterExpr or type(arg) == SourceExpr: + 841 s = s.union(arg._sources()) + 842 for arg in self._kwargs.values(): + 843 if type(arg) == FilterExpr or type(arg) == SourceExpr: + 844 s = s.union(arg._sources()) + 845 return s + 846 + 847 def _filters(self): + 848 f = {self._filter._name: self._filter} + 849 for arg in self._args: + 850 if type(arg) == FilterExpr: + 851 f = {**f, **arg._filters()} + 852 for arg in self._kwargs.values(): + 853 if type(arg) == FilterExpr: + 854 f = {**f, **arg._filters()} + 855 return f + 856 + 857 + 858class UDF: + 859 """User-defined filter superclass""" + 860 + 861 def __init__(self, name: str): + 862 self._name = name + 863 self._socket_path = None + 864 self._p = None + 865 + 866 def filter(self, *args, **kwargs): + 867 raise Exception("User must implement the filter method") + 868 + 869 def filter_type(self, *args, **kwargs): + 870 raise Exception("User must implement the filter_type method") + 871 + 872 def into_filter(self): + 873 assert self._socket_path is None + 874 self._socket_path = f"/tmp/vidformer-{self._name}-{str(uuid.uuid4())}.sock" + 875 self._p = multiprocessing.Process( + 876 target=_run_udf_host, args=(self, self._socket_path) + 877 ) + 878 self._p.start() + 879 return Filter( + 880 name=self._name, tl_func="IPC", socket=self._socket_path, func=self._name + 881 ) + 882 + 883 def _handle_connection(self, connection): + 884 try: + 885 while True: + 886 frame_len = connection.recv(4) + 887 if not frame_len or len(frame_len) != 4: + 888 break + 889 frame_len = int.from_bytes(frame_len, byteorder="big") + 890 data = connection.recv(frame_len) + 891 if not data: + 892 break + 893 + 894 while len(data) < frame_len: + 895 new_data = connection.recv(frame_len - len(data)) + 896 if not new_data: + 897 raise Exception("Partial data received") + 898 data += new_data + 899 + 900 obj = msgpack.unpackb(data, raw=False) + 901 f_func, f_op, f_args, f_kwargs = ( + 902 obj["func"], + 903 obj["op"], + 904 obj["args"], + 905 obj["kwargs"], + 906 ) + 907 + 908 response = None + 909 if f_op == "filter": + 910 f_args = [self._deser_filter(x) for x in f_args] + 911 f_kwargs = {k: self._deser_filter(v) for k, v in f_kwargs} + 912 response = self.filter(*f_args, **f_kwargs) + 913 if type(response) != UDFFrame: + 914 raise Exception( + 915 f"filter must return a UDFFrame, got {type(response)}" + 916 ) + 917 if response.frame_type().pix_fmt() != "rgb24": + 918 raise Exception( + 919 f"filter must return a frame with pix_fmt 'rgb24', got {response.frame_type().pix_fmt()}" + 920 ) + 921 + 922 response = response._response_ser() + 923 elif f_op == "filter_type": + 924 f_args = [self._deser_filter_type(x) for x in f_args] + 925 f_kwargs = {k: self._deser_filter_type(v) for k, v in f_kwargs} + 926 response = self.filter_type(*f_args, **f_kwargs) + 927 if type(response) != UDFFrameType: + 928 raise Exception( + 929 f"filter_type must return a UDFFrameType, got {type(response)}" + 930 ) + 931 if response.pix_fmt() != "rgb24": + 932 raise Exception( + 933 f"filter_type must return a frame with pix_fmt 'rgb24', got {response.pix_fmt()}" + 934 ) + 935 response = response._response_ser() + 936 else: + 937 raise Exception(f"Unknown operation: {f_op}") + 938 + 939 response = msgpack.packb(response, use_bin_type=True) + 940 response_len = len(response).to_bytes(4, byteorder="big") + 941 connection.sendall(response_len) + 942 connection.sendall(response) + 943 finally: + 944 connection.close() + 945 + 946 def _deser_filter_type(self, obj): + 947 assert type(obj) == dict + 948 keys = list(obj.keys()) + 949 assert len(keys) == 1 + 950 type_key = keys[0] + 951 assert type_key in ["FrameType", "String", "Int", "Bool"] + 952 + 953 if type_key == "FrameType": + 954 frame = obj[type_key] + 955 assert type(frame) == dict + 956 assert "width" in frame + 957 assert "height" in frame + 958 assert "format" in frame + 959 assert type(frame["width"]) == int + 960 assert type(frame["height"]) == int + 961 assert frame["format"] == 2 # AV_PIX_FMT_RGB24 + 962 return UDFFrameType(frame["width"], frame["height"], "rgb24") + 963 elif type_key == "String": + 964 assert type(obj[type_key]) == str + 965 return obj[type_key] + 966 elif type_key == "Int": + 967 assert type(obj[type_key]) == int + 968 return obj[type_key] + 969 elif type_key == "Bool": + 970 assert type(obj[type_key]) == bool + 971 return obj[type_key] + 972 else: + 973 assert False, f"Unknown type: {type_key}" + 974 + 975 def _deser_filter(self, obj): + 976 assert type(obj) == dict + 977 keys = list(obj.keys()) + 978 assert len(keys) == 1 + 979 type_key = keys[0] + 980 assert type_key in ["Frame", "String", "Int", "Bool"] + 981 + 982 if type_key == "Frame": + 983 frame = obj[type_key] + 984 assert type(frame) == dict + 985 assert "data" in frame + 986 assert "width" in frame + 987 assert "height" in frame + 988 assert "format" in frame + 989 assert type(frame["width"]) == int + 990 assert type(frame["height"]) == int + 991 assert frame["format"] == "rgb24" + 992 assert type(frame["data"]) == bytes + 993 + 994 data = np.frombuffer(frame["data"], dtype=np.uint8) + 995 data = data.reshape(frame["height"], frame["width"], 3) + 996 return UDFFrame( + 997 data, UDFFrameType(frame["width"], frame["height"], "rgb24") + 998 ) + 999 elif type_key == "String": +1000 assert type(obj[type_key]) == str +1001 return obj[type_key] +1002 elif type_key == "Int": +1003 assert type(obj[type_key]) == int +1004 return obj[type_key] +1005 elif type_key == "Bool": +1006 assert type(obj[type_key]) == bool +1007 return obj[type_key] +1008 else: +1009 assert False, f"Unknown type: {type_key}" +1010 +1011 def _host(self, socket_path: str): +1012 if os.path.exists(socket_path): +1013 os.remove(socket_path) +1014 +1015 # start listening on the socket +1016 sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) +1017 sock.bind(socket_path) +1018 sock.listen(1) +1019 +1020 while True: +1021 # accept incoming connection +1022 connection, client_address = sock.accept() +1023 thread = threading.Thread( +1024 target=self._handle_connection, args=(connection,) +1025 ) +1026 thread.start() +1027 +1028 def __del__(self): +1029 if self._socket_path is not None: +1030 self._p.terminate() +1031 if os.path.exists(self._socket_path): +1032 # it's possible the process hasn't even created the socket yet +1033 os.remove(self._socket_path) +1034 +1035 +1036class UDFFrameType: +1037 """ +1038 Frame type for use in UDFs. +1039 """ +1040 +1041 def __init__(self, width: int, height: int, pix_fmt: str): +1042 assert type(width) == int +1043 assert type(height) == int +1044 assert type(pix_fmt) == str +1045 +1046 self._width = width +1047 self._height = height +1048 self._pix_fmt = pix_fmt +1049 +1050 def width(self): +1051 return self._width +1052 +1053 def height(self): +1054 return self._height +1055 +1056 def pix_fmt(self): +1057 return self._pix_fmt +1058 +1059 def _response_ser(self): +1060 return { +1061 "frame_type": { +1062 "width": self._width, +1063 "height": self._height, +1064 "format": 2, # AV_PIX_FMT_RGB24 +1065 } +1066 } +1067 +1068 def __repr__(self): +1069 return f"FrameType<{self._width}x{self._height}, {self._pix_fmt}>" +1070 +1071 +1072class UDFFrame: +1073 """A symbolic reference to a frame for use in UDFs.""" +1074 +1075 def __init__(self, data: np.ndarray, f_type: UDFFrameType): +1076 assert type(data) == np.ndarray +1077 assert type(f_type) == UDFFrameType +1078 +1079 # We only support RGB24 for now +1080 assert data.dtype == np.uint8 +1081 assert data.shape[2] == 3 +1082 +1083 # check type matches +1084 assert data.shape[0] == f_type.height() +1085 assert data.shape[1] == f_type.width() +1086 assert f_type.pix_fmt() == "rgb24" +1087 +1088 self._data = data +1089 self._f_type = f_type +1090 +1091 def data(self): +1092 return self._data +1093 +1094 def frame_type(self): +1095 return self._f_type +1096 +1097 def _response_ser(self): +1098 return { +1099 "frame": { +1100 "data": self._data.tobytes(), +1101 "width": self._f_type.width(), +1102 "height": self._f_type.height(), +1103 "format": "rgb24", +1104 } +1105 } +1106 +1107 def __repr__(self): +1108 return f"Frame<{self._f_type.width()}x{self._f_type.height()}, {self._f_type.pix_fmt()}>" +1109 +1110 +1111def _run_udf_host(udf: UDF, socket_path: str): +1112 udf._host(socket_path) +
+
+ class
+ Spec:
+
+
+
+
+
+ 184class Spec: +185 """ +186 A video transformation specification. +187 +188 See https://ixlab.github.io/vidformer/concepts.html for more information. +189 """ +190 +191 def __init__(self, domain: list[Fraction], render, fmt: dict): +192 self._domain = domain +193 self._render = render +194 self._fmt = fmt +195 +196 def __repr__(self): +197 if len(self._domain) <= 20: +198 lines = [] +199 for i, t in enumerate(self._domain): +200 frame_expr = self._render(t, i) +201 lines.append( +202 f"{t.numerator}/{t.denominator} => {frame_expr}", +203 ) +204 return "\n".join(lines) +205 else: +206 lines = [] +207 for i, t in enumerate(self._domain[:10]): +208 frame_expr = self._render(t, i) +209 lines.append( +210 f"{t.numerator}/{t.denominator} => {frame_expr}", +211 ) +212 lines.append("...") +213 for i, t in enumerate(self._domain[-10:]): +214 frame_expr = self._render(t, i) +215 lines.append( +216 f"{t.numerator}/{t.denominator} => {frame_expr}", +217 ) +218 return "\n".join(lines) +219 +220 def _sources(self): +221 s = set() +222 for i, t in enumerate(self._domain): +223 frame_expr = self._render(t, i) +224 s = s.union(frame_expr._sources()) +225 return s +226 +227 def _to_json_spec(self): +228 frames = [] +229 s = set() +230 f = {} +231 for i, t in enumerate(self._domain): +232 frame_expr = self._render(t, i) +233 s = s.union(frame_expr._sources()) +234 f = {**f, **frame_expr._filters()} +235 frame = [[t.numerator, t.denominator], frame_expr._to_json_spec()] +236 frames.append(frame) +237 return {"frames": frames}, s, f +238 +239 def play(self, server, method="html", verbose=False): +240 """Play the video live in the notebook.""" +241 +242 spec, sources, filters = self._to_json_spec() +243 spec_json_bytes = json.dumps(spec).encode("utf-8") +244 spec_obj_json_gzip = gzip.compress(spec_json_bytes, compresslevel=1) +245 spec_obj_json_gzip_b64 = base64.b64encode(spec_obj_json_gzip).decode("utf-8") +246 +247 sources = [ +248 { +249 "name": s._name, +250 "path": s._path, +251 "stream": s._stream, +252 "service": s._service.as_json() if s._service is not None else None, +253 } +254 for s in sources +255 ] +256 filters = { +257 k: { +258 "filter": v._func, +259 "args": v._kwargs, +260 } +261 for k, v in filters.items() +262 } +263 arrays = [] +264 +265 if verbose: +266 print(f"Sending to server. Spec is {len(spec_obj_json_gzip_b64)} bytes") +267 +268 resp = server._new(spec_obj_json_gzip_b64, sources, filters, arrays, self._fmt) +269 hls_video_url = resp["stream_url"] +270 hls_player_url = resp["player_url"] +271 namespace = resp["namespace"] +272 hls_js_url = server.hls_js_url() +273 +274 if method == "link": +275 return hls_video_url +276 if method == "player": +277 return hls_player_url +278 if method == "iframe": +279 from IPython.display import IFrame +280 +281 return IFrame(hls_player_url, width=1280, height=720) +282 if method == "html": +283 from IPython.display import HTML +284 +285 # We add a namespace to the video element to avoid conflicts with other videos +286 html_code = f""" +287<!DOCTYPE html> +288<html> +289<head> +290 <title>HLS Video Player</title> +291 <!-- Include hls.js library --> +292 <script src="{hls_js_url}"></script> +293</head> +294<body> +295 <!-- Video element --> +296 <video id="video-{namespace}" controls width="640" height="360" autoplay></video> +297 <script> +298 var video = document.getElementById('video-{namespace}'); +299 var videoSrc = '{hls_video_url}'; +300 var hls = new Hls(); +301 hls.loadSource(videoSrc); +302 hls.attachMedia(video); +303 hls.on(Hls.Events.MANIFEST_PARSED, function() {{ +304 video.play(); +305 }}); +306 </script> +307</body> +308</html> +309""" +310 return HTML(data=html_code) +311 else: +312 return hls_player_url +313 +314 def load(self, server): +315 spec, sources, filters = self._to_json_spec() +316 spec_json_bytes = json.dumps(spec).encode("utf-8") +317 spec_obj_json_gzip = gzip.compress(spec_json_bytes, compresslevel=1) +318 spec_obj_json_gzip_b64 = base64.b64encode(spec_obj_json_gzip).decode("utf-8") +319 +320 sources = [ +321 { +322 "name": s._name, +323 "path": s._path, +324 "stream": s._stream, +325 "service": s._service.as_json() if s._service is not None else None, +326 } +327 for s in sources +328 ] +329 filters = { +330 k: { +331 "filter": v._func, +332 "args": v._kwargs, +333 } +334 for k, v in filters.items() +335 } +336 arrays = [] +337 +338 resp = server._new(spec_obj_json_gzip_b64, sources, filters, arrays, self._fmt) +339 namespace = resp["namespace"] +340 return Loader(server, namespace, self._domain) +341 +342 def save(self, server, pth, encoder=None, encoder_opts=None, format=None): +343 """Save the video to a file.""" +344 +345 assert encoder is None or type(encoder) == str +346 assert encoder_opts is None or type(encoder_opts) == dict +347 if encoder_opts is not None: +348 for k, v in encoder_opts.items(): +349 assert type(k) == str and type(v) == str +350 +351 spec, sources, filters = self._to_json_spec() +352 spec_json_bytes = json.dumps(spec).encode("utf-8") +353 spec_obj_json_gzip = gzip.compress(spec_json_bytes, compresslevel=1) +354 spec_obj_json_gzip_b64 = base64.b64encode(spec_obj_json_gzip).decode("utf-8") +355 +356 sources = [ +357 { +358 "name": s._name, +359 "path": s._path, +360 "stream": s._stream, +361 "service": s._service.as_json() if s._service is not None else None, +362 } +363 for s in sources +364 ] +365 filters = { +366 k: { +367 "filter": v._func, +368 "args": v._kwargs, +369 } +370 for k, v in filters.items() +371 } +372 arrays = [] +373 +374 resp = server._export( +375 pth, +376 spec_obj_json_gzip_b64, +377 sources, +378 filters, +379 arrays, +380 self._fmt, +381 encoder, +382 encoder_opts, +383 format, +384 ) +385 +386 return resp +387 +388 def _vrod_bench(self, server): +389 out = {} +390 pth = "spec.json" +391 start_t = time.time() +392 with open(pth, "w") as outfile: +393 spec, sources, filters = self._to_json_spec() +394 outfile.write(json.dumps(spec)) +395 +396 sources = [ +397 { +398 "name": s._name, +399 "path": s._path, +400 "stream": s._stream, +401 "service": s._service.as_json() if s._service is not None else None, +402 } +403 for s in sources +404 ] +405 filters = { +406 k: { +407 "filter": v._func, +408 "args": v._kwargs, +409 } +410 for k, v in filters.items() +411 } +412 arrays = [] +413 end_t = time.time() +414 out["vrod_create_spec"] = end_t - start_t +415 +416 start = time.time() +417 resp = server._new(pth, sources, filters, arrays, self._fmt) +418 end = time.time() +419 out["vrod_register"] = end - start +420 +421 stream_url = resp["stream_url"] +422 first_segment = stream_url.replace("stream.m3u8", "segment-0.ts") +423 +424 start = time.time() +425 r = requests.get(first_segment) +426 r.raise_for_status() +427 end = time.time() +428 out["vrod_first_segment"] = end - start +429 return out +430 +431 def _dve2_bench(self, server): +432 pth = "spec.json" +433 out = {} +434 start_t = time.time() +435 with open(pth, "w") as outfile: +436 spec, sources, filters = self._to_json_spec() +437 outfile.write(json.dumps(spec)) +438 +439 sources = [ +440 { +441 "name": s._name, +442 "path": s._path, +443 "stream": s._stream, +444 "service": s._service.as_json() if s._service is not None else None, +445 } +446 for s in sources +447 ] +448 filters = { +449 k: { +450 "filter": v._func, +451 "args": v._kwargs, +452 } +453 for k, v in filters.items() +454 } +455 arrays = [] +456 end_t = time.time() +457 out["dve2_create_spec"] = end_t - start_t +458 +459 start = time.time() +460 resp = server._export(pth, sources, filters, arrays, self._fmt, None, None) +461 end = time.time() +462 out["dve2_exec"] = end - start +463 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):
+
+
+
+
+
+ 239 def play(self, server, method="html", verbose=False): +240 """Play the video live in the notebook.""" +241 +242 spec, sources, filters = self._to_json_spec() +243 spec_json_bytes = json.dumps(spec).encode("utf-8") +244 spec_obj_json_gzip = gzip.compress(spec_json_bytes, compresslevel=1) +245 spec_obj_json_gzip_b64 = base64.b64encode(spec_obj_json_gzip).decode("utf-8") +246 +247 sources = [ +248 { +249 "name": s._name, +250 "path": s._path, +251 "stream": s._stream, +252 "service": s._service.as_json() if s._service is not None else None, +253 } +254 for s in sources +255 ] +256 filters = { +257 k: { +258 "filter": v._func, +259 "args": v._kwargs, +260 } +261 for k, v in filters.items() +262 } +263 arrays = [] +264 +265 if verbose: +266 print(f"Sending to server. Spec is {len(spec_obj_json_gzip_b64)} bytes") +267 +268 resp = server._new(spec_obj_json_gzip_b64, sources, filters, arrays, self._fmt) +269 hls_video_url = resp["stream_url"] +270 hls_player_url = resp["player_url"] +271 namespace = resp["namespace"] +272 hls_js_url = server.hls_js_url() +273 +274 if method == "link": +275 return hls_video_url +276 if method == "player": +277 return hls_player_url +278 if method == "iframe": +279 from IPython.display import IFrame +280 +281 return IFrame(hls_player_url, width=1280, height=720) +282 if method == "html": +283 from IPython.display import HTML +284 +285 # We add a namespace to the video element to avoid conflicts with other videos +286 html_code = f""" +287<!DOCTYPE html> +288<html> +289<head> +290 <title>HLS Video Player</title> +291 <!-- Include hls.js library --> +292 <script src="{hls_js_url}"></script> +293</head> +294<body> +295 <!-- Video element --> +296 <video id="video-{namespace}" controls width="640" height="360" autoplay></video> +297 <script> +298 var video = document.getElementById('video-{namespace}'); +299 var videoSrc = '{hls_video_url}'; +300 var hls = new Hls(); +301 hls.loadSource(videoSrc); +302 hls.attachMedia(video); +303 hls.on(Hls.Events.MANIFEST_PARSED, function() {{ +304 video.play(); +305 }}); +306 </script> +307</body> +308</html> +309""" +310 return HTML(data=html_code) +311 else: +312 return hls_player_url +
Play the video live in the notebook.
+
+
+
+
+
+
+
+
+
+
+ def
+ load(self, server):
+
+
+
+
+
+ 314 def load(self, server): +315 spec, sources, filters = self._to_json_spec() +316 spec_json_bytes = json.dumps(spec).encode("utf-8") +317 spec_obj_json_gzip = gzip.compress(spec_json_bytes, compresslevel=1) +318 spec_obj_json_gzip_b64 = base64.b64encode(spec_obj_json_gzip).decode("utf-8") +319 +320 sources = [ +321 { +322 "name": s._name, +323 "path": s._path, +324 "stream": s._stream, +325 "service": s._service.as_json() if s._service is not None else None, +326 } +327 for s in sources +328 ] +329 filters = { +330 k: { +331 "filter": v._func, +332 "args": v._kwargs, +333 } +334 for k, v in filters.items() +335 } +336 arrays = [] +337 +338 resp = server._new(spec_obj_json_gzip_b64, sources, filters, arrays, self._fmt) +339 namespace = resp["namespace"] +340 return Loader(server, namespace, self._domain) +
+
+
+
+
+
+
+
+
+
+
+ def
+ save(self, server, pth, encoder=None, encoder_opts=None, format=None):
+
+
+
+
+
+ 342 def save(self, server, pth, encoder=None, encoder_opts=None, format=None): +343 """Save the video to a file.""" +344 +345 assert encoder is None or type(encoder) == str +346 assert encoder_opts is None or type(encoder_opts) == dict +347 if encoder_opts is not None: +348 for k, v in encoder_opts.items(): +349 assert type(k) == str and type(v) == str +350 +351 spec, sources, filters = self._to_json_spec() +352 spec_json_bytes = json.dumps(spec).encode("utf-8") +353 spec_obj_json_gzip = gzip.compress(spec_json_bytes, compresslevel=1) +354 spec_obj_json_gzip_b64 = base64.b64encode(spec_obj_json_gzip).decode("utf-8") +355 +356 sources = [ +357 { +358 "name": s._name, +359 "path": s._path, +360 "stream": s._stream, +361 "service": s._service.as_json() if s._service is not None else None, +362 } +363 for s in sources +364 ] +365 filters = { +366 k: { +367 "filter": v._func, +368 "args": v._kwargs, +369 } +370 for k, v in filters.items() +371 } +372 arrays = [] +373 +374 resp = server._export( +375 pth, +376 spec_obj_json_gzip_b64, +377 sources, +378 filters, +379 arrays, +380 self._fmt, +381 encoder, +382 encoder_opts, +383 format, +384 ) +385 +386 return resp +
Save the video to a file.
+
+
+ class
+ Loader:
+
+
+
+
+
+ 466class Loader: +467 def __init__(self, server, namespace: str, domain): +468 self._server = server +469 self._namespace = namespace +470 self._domain = domain +471 +472 def _chunk(self, start_i, end_i): +473 return self._server._raw(self._namespace, start_i, end_i) +474 +475 def __len__(self): +476 return len(self._domain) +477 +478 def _find_index_by_rational(self, value): +479 if value not in self._domain: +480 raise ValueError(f"Rational timestamp {value} is not in the domain") +481 return self._domain.index(value) +482 +483 def __getitem__(self, index): +484 if isinstance(index, slice): +485 start = index.start if index.start is not None else 0 +486 end = index.stop if index.stop is not None else len(self._domain) +487 assert start >= 0 and start < len(self._domain) +488 assert end >= 0 and end <= len(self._domain) +489 assert start <= end +490 num_frames = end - start +491 all_bytes = self._chunk(start, end - 1) +492 all_bytes_len = len(all_bytes) +493 assert all_bytes_len % num_frames == 0 +494 return [ +495 all_bytes[ +496 i +497 * all_bytes_len +498 // num_frames : (i + 1) +499 * all_bytes_len +500 // num_frames +501 ] +502 for i in range(num_frames) +503 ] +504 elif isinstance(index, int): +505 assert index >= 0 and index < len(self._domain) +506 return self._chunk(index, index) +507 else: +508 raise TypeError( +509 "Invalid argument type for iloc. Use a slice or an integer." +510 ) +
+
+ class
+ YrdenServer:
+
+
+
+
+
+ 513class YrdenServer: +514 """ +515 A connection to a Yrden server. +516 +517 A yrden server is the main API for local use of vidformer. +518 """ +519 +520 def __init__(self, domain=None, port=None, bin=None, hls_prefix=None): +521 """ +522 Connect to a Yrden server +523 +524 Can either connect to an existing server, if domain and port are provided, or start a new server using the provided binary. +525 If no domain or binary is provided, the `VIDFORMER_BIN` environment variable is used. +526 """ +527 +528 self._domain = domain +529 self._port = port +530 self._proc = None +531 if self._port is None: +532 if bin is None: +533 if os.getenv("VIDFORMER_BIN") is not None: +534 bin = os.getenv("VIDFORMER_BIN") +535 else: +536 bin = "vidformer-cli" +537 +538 self._domain = "localhost" +539 self._port = random.randint(49152, 65535) +540 cmd = [bin, "yrden", "--port", str(self._port)] +541 if _in_notebook: +542 # We need to print the URL in the notebook +543 # This is a trick to get VS Code to forward the port +544 cmd += ["--print-url"] +545 +546 if hls_prefix is not None: +547 if not type(hls_prefix) == str: +548 raise Exception("hls_prefix must be a string") +549 cmd += ["--hls-prefix", hls_prefix] +550 +551 self._proc = subprocess.Popen(cmd) +552 +553 version = _check_hls_link_exists(f"http://{self._domain}:{self._port}/") +554 if version is None: +555 raise Exception("Failed to connect to server") +556 +557 expected_version = f"vidformer-yrden v{__version__}" +558 if version != expected_version: +559 print( +560 f"Warning: Expected version `{expected_version}`, got `{version}`. API may not be compatible!" +561 ) +562 +563 def _source(self, name: str, path: str, stream: int, service): +564 r = requests.post( +565 f"http://{self._domain}:{self._port}/source", +566 json={ +567 "name": name, +568 "path": path, +569 "stream": stream, +570 "service": service.as_json() if service is not None else None, +571 }, +572 ) +573 if not r.ok: +574 raise Exception(r.text) +575 +576 resp = r.json() +577 resp["ts"] = [Fraction(x[0], x[1]) for x in resp["ts"]] +578 return resp +579 +580 def _new(self, spec, sources, filters, arrays, fmt): +581 req = { +582 "spec": spec, +583 "sources": sources, +584 "filters": filters, +585 "arrays": arrays, +586 "width": fmt["width"], +587 "height": fmt["height"], +588 "pix_fmt": fmt["pix_fmt"], +589 } +590 +591 r = requests.post(f"http://{self._domain}:{self._port}/new", json=req) +592 if not r.ok: +593 raise Exception(r.text) +594 +595 return r.json() +596 +597 def _export( +598 self, pth, spec, sources, filters, arrays, fmt, encoder, encoder_opts, format +599 ): +600 req = { +601 "spec": spec, +602 "sources": sources, +603 "filters": filters, +604 "arrays": arrays, +605 "width": fmt["width"], +606 "height": fmt["height"], +607 "pix_fmt": fmt["pix_fmt"], +608 "output_path": pth, +609 "encoder": encoder, +610 "encoder_opts": encoder_opts, +611 "format": format, +612 } +613 +614 r = requests.post(f"http://{self._domain}:{self._port}/export", json=req) +615 if not r.ok: +616 raise Exception(r.text) +617 +618 return r.json() +619 +620 def _raw(self, namespace, start_i, end_i): +621 r = requests.get( +622 f"http://{self._domain}:{self._port}/{namespace}/raw/{start_i}-{end_i}" +623 ) +624 if not r.ok: +625 raise Exception(r.text) +626 return r.content +627 +628 def hls_js_url(self): +629 """Return the link to the yrden-hosted hls.js file""" +630 return f"http://{self._domain}:{self._port}/hls.js" +631 +632 def __del__(self): +633 if self._proc is not None: +634 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)
+
+
+
+
+
+ 520 def __init__(self, domain=None, port=None, bin=None, hls_prefix=None): +521 """ +522 Connect to a Yrden server +523 +524 Can either connect to an existing server, if domain and port are provided, or start a new server using the provided binary. +525 If no domain or binary is provided, the `VIDFORMER_BIN` environment variable is used. +526 """ +527 +528 self._domain = domain +529 self._port = port +530 self._proc = None +531 if self._port is None: +532 if bin is None: +533 if os.getenv("VIDFORMER_BIN") is not None: +534 bin = os.getenv("VIDFORMER_BIN") +535 else: +536 bin = "vidformer-cli" +537 +538 self._domain = "localhost" +539 self._port = random.randint(49152, 65535) +540 cmd = [bin, "yrden", "--port", str(self._port)] +541 if _in_notebook: +542 # We need to print the URL in the notebook +543 # This is a trick to get VS Code to forward the port +544 cmd += ["--print-url"] +545 +546 if hls_prefix is not None: +547 if not type(hls_prefix) == str: +548 raise Exception("hls_prefix must be a string") +549 cmd += ["--hls-prefix", hls_prefix] +550 +551 self._proc = subprocess.Popen(cmd) +552 +553 version = _check_hls_link_exists(f"http://{self._domain}:{self._port}/") +554 if version is None: +555 raise Exception("Failed to connect to server") +556 +557 expected_version = f"vidformer-yrden v{__version__}" +558 if version != expected_version: +559 print( +560 f"Warning: Expected version `{expected_version}`, got `{version}`. API may not be compatible!" +561 ) +
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:
+
+
+
+
+
+ 637class SourceExpr: +638 def __init__(self, source, idx, is_iloc): +639 self._source = source +640 self._idx = idx +641 self._is_iloc = is_iloc +642 +643 def __repr__(self): +644 if self._is_iloc: +645 return f"{self._source._name}.iloc[{self._idx}]" +646 else: +647 return f"{self._source._name}[{self._idx}]" +648 +649 def _to_json_spec(self): +650 if self._is_iloc: +651 return { +652 "Source": { +653 "video": self._source._name, +654 "index": {"ILoc": int(self._idx)}, +655 } +656 } +657 else: +658 return { +659 "Source": { +660 "video": self._source._name, +661 "index": {"T": [self._idx.numerator, self._idx.denominator]}, +662 } +663 } +664 +665 def _sources(self): +666 return set([self._source]) +667 +668 def _filters(self): +669 return {} +
+
+ class
+ SourceILoc:
+
+
+
+
+
+
+
+
+
+
+
+
+
+ class
+ Source:
+
+
+
+
+
+ 682class Source: +683 """A video source.""" +684 +685 def __init__( +686 self, server: YrdenServer, name: str, path: str, stream: int, service=None +687 ): +688 if service is None: +689 # check if path is a http URL and, if so, automatically set the service +690 # for example, the following code should work with just vf.Source(server, "tos_720p", "https://f.dominik.win/data/dve2/tos_720p.mp4") +691 # this creates a storage service with endpoint "https://f.dominik.win/" and path "data/dve2/tos_720p.mp4" +692 # don't use the root parameter in this case +693 +694 match = re.match(r"(http|https)://([^/]+)(.*)", path) +695 if match is not None: +696 endpoint = f"{match.group(1)}://{match.group(2)}" +697 path = match.group(3) +698 # remove leading slash +699 if path.startswith("/"): +700 path = path[1:] +701 service = StorageService("http", endpoint=endpoint) +702 +703 self._server = server +704 self._name = name +705 self._path = path +706 self._stream = stream +707 self._service = service +708 +709 self.iloc = SourceILoc(self) +710 +711 self._src = self._server._source( +712 self._name, self._path, self._stream, self._service +713 ) +714 +715 def fmt(self): +716 return { +717 "width": self._src["width"], +718 "height": self._src["height"], +719 "pix_fmt": self._src["pix_fmt"], +720 } +721 +722 def ts(self): +723 return self._src["ts"] +724 +725 def __len__(self): +726 return len(self._src["ts"]) +727 +728 def __getitem__(self, idx): +729 if type(idx) != Fraction: +730 raise Exception("Source index must be a Fraction") +731 return SourceExpr(self, idx, False) +732 +733 def play(self, *args, **kwargs): +734 """Play the video live in the notebook.""" +735 +736 domain = self.ts() +737 render = lambda t, i: self[t] +738 spec = Spec(domain, render, self.fmt()) +739 return spec.play(*args, **kwargs) +
A video source.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Source( server: YrdenServer, name: str, path: str, stream: int, service=None)
+
+
+
+
+
+ 685 def __init__( +686 self, server: YrdenServer, name: str, path: str, stream: int, service=None +687 ): +688 if service is None: +689 # check if path is a http URL and, if so, automatically set the service +690 # for example, the following code should work with just vf.Source(server, "tos_720p", "https://f.dominik.win/data/dve2/tos_720p.mp4") +691 # this creates a storage service with endpoint "https://f.dominik.win/" and path "data/dve2/tos_720p.mp4" +692 # don't use the root parameter in this case +693 +694 match = re.match(r"(http|https)://([^/]+)(.*)", path) +695 if match is not None: +696 endpoint = f"{match.group(1)}://{match.group(2)}" +697 path = match.group(3) +698 # remove leading slash +699 if path.startswith("/"): +700 path = path[1:] +701 service = StorageService("http", endpoint=endpoint) +702 +703 self._server = server +704 self._name = name +705 self._path = path +706 self._stream = stream +707 self._service = service +708 +709 self.iloc = SourceILoc(self) +710 +711 self._src = self._server._source( +712 self._name, self._path, self._stream, self._service +713 ) +
+
+
+
+
+
+
+
+
+
+
+ def
+ play(self, *args, **kwargs):
+
+
+
+
+
+ 733 def play(self, *args, **kwargs): +734 """Play the video live in the notebook.""" +735 +736 domain = self.ts() +737 render = lambda t, i: self[t] +738 spec = Spec(domain, render, self.fmt()) +739 return spec.play(*args, **kwargs) +
Play the video live in the notebook.
+
+
+ class
+ StorageService:
+
+
+
+
+
+ 742class StorageService: +743 def __init__(self, service: str, **kwargs): +744 if type(service) != str: +745 raise Exception("Service name must be a string") +746 self._service = service +747 for k, v in kwargs.items(): +748 if type(v) != str: +749 raise Exception(f"Value of {k} must be a string") +750 self._config = kwargs +751 +752 def as_json(self): +753 return {"service": self._service, "config": self._config} +754 +755 def __repr__(self): +756 return f"{self._service}(config={self._config})" +
+
+
+
+
+
+
+
+
+
+
+ StorageService(service: str, **kwargs)
+
+
+
+
+
+ 743 def __init__(self, service: str, **kwargs): +744 if type(service) != str: +745 raise Exception("Service name must be a string") +746 self._service = service +747 for k, v in kwargs.items(): +748 if type(v) != str: +749 raise Exception(f"Value of {k} must be a string") +750 self._config = kwargs +
+
+ class
+ Filter:
+
+
+
+
+
+ 791class Filter: +792 """A video filter.""" +793 +794 def __init__(self, name: str, tl_func=None, **kwargs): +795 self._name = name +796 +797 # tl_func is the top level func, which is the true implementation, not just a pretty name +798 if tl_func is None: +799 self._func = name +800 else: +801 self._func = tl_func +802 +803 # filter infra args, not invocation args +804 for k, v in kwargs.items(): +805 if type(v) != str: +806 raise Exception(f"Value of {k} must be a string") +807 self._kwargs = kwargs +808 +809 def __call__(self, *args, **kwargs): +810 return FilterExpr(self, args, kwargs) +
A video filter.
+
+
+
+
+
+
+
+
+
+
+ Filter(name: str, tl_func=None, **kwargs)
+
+
+
+
+
+ 794 def __init__(self, name: str, tl_func=None, **kwargs): +795 self._name = name +796 +797 # tl_func is the top level func, which is the true implementation, not just a pretty name +798 if tl_func is None: +799 self._func = name +800 else: +801 self._func = tl_func +802 +803 # filter infra args, not invocation args +804 for k, v in kwargs.items(): +805 if type(v) != str: +806 raise Exception(f"Value of {k} must be a string") +807 self._kwargs = kwargs +
+
+ class
+ FilterExpr:
+
+
+
+
+
+ 813class FilterExpr: +814 def __init__(self, filter: Filter, args, kwargs): +815 self._filter = filter +816 self._args = args +817 self._kwargs = kwargs +818 +819 def __repr__(self): +820 args = [] +821 for arg in self._args: +822 val = f'"{arg}"' if type(arg) == str else str(arg) +823 args.append(str(val)) +824 for k, v in self._kwargs.items(): +825 val = f'"{v}"' if type(v) == str else str(v) +826 args.append(f"{k}={val}") +827 return f"{self._filter._name}({', '.join(args)})" +828 +829 def _to_json_spec(self): +830 args = [] +831 for arg in self._args: +832 args.append(_json_arg(arg)) +833 kwargs = {} +834 for k, v in self._kwargs.items(): +835 kwargs[k] = _json_arg(v) +836 return {"Filter": {"name": self._filter._name, "args": args, "kwargs": kwargs}} +837 +838 def _sources(self): +839 s = set() +840 for arg in self._args: +841 if type(arg) == FilterExpr or type(arg) == SourceExpr: +842 s = s.union(arg._sources()) +843 for arg in self._kwargs.values(): +844 if type(arg) == FilterExpr or type(arg) == SourceExpr: +845 s = s.union(arg._sources()) +846 return s +847 +848 def _filters(self): +849 f = {self._filter._name: self._filter} +850 for arg in self._args: +851 if type(arg) == FilterExpr: +852 f = {**f, **arg._filters()} +853 for arg in self._kwargs.values(): +854 if type(arg) == FilterExpr: +855 f = {**f, **arg._filters()} +856 return f +
+
+ class
+ UDF:
+
+
+
+
+
+ 859class UDF: + 860 """User-defined filter superclass""" + 861 + 862 def __init__(self, name: str): + 863 self._name = name + 864 self._socket_path = None + 865 self._p = None + 866 + 867 def filter(self, *args, **kwargs): + 868 raise Exception("User must implement the filter method") + 869 + 870 def filter_type(self, *args, **kwargs): + 871 raise Exception("User must implement the filter_type method") + 872 + 873 def into_filter(self): + 874 assert self._socket_path is None + 875 self._socket_path = f"/tmp/vidformer-{self._name}-{str(uuid.uuid4())}.sock" + 876 self._p = multiprocessing.Process( + 877 target=_run_udf_host, args=(self, self._socket_path) + 878 ) + 879 self._p.start() + 880 return Filter( + 881 name=self._name, tl_func="IPC", socket=self._socket_path, func=self._name + 882 ) + 883 + 884 def _handle_connection(self, connection): + 885 try: + 886 while True: + 887 frame_len = connection.recv(4) + 888 if not frame_len or len(frame_len) != 4: + 889 break + 890 frame_len = int.from_bytes(frame_len, byteorder="big") + 891 data = connection.recv(frame_len) + 892 if not data: + 893 break + 894 + 895 while len(data) < frame_len: + 896 new_data = connection.recv(frame_len - len(data)) + 897 if not new_data: + 898 raise Exception("Partial data received") + 899 data += new_data + 900 + 901 obj = msgpack.unpackb(data, raw=False) + 902 f_func, f_op, f_args, f_kwargs = ( + 903 obj["func"], + 904 obj["op"], + 905 obj["args"], + 906 obj["kwargs"], + 907 ) + 908 + 909 response = None + 910 if f_op == "filter": + 911 f_args = [self._deser_filter(x) for x in f_args] + 912 f_kwargs = {k: self._deser_filter(v) for k, v in f_kwargs} + 913 response = self.filter(*f_args, **f_kwargs) + 914 if type(response) != UDFFrame: + 915 raise Exception( + 916 f"filter must return a UDFFrame, got {type(response)}" + 917 ) + 918 if response.frame_type().pix_fmt() != "rgb24": + 919 raise Exception( + 920 f"filter must return a frame with pix_fmt 'rgb24', got {response.frame_type().pix_fmt()}" + 921 ) + 922 + 923 response = response._response_ser() + 924 elif f_op == "filter_type": + 925 f_args = [self._deser_filter_type(x) for x in f_args] + 926 f_kwargs = {k: self._deser_filter_type(v) for k, v in f_kwargs} + 927 response = self.filter_type(*f_args, **f_kwargs) + 928 if type(response) != UDFFrameType: + 929 raise Exception( + 930 f"filter_type must return a UDFFrameType, got {type(response)}" + 931 ) + 932 if response.pix_fmt() != "rgb24": + 933 raise Exception( + 934 f"filter_type must return a frame with pix_fmt 'rgb24', got {response.pix_fmt()}" + 935 ) + 936 response = response._response_ser() + 937 else: + 938 raise Exception(f"Unknown operation: {f_op}") + 939 + 940 response = msgpack.packb(response, use_bin_type=True) + 941 response_len = len(response).to_bytes(4, byteorder="big") + 942 connection.sendall(response_len) + 943 connection.sendall(response) + 944 finally: + 945 connection.close() + 946 + 947 def _deser_filter_type(self, obj): + 948 assert type(obj) == dict + 949 keys = list(obj.keys()) + 950 assert len(keys) == 1 + 951 type_key = keys[0] + 952 assert type_key in ["FrameType", "String", "Int", "Bool"] + 953 + 954 if type_key == "FrameType": + 955 frame = obj[type_key] + 956 assert type(frame) == dict + 957 assert "width" in frame + 958 assert "height" in frame + 959 assert "format" in frame + 960 assert type(frame["width"]) == int + 961 assert type(frame["height"]) == int + 962 assert frame["format"] == 2 # AV_PIX_FMT_RGB24 + 963 return UDFFrameType(frame["width"], frame["height"], "rgb24") + 964 elif type_key == "String": + 965 assert type(obj[type_key]) == str + 966 return obj[type_key] + 967 elif type_key == "Int": + 968 assert type(obj[type_key]) == int + 969 return obj[type_key] + 970 elif type_key == "Bool": + 971 assert type(obj[type_key]) == bool + 972 return obj[type_key] + 973 else: + 974 assert False, f"Unknown type: {type_key}" + 975 + 976 def _deser_filter(self, obj): + 977 assert type(obj) == dict + 978 keys = list(obj.keys()) + 979 assert len(keys) == 1 + 980 type_key = keys[0] + 981 assert type_key in ["Frame", "String", "Int", "Bool"] + 982 + 983 if type_key == "Frame": + 984 frame = obj[type_key] + 985 assert type(frame) == dict + 986 assert "data" in frame + 987 assert "width" in frame + 988 assert "height" in frame + 989 assert "format" in frame + 990 assert type(frame["width"]) == int + 991 assert type(frame["height"]) == int + 992 assert frame["format"] == "rgb24" + 993 assert type(frame["data"]) == bytes + 994 + 995 data = np.frombuffer(frame["data"], dtype=np.uint8) + 996 data = data.reshape(frame["height"], frame["width"], 3) + 997 return UDFFrame( + 998 data, UDFFrameType(frame["width"], frame["height"], "rgb24") + 999 ) +1000 elif type_key == "String": +1001 assert type(obj[type_key]) == str +1002 return obj[type_key] +1003 elif type_key == "Int": +1004 assert type(obj[type_key]) == int +1005 return obj[type_key] +1006 elif type_key == "Bool": +1007 assert type(obj[type_key]) == bool +1008 return obj[type_key] +1009 else: +1010 assert False, f"Unknown type: {type_key}" +1011 +1012 def _host(self, socket_path: str): +1013 if os.path.exists(socket_path): +1014 os.remove(socket_path) +1015 +1016 # start listening on the socket +1017 sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) +1018 sock.bind(socket_path) +1019 sock.listen(1) +1020 +1021 while True: +1022 # accept incoming connection +1023 connection, client_address = sock.accept() +1024 thread = threading.Thread( +1025 target=self._handle_connection, args=(connection,) +1026 ) +1027 thread.start() +1028 +1029 def __del__(self): +1030 if self._socket_path is not None: +1031 self._p.terminate() +1032 if os.path.exists(self._socket_path): +1033 # it's possible the process hasn't even created the socket yet +1034 os.remove(self._socket_path) +
User-defined filter superclass
+
+
+
+
+
+
+
+
+
+
+ def
+ into_filter(self):
+
+
+
+
+
+ 873 def into_filter(self): +874 assert self._socket_path is None +875 self._socket_path = f"/tmp/vidformer-{self._name}-{str(uuid.uuid4())}.sock" +876 self._p = multiprocessing.Process( +877 target=_run_udf_host, args=(self, self._socket_path) +878 ) +879 self._p.start() +880 return Filter( +881 name=self._name, tl_func="IPC", socket=self._socket_path, func=self._name +882 ) +
+
+ class
+ UDFFrameType:
+
+
+
+
+
+ 1037class UDFFrameType: +1038 """ +1039 Frame type for use in UDFs. +1040 """ +1041 +1042 def __init__(self, width: int, height: int, pix_fmt: str): +1043 assert type(width) == int +1044 assert type(height) == int +1045 assert type(pix_fmt) == str +1046 +1047 self._width = width +1048 self._height = height +1049 self._pix_fmt = pix_fmt +1050 +1051 def width(self): +1052 return self._width +1053 +1054 def height(self): +1055 return self._height +1056 +1057 def pix_fmt(self): +1058 return self._pix_fmt +1059 +1060 def _response_ser(self): +1061 return { +1062 "frame_type": { +1063 "width": self._width, +1064 "height": self._height, +1065 "format": 2, # AV_PIX_FMT_RGB24 +1066 } +1067 } +1068 +1069 def __repr__(self): +1070 return f"FrameType<{self._width}x{self._height}, {self._pix_fmt}>" +
Frame type for use in UDFs.
+
+
+ class
+ UDFFrame:
+
+
+
+
+
+ 1073class UDFFrame: +1074 """A symbolic reference to a frame for use in UDFs.""" +1075 +1076 def __init__(self, data: np.ndarray, f_type: UDFFrameType): +1077 assert type(data) == np.ndarray +1078 assert type(f_type) == UDFFrameType +1079 +1080 # We only support RGB24 for now +1081 assert data.dtype == np.uint8 +1082 assert data.shape[2] == 3 +1083 +1084 # check type matches +1085 assert data.shape[0] == f_type.height() +1086 assert data.shape[1] == f_type.width() +1087 assert f_type.pix_fmt() == "rgb24" +1088 +1089 self._data = data +1090 self._f_type = f_type +1091 +1092 def data(self): +1093 return self._data +1094 +1095 def frame_type(self): +1096 return self._f_type +1097 +1098 def _response_ser(self): +1099 return { +1100 "frame": { +1101 "data": self._data.tobytes(), +1102 "width": self._f_type.width(), +1103 "height": self._f_type.height(), +1104 "format": "rgb24", +1105 } +1106 } +1107 +1108 def __repr__(self): +1109 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)
+
+
+
+
+
+ 1076 def __init__(self, data: np.ndarray, f_type: UDFFrameType): +1077 assert type(data) == np.ndarray +1078 assert type(f_type) == UDFFrameType +1079 +1080 # We only support RGB24 for now +1081 assert data.dtype == np.uint8 +1082 assert data.shape[2] == 3 +1083 +1084 # check type matches +1085 assert data.shape[0] == f_type.height() +1086 assert data.shape[1] == f_type.width() +1087 assert f_type.pix_fmt() == "rgb24" +1088 +1089 self._data = data +1090 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..e3fa78e --- /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,
§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..ffbb1d8 --- /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,
§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,
§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,
§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,
§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,
§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,
§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)
Implementations§
Source§impl FrameExpr
impl FrameExpr
Sourcepub fn add_source_deps<'a>(&'a self, deps: &mut BTreeSet<&'a FrameSource>)
pub fn add_source_deps<'a>(&'a self, deps: &mut BTreeSet<&'a FrameSource>)
Add all referenced frame sources to a set.
+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,
§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,
§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,
§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,
§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,
§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,
§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,
§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,
§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