Allow to enable frame copy on a video track

updating go.mod
🚧 replace by fork
2025-09-27 21:02:17 +08:00 · 2022-05-13 17:08:17 +02:00 · 2022-03-01 15:30:05 +01:00 · 2022-03-01 15:10:52 +01:00 · 2022-03-01 15:01:08 +01:00 · 2022-03-01 14:46:58 +01:00
37 changed files with 188 additions and 764 deletions
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -17,9 +17,9 @@ jobs:
    name: Linux Go ${{ matrix.go }}
    steps:
      - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v2
      - name: Setup Go
-        uses: actions/setup-go@v3
+        uses: actions/setup-go@v2
        with:
          go-version: ${{ matrix.go }}
      - name: Install dependencies
@@ -32,7 +32,7 @@ jobs:
            libx264-dev
      - name: Run Test Suite
        run: make test
-      - uses: codecov/codecov-action@v3	
+      - uses: codecov/codecov-action@v2	
        if: matrix.go == '1.16'
  build-darwin:
    runs-on: macos-latest
@@ -43,9 +43,9 @@ jobs:
    name: Darwin Go ${{ matrix.go }}
    steps:
      - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v2
      - name: Setup Go
-        uses: actions/setup-go@v3
+        uses: actions/setup-go@v2
        with:
          go-version: ${{ matrix.go }}
      - name: Install dependencies
@@ -62,9 +62,9 @@ jobs:
    name: Check Licenses
    steps:
      - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v2
      - name: Setup Go
-        uses: actions/setup-go@v3
+        uses: actions/setup-go@v2
        with:
          go-version: '1.16'
      - name: Installing go-licenses
--- a/.github/workflows/renovate-go-mod-fix.yaml
+++ b/.github/workflows/renovate-go-mod-fix.yaml
@@ -9,7 +9,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v2
        with:
          fetch-depth: 2
      - name: fix
--- a/.gitignore
+++ b/.gitignore
@@ -13,5 +13,3 @@

 scripts/cross
 coverage.txt
-
-.idea
--- a/.idea/mediadevices.iml
+++ b/.idea/mediadevices.iml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="Go" enabled="true" />
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>
--- a/.idea/modules.xml
+++ b/.idea/modules.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/mediadevices.iml" filepath="$PROJECT_DIR$/.idea/mediadevices.iml" />
+    </modules>
+  </component>
+</project>
--- a/.idea/vcs.xml
+++ b/.idea/vcs.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>
--- a/.idea/workspace.xml
+++ b/.idea/workspace.xml
@@ -0,0 +1,63 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="AutoImportSettings">
+    <option name="autoReloadType" value="SELECTIVE" />
+  </component>
+  <component name="ChangeListManager">
+    <list default="true" id="8804a8cb-7b92-421b-8786-b7715667b867" name="Changes" comment="">
+      <change afterPath="$PROJECT_DIR$/.idea/mediadevices.iml" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/.idea/modules.xml" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/.idea/vcs.xml" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/go.mod" beforeDir="false" afterPath="$PROJECT_DIR$/go.mod" afterDir="false" />
+    </list>
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="GOROOT" url="file:///usr/local/opt/go/libexec" />
+  <component name="Git.Settings">
+    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
+  </component>
+  <component name="GoLibraries">
+    <option name="indexEntireGoPath" value="false" />
+  </component>
+  <component name="KubernetesApiPersistence">
+    <option name="context" value="crane-nts-0" />
+    <option name="namespace" value="default" />
+  </component>
+  <component name="ProjectId" id="25msmAX4e3Virjg5KBrchpLrlbl" />
+  <component name="ProjectViewState">
+    <option name="autoscrollFromSource" value="true" />
+    <option name="autoscrollToSource" value="true" />
+    <option name="hideEmptyMiddlePackages" value="true" />
+    <option name="showLibraryContents" value="true" />
+  </component>
+  <component name="PropertiesComponent">
+    <property name="RunOnceActivity.OpenProjectViewOnStart" value="true" />
+    <property name="RunOnceActivity.ShowReadmeOnStart" value="true" />
+    <property name="WebServerToolWindowFactoryState" value="false" />
+    <property name="go.formatter.settings.were.checked" value="true" />
+    <property name="go.import.settings.migrated" value="true" />
+    <property name="go.sdk.automatically.set" value="true" />
+  </component>
+  <component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="application-level" UseSingleDictionary="true" transferred="true" />
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="8804a8cb-7b92-421b-8786-b7715667b867" name="Changes" comment="" />
+      <created>1646143753802</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1646143753802</updated>
+      <workItem from="1646143757180" duration="56000" />
+    </task>
+    <servers />
+  </component>
+  <component name="TypeScriptGeneratedFilesManager">
+    <option name="version" value="3" />
+  </component>
+  <component name="VgoProject">
+    <integration-enabled>true</integration-enabled>
+  </component>
+</project>
--- a/3
+++ b/3
@@ -16,8 +16,7 @@ supported_platforms := \
  linux-arm64 \
  linux-x64 \
  windows-x64 \
-  darwin-x64 \
-  darwin-arm64
+  darwin-x64
 cmd_build := build
 cmd_test := test
 examples_dir := examples
--- a/dockerfiles/darwin-arm64.Dockerfile
+++ b/dockerfiles/darwin-arm64.Dockerfile
@@ -1,47 +0,0 @@
-FROM dockercore/golang-cross as m1cross
-
-ARG DEBIAN_FRONTEND=noninteractive
-RUN apt-get update -qq && apt-get install -y -q --no-install-recommends \
-    cmake \
-    git \
-    libssl-dev \
-    libxml2-dev \
-    libz-dev \
-  && rm -rf /var/lib/apt/lists/*
-
-ENV SDK_VERSION=11.3 \
-    TARGET_DIR=/osxcross/target \
-    UNATTENDED=1
-
-WORKDIR /work
-RUN git clone --depth=1 https://github.com/tpoechtrager/osxcross.git /work \
-  && cd /work/tarballs \
-  && wget -q https://github.com/phracker/MacOSX-SDKs/releases/download/${SDK_VERSION}/MacOSX${SDK_VERSION}.sdk.tar.xz
-
-# Build cross compile toolchain for Apple silicon
-RUN ./build.sh
-
-
-FROM dockcross/base
-
-ENV OSX_CROSS_PATH=/osxcross
-
-COPY --from=m1cross "${OSX_CROSS_PATH}/." "${OSX_CROSS_PATH}/"
-ENV PATH=${OSX_CROSS_PATH}/target/bin:$PATH
-
-COPY init.sh /tmp/init.sh
-RUN bash /tmp/init.sh
-
-ENV CC=arm64-apple-darwin20.4-clang \
-    CXX=arm64-apple-darwin20.4-clang++ \
-    CPP=arm64-apple-darwin20.4-clang++ \
-    AR=arm64-apple-darwin20.4-ar \
-    AS=arm64-apple-darwin20.4-as \
-    LD=arm64-apple-darwin20.4-ld
-
-COPY darwin-arm64.cmake ${OSX_CROSS_PATH}/
-ENV CMAKE_TOOLCHAIN_FILE ${OSX_CROSS_PATH}/darwin-arm64.cmake
-
-ARG IMAGE=lherman/cross-darwin-arm64
-ARG VERSION=latest
-ENV DEFAULT_DOCKCROSS_IMAGE ${IMAGE}:${VERSION}
--- a/dockerfiles/darwin-arm64.cmake
+++ b/dockerfiles/darwin-arm64.cmake
@@ -1,8 +0,0 @@
-set(CMAKE_SYSTEM_NAME Darwin)
-set(CMAKE_SYSTEM_VERSION 1)
-set(CMAKE_SYSTEM_PROCESSOR arm64)
-
-set(CMAKE_C_COMPILER $ENV{CC})
-set(CMAKE_CXX_COMPILER $ENV{CXX})
-set(CMAKE_AR $ENV{AR})
-set(CMAKE_ASM_COMPILER ${CMAKE_C_COMPILER})
--- a/go.mod
+++ b/go.mod
@@ -5,14 +5,14 @@ go 1.13
 replace github.com/pion/webrtc/v3 => github.com/EmrysMyrddin/webrtc/v3 v3.1.25-0.20220301142221-d92d68ff068f

 require (
-	github.com/blackjack/webcam v0.0.0-20220329180758-ba064708e165
+	github.com/blackjack/webcam v0.0.0-20200313125108-10ed912a8539
 	github.com/gen2brain/malgo v0.10.35
 	github.com/google/uuid v1.3.0
 	github.com/kbinani/screenshot v0.0.0-20210720154843-7d3a670d8329
 	github.com/pion/logging v0.2.2
 	github.com/pion/rtcp v1.2.9
-	github.com/pion/rtp v1.7.13
-	github.com/pion/webrtc/v3 v3.1.34
-	golang.org/x/image v0.0.0-20220617043117-41969df76e82
+	github.com/pion/rtp v1.7.4
+	github.com/pion/webrtc/v3 v3.1.10
+	golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d
 	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
 )
--- a/go.sum
+++ b/go.sum
@@ -1,7 +1,7 @@
 github.com/EmrysMyrddin/webrtc/v3 v3.1.25-0.20220301142221-d92d68ff068f h1:o7MCxR85nZxyOgjkmjtnXHsmPmchX3AEbWb/Bgpy3aI=
 github.com/EmrysMyrddin/webrtc/v3 v3.1.25-0.20220301142221-d92d68ff068f/go.mod h1:mO/yv7fBN3Lp7YNlnYcTj1jtpvNvssJG+7eh6itZ4xM=
-github.com/blackjack/webcam v0.0.0-20220329180758-ba064708e165 h1:QsIbRyO2tn5eSJZ/skuDqSTo0GWI5H4G1AT7Mm2H0Nw=
-github.com/blackjack/webcam v0.0.0-20220329180758-ba064708e165/go.mod h1:G0X+rEqYPWSq0dG8OMf8M446MtKytzpPjgS3HbdOJZ4=
+github.com/blackjack/webcam v0.0.0-20200313125108-10ed912a8539 h1:1aIqYfg9s9RETAJHGfVKZW4ok0b22p4QTwk8MsdRtPs=
+github.com/blackjack/webcam v0.0.0-20200313125108-10ed912a8539/go.mod h1:G0X+rEqYPWSq0dG8OMf8M446MtKytzpPjgS3HbdOJZ4=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -68,9 +68,8 @@ github.com/pion/rtcp v1.2.6/go.mod h1:52rMNPWFsjr39z9B9MhnkqhPLoeHTv1aN63o/42bWE
 github.com/pion/rtcp v1.2.9 h1:1ujStwg++IOLIEoOiIQ2s+qBuJ1VN81KW+9pMPsif+U=
 github.com/pion/rtcp v1.2.9/go.mod h1:qVPhiCzAm4D/rxb6XzKeyZiQK69yJpbUDJSF7TgrqNo=
 github.com/pion/rtp v1.7.0/go.mod h1:bDb5n+BFZxXx0Ea7E5qe+klMuqiBrP+w8XSjiWtCUko=
+github.com/pion/rtp v1.7.4 h1:4dMbjb1SuynU5OpA3kz1zHK+u+eOCQjW3MAeVHf1ODA=
 github.com/pion/rtp v1.7.4/go.mod h1:bDb5n+BFZxXx0Ea7E5qe+klMuqiBrP+w8XSjiWtCUko=
-github.com/pion/rtp v1.7.13 h1:qcHwlmtiI50t1XivvoawdCGTP4Uiypzfrsap+bijcoA=
-github.com/pion/rtp v1.7.13/go.mod h1:bDb5n+BFZxXx0Ea7E5qe+klMuqiBrP+w8XSjiWtCUko=
 github.com/pion/sctp v1.8.0/go.mod h1:xFe9cLMZ5Vj6eOzpyiKjT9SwGM4KpK/8Jbw5//jc+0s=
 github.com/pion/sctp v1.8.2 h1:yBBCIrUMJ4yFICL3RIvR4eh/H2BTTvlligmSTy+3kiA=
 github.com/pion/sctp v1.8.2/go.mod h1:xFe9cLMZ5Vj6eOzpyiKjT9SwGM4KpK/8Jbw5//jc+0s=
@@ -102,8 +101,8 @@ golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8U
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20220131195533-30dcbda58838 h1:71vQrMauZZhcTVK6KdYM+rklehEEwb3E+ZhaE5jrPrE=
 golang.org/x/crypto v0.0.0-20220131195533-30dcbda58838/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
-golang.org/x/image v0.0.0-20220617043117-41969df76e82 h1:KpZB5pUSBvrHltNEdK/tw0xlPeD13M6M6aGP32gKqiw=
-golang.org/x/image v0.0.0-20220617043117-41969df76e82/go.mod h1:doUCurBvlfPMKfmIpRIywoHmhN3VyhnoFDbvIEWF4hY=
+golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d h1:RNPAfi2nHY7C2srAV8A49jpsYr0ADedCk1wq6fTMTvs=
+golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
--- a/mediadevices_test.go
+++ b/mediadevices_test.go
@@ -8,7 +8,6 @@ import (
 	"github.com/pion/mediadevices/pkg/driver"
 	_ "github.com/pion/mediadevices/pkg/driver/audiotest"
 	_ "github.com/pion/mediadevices/pkg/driver/videotest"
-	"github.com/pion/mediadevices/pkg/frame"
 	"github.com/pion/mediadevices/pkg/prop"
 )

@@ -98,58 +97,20 @@ func TestSelectBestDriverConstraintsResultIsSetProperly(t *testing.T) {
 		t.Fatal("expect to get at least 1 property")
 	}
 	expectedProp := driver.Properties()[0]
+	// Since this is a continuous value, bestConstraints should be set with the value that user specified
+	expectedProp.FrameRate = 30.0

-	// By reducing the value from the driver by a tiny amount, this property should be chosen.
-	// At the same time, we'll be able to find out if the return constraints will be properly set
-	// to the best constraints.
-	cases := map[string]struct {
-		width, height int
-		frameFormat   frame.Format
-		frameRate     float32
-	}{
-		"DifferentWidth": {
-			width:       expectedProp.Width - 1,
-			height:      expectedProp.Height,
-			frameFormat: expectedProp.FrameFormat,
-			frameRate:   expectedProp.FrameRate,
-		},
-		"DifferentHeight": {
-			width:       expectedProp.Width,
-			height:      expectedProp.Height - 1,
-			frameFormat: expectedProp.FrameFormat,
-			frameRate:   expectedProp.FrameRate,
-		},
-		"DifferentFrameFormat": {
-			width:       expectedProp.Width,
-			height:      expectedProp.Height,
-			frameFormat: frame.FormatI420,
-			frameRate:   expectedProp.FrameRate,
-		},
-	}
-
-	for name, c := range cases {
-		c := c
-		t.Run(name, func(t *testing.T) {
-			var vc prop.VideoConstraints
-
-			if c.frameRate >= 0 {
-				vc = prop.VideoConstraints{
-					Width:       prop.Int(c.width),
-					Height:      prop.Int(c.height),
-					FrameFormat: prop.FrameFormat(c.frameFormat),
-					FrameRate:   prop.Float(c.frameRate),
-				}
-			} else {
-				// do not specify the framerate
-				vc = prop.VideoConstraints{
-					Width:       prop.Int(c.width),
-					Height:      prop.Int(c.height),
-					FrameFormat: prop.FrameFormat(c.frameFormat),
-				}
-			}
 	wantConstraints := MediaTrackConstraints{
 		MediaConstraints: prop.MediaConstraints{
-					VideoConstraints: vc,
+			VideoConstraints: prop.VideoConstraints{
+				// By reducing the width from the driver by a tiny amount, this property should be chosen.
+				// At the same time, we'll be able to find out if the return constraints will be properly set
+				// to the best constraints.
+				Width:       prop.Int(expectedProp.Width - 1),
+				Height:      prop.Int(expectedProp.Width),
+				FrameFormat: prop.FrameFormat(expectedProp.FrameFormat),
+				FrameRate:   prop.Float(30.0),
+			},
 		},
 	}

@@ -169,74 +130,4 @@ func TestSelectBestDriverConstraintsResultIsSetProperly(t *testing.T) {
 		s.FrameRate != expectedProp.FrameRate {
 		t.Fatalf("failed to return best constraints\nexpected:\n%v\n\ngot:\n%v", expectedProp, bestConstraints.selectedMedia)
 	}
-
-		})
-	}
-
-}
-
-func TestSelectBestDriverConstraintsNoFit(t *testing.T) {
-	filterFn := driver.FilterVideoRecorder()
-	drivers := driver.GetManager().Query(filterFn)
-	if len(drivers) == 0 {
-		t.Fatal("expect to get at least 1 driver")
-	}
-
-	driver := drivers[0]
-	err := driver.Open()
-	if err != nil {
-		t.Fatal("expect to open driver successfully")
-	}
-	defer driver.Close()
-
-	if len(driver.Properties()) == 0 {
-		t.Fatal("expect to get at least 1 property")
-	}
-	expectedProp := driver.Properties()[0]
-
-	cases := map[string]struct {
-		width, height int
-		frameFormat   frame.Format
-		frameRate     float32
-	}{
-		"DifferentWidth": {
-			width:       expectedProp.Width - 1,
-			height:      expectedProp.Height,
-			frameFormat: expectedProp.FrameFormat,
-			frameRate:   expectedProp.FrameRate,
-		},
-		"DifferentHeight": {
-			width:       expectedProp.Width,
-			height:      expectedProp.Height - 1,
-			frameFormat: expectedProp.FrameFormat,
-			frameRate:   expectedProp.FrameRate,
-		},
-		"DifferentFrameFormat": {
-			width:       expectedProp.Width,
-			height:      expectedProp.Height,
-			frameFormat: frame.FormatI420,
-			frameRate:   expectedProp.FrameRate,
-		},
-	}
-
-	for name, c := range cases {
-		c := c
-		t.Run(name, func(t *testing.T) {
-			wantConstraints := MediaTrackConstraints{
-				MediaConstraints: prop.MediaConstraints{
-					VideoConstraints: prop.VideoConstraints{
-						Width:       prop.IntExact(c.width),
-						Height:      prop.IntExact(c.height),
-						FrameFormat: prop.FrameFormatExact(c.frameFormat),
-						FrameRate:   prop.FloatExact(c.frameRate),
-					},
-				},
-			}
-
-			_, _, err := selectBestDriver(filterFn, wantConstraints)
-			if err == nil {
-				t.Fatal("expect to not find a driver that fits the constraints")
-			}
-		})
-	}
 }
--- a/pkg/avfoundation/avfoundation_darwin.go
+++ b/pkg/avfoundation/avfoundation_darwin.go
@@ -11,7 +11,6 @@ package avfoundation
 // }
 import "C"
 import (
-	"context"
 	"fmt"
 	"io"
 	"unsafe"
@@ -97,8 +96,6 @@ type ReadCloser struct {
 	dataChan chan []byte
 	id       handleID
 	onClose  func()
-	cancelCtx  context.Context
-	cancelFunc func()
 }

 func newReadCloser(onClose func()) *ReadCloser {
@@ -106,22 +103,12 @@ func newReadCloser(onClose func()) *ReadCloser {
 	rc.dataChan = make(chan []byte, 1)
 	rc.onClose = onClose
 	rc.id = register(rc.dataCb)
-	cancelCtx, cancelFunc := context.WithCancel(context.Background())
-	rc.cancelCtx = cancelCtx
-	rc.cancelFunc = cancelFunc
 	return &rc
 }

 func (rc *ReadCloser) dataCb(data []byte) {
 	// TODO: add a policy for slow reader
-	if rc.cancelCtx.Err() != nil {
-		return
-	}
-	select {
-	case <-rc.cancelCtx.Done():
-		close(rc.dataChan)
-	case rc.dataChan <- data:
-	}
+	rc.dataChan <- data
 }

 // Read reads raw data, the format is determined by the media type and property:
@@ -140,7 +127,7 @@ func (rc *ReadCloser) Close() {
 	if rc.onClose != nil {
 		rc.onClose()
 	}
-	rc.cancelFunc()
+	close(rc.dataChan)
 	unregister(rc.id)
 }

--- a/pkg/codec/openh264/bridge.cpp
+++ b/pkg/codec/openh264/bridge.cpp
@@ -81,15 +81,16 @@ Slice enc_encode(Encoder *e, Frame f, int *eresult) {
  Slice payload = {0};

  if(e->force_key_frame == 1) {
-    e->engine->ForceIntraFrame(true);
+    info.eFrameType = videoFrameTypeI;
    e->force_key_frame = 0;
  }

  pic.iPicWidth = f.width;
  pic.iPicHeight = f.height;
  pic.iColorFormat = videoFormatI420;
-  pic.iStride[0] = f.ystride;
-  pic.iStride[1] = pic.iStride[2] = f.cstride;
+  // We always received I420 format
+  pic.iStride[0] = pic.iPicWidth;
+  pic.iStride[1] = pic.iStride[2] = pic.iPicWidth / 2;
  pic.pData[0] = (unsigned char *)f.y;
  pic.pData[1] = (unsigned char *)f.u;
  pic.pData[2] = (unsigned char *)f.v;
--- a/pkg/codec/openh264/bridge.hpp
+++ b/pkg/codec/openh264/bridge.hpp
@@ -12,8 +12,6 @@ typedef struct Slice {

 typedef struct Frame {
  void *y, *u, *v;
-  int ystride;
-  int cstride;
  int height;
  int width;
 } Frame;
--- a/pkg/codec/openh264/lib/libopenh264-darwin-arm64.a
+++ b/pkg/codec/openh264/lib/libopenh264-darwin-arm64.a
--- a/pkg/codec/openh264/openh264.go
+++ b/pkg/codec/openh264/openh264.go
@@ -68,8 +68,6 @@ func (e *encoder) Read() ([]byte, func(), error) {
 		y:      unsafe.Pointer(&yuvImg.Y[0]),
 		u:      unsafe.Pointer(&yuvImg.Cb[0]),
 		v:      unsafe.Pointer(&yuvImg.Cr[0]),
-		ystride: C.int(yuvImg.YStride),
-		cstride: C.int(yuvImg.CStride),
 		height: C.int(bounds.Max.Y - bounds.Min.Y),
 		width:  C.int(bounds.Max.X - bounds.Min.X),
 	}, &rv)
--- a/pkg/codec/openh264/openh264_static.go
+++ b/pkg/codec/openh264/openh264_static.go
@@ -8,6 +8,5 @@ package openh264
 //#cgo linux,arm64 LDFLAGS: ${SRCDIR}/lib/libopenh264-linux-arm64.a
 //#cgo linux,amd64 LDFLAGS: ${SRCDIR}/lib/libopenh264-linux-x64.a
 //#cgo darwin,amd64 LDFLAGS: ${SRCDIR}/lib/libopenh264-darwin-x64.a
-//#cgo darwin,arm64 LDFLAGS: ${SRCDIR}/lib/libopenh264-darwin-arm64.a
 //#cgo windows,amd64 LDFLAGS: ${SRCDIR}/lib/libopenh264-windows-x64.a -lssp
 import "C"
--- a/pkg/codec/opus/lib/libopus-darwin-arm64.a
+++ b/pkg/codec/opus/lib/libopus-darwin-arm64.a
--- a/pkg/codec/opus/opus_static.go
+++ b/pkg/codec/opus/opus_static.go
@@ -8,6 +8,5 @@ package opus
 //#cgo linux,arm64 LDFLAGS: ${SRCDIR}/lib/libopus-linux-arm64.a -lm
 //#cgo linux,amd64 LDFLAGS: ${SRCDIR}/lib/libopus-linux-x64.a -lm
 //#cgo darwin,amd64 LDFLAGS: ${SRCDIR}/lib/libopus-darwin-x64.a
-//#cgo darwin,arm64 LDFLAGS: ${SRCDIR}/lib/libopus-darwin-arm64.a
 //#cgo windows,amd64 LDFLAGS: ${SRCDIR}/lib/libopus-windows-x64.a
 import "C"
--- a/pkg/codec/x264/bridge.h
+++ b/pkg/codec/x264/bridge.h
@@ -18,7 +18,6 @@ typedef struct Encoder {
  x264_t *h;
  x264_picture_t pic_in;
  x264_param_t param;
-  int force_key_frame;
 } Encoder;

 Encoder *enc_new(x264_param_t param, char *preset, int *rc) {
@@ -86,14 +85,8 @@ Slice enc_encode(Encoder *e, uint8_t *y, uint8_t *cb, uint8_t *cr, int *rc) {
  e->pic_in.img.plane[0] = y;
  e->pic_in.img.plane[1] = cb;
  e->pic_in.img.plane[2] = cr;
-  if (e->force_key_frame) {
-    e->pic_in.i_type = X264_TYPE_IDR;
-  } else {
-    e->pic_in.i_type = X264_TYPE_AUTO;
-  }

  int frame_size = x264_encoder_encode(e->h, &nal, &i_nal, &e->pic_in, &pic_out);
-  e->force_key_frame = 0;
  Slice s = {.data_len = frame_size};
  if (frame_size <= 0) {
    *rc = ERR_ENCODE;
--- a/pkg/codec/x264/x264.go
+++ b/pkg/codec/x264/x264.go
@@ -124,11 +124,6 @@ func (e *encoder) Read() ([]byte, func(), error) {
 	return encoded, func() {}, err
 }

-func (e *encoder) ForceKeyFrame() error {
-	e.engine.force_key_frame = C.int(1)
-	return nil
-}
-
 func (e *encoder) Controller() codec.EncoderController {
 	return e
 }
--- a/pkg/codec/x264/x264_test.go
+++ b/pkg/codec/x264/x264_test.go
@@ -49,6 +49,8 @@ func TestEncoder(t *testing.T) {
 }

 func TestShouldImplementKeyFrameControl(t *testing.T) {
+	t.SkipNow() // TODO: Implement key frame control
+
 	e := &encoder{}
 	if _, ok := e.Controller().(codec.KeyFrameController); !ok {
 		t.Error()
--- a/pkg/driver/camera/camera_darwin.go
+++ b/pkg/driver/camera/camera_darwin.go
@@ -13,7 +13,6 @@ import (
 type camera struct {
 	device  avfoundation.Device
 	session *avfoundation.Session
-	rcClose func()
 }

 func init() {
@@ -44,9 +43,6 @@ func (cam *camera) Open() error {
 }

 func (cam *camera) Close() error {
-	if cam.rcClose != nil {
-		cam.rcClose()
-	}
 	return cam.session.Close()
 }

@@ -60,7 +56,6 @@ func (cam *camera) VideoRecord(property prop.Media) (video.Reader, error) {
 	if err != nil {
 		return nil, err
 	}
-	cam.rcClose = rc.Close
 	r := video.ReaderFunc(func() (image.Image, func(), error) {
 		frame, _, err := rc.Read()
 		if err != nil {
--- a/pkg/driver/camera/camera_linux.go
+++ b/pkg/driver/camera/camera_linux.go
@@ -10,7 +10,6 @@ import (
 	"io"
 	"os"
 	"path/filepath"
-	"strconv"
 	"sync"

 	"github.com/blackjack/webcam"
@@ -134,19 +133,6 @@ func newCamera(path string) *camera {
 	return c
 }

-func getCameraReadTimeout() uint32 {
-	// default to 5 seconds
-	var readTimeoutSec uint32 = 5
-	if val, ok := os.LookupEnv("PION_MEDIADEVICES_CAMERA_READ_TIMEOUT"); ok {
-		if valInt, err := strconv.Atoi(val); err == nil {
-			if valInt > 0 {
-				readTimeoutSec = uint32(valInt)
-			}
-		}
-	}
-	return readTimeoutSec
-}
-
 func (c *camera) Open() error {
 	cam, err := webcam.Open(c.path)
 	if err != nil {
@@ -193,21 +179,12 @@ func (c *camera) VideoRecord(p prop.Media) (video.Reader, error) {
 		return nil, err
 	}

-	if p.FrameRate > 0 {
-		err = c.cam.SetFramerate(float32(p.FrameRate))
-		if err != nil {
-			return nil, err
-		}
-	}
-
 	if err := c.cam.StartStreaming(); err != nil {
 		return nil, err
 	}

 	cam := c.cam

-	readTimeoutSec := getCameraReadTimeout()
-
 	ctx, cancel := context.WithCancel(context.Background())
 	c.cancel = cancel
 	var buf []byte
@@ -223,7 +200,7 @@ func (c *camera) VideoRecord(p prop.Media) (video.Reader, error) {
 				return nil, func() {}, io.EOF
 			}

-			err := cam.WaitForFrame(readTimeoutSec)
+			err := cam.WaitForFrame(5) // 5 seconds
 			switch err.(type) {
 			case nil:
 			case *webcam.Timeout:
--- a/pkg/driver/camera/camera_linux_test.go
+++ b/pkg/driver/camera/camera_linux_test.go
@@ -70,31 +70,3 @@ func TestDiscover(t *testing.T) {
 		t.Errorf("Expected label: %s, got: %s", expectedNoLink, label)
 	}
 }
-
-func TestGetCameraReadTimeout(t *testing.T) {
-	var expected uint32 = 5
-	value := getCameraReadTimeout()
-	if value != expected {
-		t.Errorf("Expected: %d, got: %d", expected, value)
-	}
-
-	envVarName := "PION_MEDIADEVICES_CAMERA_READ_TIMEOUT"
-	os.Setenv(envVarName, "text")
-	value = getCameraReadTimeout()
-	if value != expected {
-		t.Errorf("Expected: %d, got: %d", expected, value)
-	}
-
-	os.Setenv(envVarName, "-1")
-	value = getCameraReadTimeout()
-	if value != expected {
-		t.Errorf("Expected: %d, got: %d", expected, value)
-	}
-
-	os.Setenv(envVarName, "1")
-	expected = 1
-	value = getCameraReadTimeout()
-	if value != expected {
-		t.Errorf("Expected: %d, got: %d", expected, value)
-	}
-}
--- a/pkg/driver/microphone/microphone.go
+++ b/pkg/driver/microphone/microphone.go
@@ -111,8 +111,6 @@ func (m *microphone) AudioRecord(inputProp prop.Media) (audio.Reader, error) {
 	config.PerformanceProfile = malgo.LowLatency
 	config.Capture.Channels = uint32(inputProp.ChannelCount)
 	config.SampleRate = uint32(inputProp.SampleRate)
-	//FIX: Turn on the microphone with the current device id
-	config.Capture.DeviceID = m.ID.Pointer()
 	if inputProp.SampleSize == 4 && inputProp.IsFloat {
 		config.Capture.Format = malgo.FormatF32
 	} else if inputProp.SampleSize == 2 && !inputProp.IsFloat {
--- a/pkg/driver/videotest/dummy.go
+++ b/pkg/driver/videotest/dummy.go
@@ -47,6 +47,10 @@ func (d *dummy) Close() error {
 }

 func (d *dummy) VideoRecord(p prop.Media) (video.Reader, error) {
+	if p.FrameRate == 0 {
+		p.FrameRate = 30
+	}
+
 	colors := [][3]byte{
 		{235, 128, 128},
 		{210, 16, 146},
@@ -139,7 +143,6 @@ func (d dummy) Properties() []prop.Media {
 				Width:       640,
 				Height:      480,
 				FrameFormat: frame.FormatYUYV,
-				FrameRate:   30,
 			},
 		},
 	}
--- a/pkg/driver/vncdriver/vnc/encoding.go
+++ b/pkg/driver/vncdriver/vnc/encoding.go
@@ -18,25 +18,6 @@ type Encoding interface {
 	// the proper data.
 	Read(*ClientConn, *Rectangle, io.Reader) (Encoding, error)
 }
-type CursorEncoding struct {
-}
-
-func (*CursorEncoding) Type() int32 {
-	return -239
-}
-func (*CursorEncoding) Read(c *ClientConn, rect *Rectangle, r io.Reader) (Encoding, error) {
-	size := int(rect.Height) * int(rect.Width) * int(c.PixelFormat.BPP) / 8
-	pixelBytes := make([]uint8, size)
-	if _, err := io.ReadFull(r, pixelBytes); err != nil {
-		return nil, err
-	}
-	mask := ((int(rect.Width) + 7) / 8) * int(rect.Height)
-	maskBytes := make([]uint8, mask)
-	if _, err := io.ReadFull(r, maskBytes); err != nil {
-		return nil, err
-	}
-	return &CursorEncoding{}, nil
-}

 // RawEncoding is raw pixel data sent by the server.
 //
@@ -51,7 +32,6 @@ func (*RawEncoding) Type() int32 {
 }

 func (*RawEncoding) Read(c *ClientConn, rect *Rectangle, r io.Reader) (Encoding, error) {
-	//fmt.Println("RawEncoding")
 	bytesPerPixel := c.PixelFormat.BPP / 8
 	pixelBytes := make([]uint8, bytesPerPixel)

@@ -82,22 +62,16 @@ func (*RawEncoding) Read(c *ClientConn, rect *Rectangle, r io.Reader) (Encoding,
 				color.R = uint16((rawPixel >> c.PixelFormat.RedShift) & uint32(c.PixelFormat.RedMax))
 				color.G = uint16((rawPixel >> c.PixelFormat.GreenShift) & uint32(c.PixelFormat.GreenMax))
 				color.B = uint16((rawPixel >> c.PixelFormat.BlueShift) & uint32(c.PixelFormat.BlueMax))
-				if c.PixelFormat.BPP == 16 {
-					color.B = color.B<<3 | color.B>>2
-					color.G = color.G<<2 | color.G>>2
-					color.R = color.R<<3 | color.R>>2
-				}
 			} else {
 				*color = c.ColorMap[rawPixel]
 			}
-			rawPixels[int(y)*int(rect.Width)+int(x)] = uint32(0xff)<<24 | uint32(color.B)<<16 | uint32(color.G)<<8 | uint32(color.R)
+			rawPixels[int(y)*int(rect.Width)+int(x)]=uint32(color.B)<<16 | uint32(color.G)<<8 | uint32(color.R)
 			//fmt.Printf("%x %x",rawPixel,rawPixels[int(y)*int(rect.Width)+int(x)])
 		}
 	}

 	return &RawEncoding{colors,rawPixels}, nil
 }
-
 // ZlibEncoding is raw pixel data sent by the server compressed by Zlib.
 //
 // A single Zlib stream is created. There is only a single header for a framebuffer request response.
@@ -113,7 +87,6 @@ func (*ZlibEncoding) Type() int32 {
 }

 func (ze *ZlibEncoding) Read(c *ClientConn, rect *Rectangle, r io.Reader) (Encoding, error) {
-	//fmt.Println("ZlibEncoding")
 	bytesPerPixel := c.PixelFormat.BPP / 8
 	pixelBytes := make([]uint8, bytesPerPixel)

@@ -125,6 +98,7 @@ func (ze *ZlibEncoding) Read(c *ClientConn, rect *Rectangle, r io.Reader) (Encod
 	// Format
 	// 4 bytes        | uint32 | length
 	// 'length' bytes | []byte | zlibData
+
 	// Read zlib length
 	var zipLength uint32
 	err := binary.Read(r, binary.BigEndian, &zipLength)
@@ -193,15 +167,10 @@ func (ze *ZlibEncoding) Read(c *ClientConn, rect *Rectangle, r io.Reader) (Encod
 				color.R = uint16((rawPixel >> c.PixelFormat.RedShift) & uint32(c.PixelFormat.RedMax))
 				color.G = uint16((rawPixel >> c.PixelFormat.GreenShift) & uint32(c.PixelFormat.GreenMax))
 				color.B = uint16((rawPixel >> c.PixelFormat.BlueShift) & uint32(c.PixelFormat.BlueMax))
-				if c.PixelFormat.BPP == 16 {
-					color.B = color.B<<3 | color.B>>2
-					color.G = color.G<<2 | color.G>>2
-					color.R = color.R<<3 | color.R>>2
-				}
 			} else {
 				*color = c.ColorMap[rawPixel]
 			}
-			rawPixels[int(y)*int(rect.Width)+int(x)] = uint32(0xff)<<24 | uint32(color.B)<<16 | uint32(color.G)<<8 | uint32(color.R)
+			rawPixels[int(y)*int(rect.Width)+int(x)]=uint32(color.B)<<16 | uint32(color.G)<<8 | uint32(color.R)
 		}
 	}

--- a/pkg/driver/vncdriver/vncdriver.go
+++ b/pkg/driver/vncdriver/vncdriver.go
@@ -5,14 +5,13 @@ import (
 	"context"
 	"encoding/binary"
 	"fmt"
+	"github.com/pion/mediadevices/pkg/driver/vncdriver/vnc"
 	"image"
 	"io"
 	"net"
 	"sync"
 	"time"

-	"github.com/pion/mediadevices/pkg/driver/vncdriver/vnc"
-
 	"github.com/pion/mediadevices/pkg/frame"
 	"github.com/pion/mediadevices/pkg/io/video"
 	"github.com/pion/mediadevices/pkg/prop"
@@ -50,10 +49,7 @@ func (d *vncDevice) Open() error {
 	d.closed = ctx.Done()
 	d.cancel = cancel
 	msg := make(chan vnc.ServerMessage, 1)
-	//auth:=new(vnc.PasswordAuth)
-	//auth.Password="####"
 	conf := vnc.ClientConfig{
-		//Auth: []vnc.ClientAuth{auth},
 		ServerMessageCh: msg,
 		Exclusive:       false,
 	}
@@ -70,7 +66,6 @@ func (d *vncDevice) Open() error {
 	d.vClient.SetEncodings([]vnc.Encoding{
 		&vnc.ZlibEncoding{},
 		&vnc.RawEncoding{},
-		&vnc.CursorEncoding{},
 	})
 	d.w = int(d.vClient.FrameBufferWidth)
 	d.h = int(d.vClient.FrameBufferHeight)
@@ -94,9 +89,6 @@ func (d *vncDevice) Open() error {
 					for _, rect := range t.Rectangles {
 						var pix []uint32
 						switch t := rect.Enc.(type) {
-						case *vnc.CursorEncoding:
-							//ignore remote cursor messages
-							continue
 						case *vnc.RawEncoding:
 							pix = t.RawPixel
 						case *vnc.ZlibEncoding:
@@ -105,16 +97,19 @@ func (d *vncDevice) Open() error {
 						for y := int(rect.Y); y < int(rect.Height+rect.Y); y++ {
 							for x := int(rect.X); x < int(rect.Width+rect.X); x++ {
 								binary.LittleEndian.PutUint32(d.rawPixel[(y*d.w+x)*4:], pix[(y-int(rect.Y))*int(rect.Width)+(x-int(rect.X))])
+								//BigEndian
 							}
 						}

 					}
+					//time.Sleep(33 * time.Millisecond)
 					d.vClient.FramebufferUpdateRequest(true, 0, 0, uint16(d.w), uint16(d.h))
 					break
 				default:

 				}
 			case <-time.After(10 * time.Second):
+				//fmt.Println("Timeout FramebufferUpdate")
 				if d.vClient.FramebufferUpdateRequest(true, 0, 0, uint16(d.w), uint16(d.h)) != nil {
 					d.cancel()
 					return
@@ -142,12 +137,13 @@ func (d *vncDevice) Close() error {

 func (d *vncDevice) VideoRecord(p prop.Media) (video.Reader, error) {
 	if p.FrameRate == 0 {
-		p.FrameRate = 30
+		p.FrameRate = 15
 	}

 	tick := time.NewTicker(time.Duration(float32(time.Second) / p.FrameRate))
 	d.tick = tick
 	closed := d.closed
+	pixs := make([]byte, d.h*d.w*4)
 	r := video.ReaderFunc(func() (image.Image, func(), error) {
 		select {
 		case <-closed:
@@ -157,8 +153,9 @@ func (d *vncDevice) VideoRecord(p prop.Media) (video.Reader, error) {
 		}

 		<-tick.C
+		copy(pixs, d.rawPixel)
 		return &image.RGBA{
-			Pix:    d.rawPixel,
+			Pix:    pixs,
 			Stride: 4,
 			Rect:   image.Rect(0, 0, d.w, d.h),
 		}, func() {}, nil
--- a/pkg/io/video/scale.go
+++ b/pkg/io/video/scale.go
@@ -109,7 +109,7 @@ func Scale(width, height int, scaler Scaler) TransformFunc {
 			yDy := rect.Dy()
 			cRect := fixedRect(rect, i1.SubsampleRatio)
 			cDx := cRect.Dx()
-			cDy := cRect.Dy()
+			cDy := cRect.Dx()
 			yLen := yDx * yDy
 			cLen := cDx * cDy
 			if len(imgDst.Y) < yLen {
--- a/pkg/io/video/scale_test.go
+++ b/pkg/io/video/scale_test.go
@@ -36,32 +36,6 @@ func TestScale(t *testing.T) {
 				Rect:   image.Rect(0, 0, 2, 2),
 			},
 		},
-		"RGBASameSize": {
-			src: &image.RGBA{
-				Pix: []uint8{
-					// R     G     B     A |   R     G     B     A |   R     G     B     A |   R     G     B     A
-					0x80, 0x00, 0x00, 0xFF, 0x80, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF,
-					0x80, 0x00, 0x00, 0xFF, 0x80, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF,
-					0x00, 0x40, 0x00, 0xFF, 0x00, 0x40, 0x00, 0xFF, 0x00, 0x00, 0x60, 0xFF, 0x00, 0x00, 0x60, 0xFF,
-					0x00, 0x40, 0x00, 0xFF, 0x00, 0x40, 0x00, 0xFF, 0x00, 0x00, 0x60, 0xFF, 0x00, 0x00, 0x60, 0xFF,
-				},
-				Stride: 16,
-				Rect:   image.Rect(0, 0, 4, 4),
-			},
-			width:  4,
-			height: 4,
-			expected: &image.RGBA{
-				Pix: []uint8{
-					// R     G     B     A |   R     G     B     A |   R     G     B     A |   R     G     B     A
-					0x80, 0x00, 0x00, 0xFF, 0x80, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF,
-					0x80, 0x00, 0x00, 0xFF, 0x80, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF,
-					0x00, 0x40, 0x00, 0xFF, 0x00, 0x40, 0x00, 0xFF, 0x00, 0x00, 0x60, 0xFF, 0x00, 0x00, 0x60, 0xFF,
-					0x00, 0x40, 0x00, 0xFF, 0x00, 0x40, 0x00, 0xFF, 0x00, 0x00, 0x60, 0xFF, 0x00, 0x00, 0x60, 0xFF,
-				},
-				Stride: 16,
-				Rect:   image.Rect(0, 0, 4, 4),
-			},
-		},
 		"I444": {
 			src: &image.YCbCr{
 				SubsampleRatio: image.YCbCrSubsampleRatio444,
@@ -117,70 +91,6 @@ func TestScale(t *testing.T) {
 				Rect:    image.Rect(0, 0, 3, 3),
 			},
 		},
-		"I444SameSize": {
-			src: &image.YCbCr{
-				SubsampleRatio: image.YCbCrSubsampleRatio444,
-				Y: []uint8{
-					0xF0, 0xF0, 0x00, 0x00, 0x00, 0x00,
-					0xF0, 0xF0, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x40, 0x40,
-					0x00, 0x00, 0x00, 0x00, 0x40, 0x40,
-					0x00, 0x00, 0x80, 0x80, 0x00, 0x00,
-					0x00, 0x00, 0x80, 0x80, 0x00, 0x00,
-				},
-				Cb: []uint8{
-					0x20, 0x20, 0x80, 0x80, 0x80, 0x80,
-					0x20, 0x20, 0x80, 0x80, 0x80, 0x80,
-					0x80, 0x80, 0x80, 0x80, 0xC0, 0xC0,
-					0x80, 0x80, 0x80, 0x80, 0xC0, 0xC0,
-					0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-					0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-				},
-				Cr: []uint8{
-					0xE0, 0xE0, 0x80, 0x80, 0x80, 0x80,
-					0xE0, 0xE0, 0x80, 0x80, 0x80, 0x80,
-					0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-					0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-					0x80, 0x80, 0x40, 0x40, 0x80, 0x80,
-					0x80, 0x80, 0x40, 0x40, 0x80, 0x80,
-				},
-				YStride: 6,
-				CStride: 6,
-				Rect:    image.Rect(0, 0, 6, 6),
-			},
-			width:  6,
-			height: 6,
-			expected: &image.YCbCr{
-				SubsampleRatio: image.YCbCrSubsampleRatio444,
-				Y: []uint8{
-					0xF0, 0xF0, 0x00, 0x00, 0x00, 0x00,
-					0xF0, 0xF0, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x40, 0x40,
-					0x00, 0x00, 0x00, 0x00, 0x40, 0x40,
-					0x00, 0x00, 0x80, 0x80, 0x00, 0x00,
-					0x00, 0x00, 0x80, 0x80, 0x00, 0x00,
-				},
-				Cb: []uint8{
-					0x20, 0x20, 0x80, 0x80, 0x80, 0x80,
-					0x20, 0x20, 0x80, 0x80, 0x80, 0x80,
-					0x80, 0x80, 0x80, 0x80, 0xC0, 0xC0,
-					0x80, 0x80, 0x80, 0x80, 0xC0, 0xC0,
-					0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-					0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-				},
-				Cr: []uint8{
-					0xE0, 0xE0, 0x80, 0x80, 0x80, 0x80,
-					0xE0, 0xE0, 0x80, 0x80, 0x80, 0x80,
-					0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-					0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-					0x80, 0x80, 0x40, 0x40, 0x80, 0x80,
-					0x80, 0x80, 0x40, 0x40, 0x80, 0x80,
-				},
-				YStride: 6,
-				CStride: 6,
-				Rect:    image.Rect(0, 0, 6, 6),
-			},
-		},
 		"I422": {
 			src: &image.YCbCr{
 				SubsampleRatio: image.YCbCrSubsampleRatio422,
@@ -245,82 +155,6 @@ func TestScale(t *testing.T) {
 				Rect:    image.Rect(0, 0, 4, 4),
 			},
 		},
-		"I422SameSize": {
-			src: &image.YCbCr{
-				SubsampleRatio: image.YCbCrSubsampleRatio422,
-				Y: []uint8{
-					0xF0, 0xF0, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00,
-					0xF0, 0xF0, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x80, 0x80, 0x30, 0x30, 0x00, 0x00,
-					0x00, 0x00, 0x80, 0x80, 0x30, 0x30, 0x00, 0x00,
-				},
-				Cb: []uint8{
-					0x20, 0x20, 0x80, 0x80,
-					0x20, 0x20, 0x80, 0x80,
-					0x80, 0x80, 0x80, 0x80,
-					0x80, 0x80, 0x80, 0x80,
-					0x80, 0x80, 0x80, 0x80,
-					0x80, 0x80, 0x80, 0x80,
-					0x80, 0x80, 0xE0, 0xE0,
-					0x80, 0x80, 0xE0, 0xE0,
-				},
-				Cr: []uint8{
-					0xE0, 0xE0, 0x80, 0x80,
-					0xE0, 0xE0, 0x80, 0x80,
-					0x80, 0x80, 0x80, 0x80,
-					0x80, 0x80, 0x80, 0x80,
-					0x80, 0x80, 0x80, 0x80,
-					0x80, 0x80, 0x80, 0x80,
-					0xF0, 0xF0, 0x40, 0x40,
-					0xF0, 0xF0, 0x40, 0x40,
-				},
-				YStride: 8,
-				CStride: 4,
-				Rect:    image.Rect(0, 0, 8, 8),
-			},
-			width:  8,
-			height: 8,
-			expected: &image.YCbCr{
-				SubsampleRatio: image.YCbCrSubsampleRatio422,
-				Y: []uint8{
-					0xF0, 0xF0, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00,
-					0xF0, 0xF0, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x80, 0x80, 0x30, 0x30, 0x00, 0x00,
-					0x00, 0x00, 0x80, 0x80, 0x30, 0x30, 0x00, 0x00,
-				},
-				Cb: []uint8{
-					0x20, 0x20, 0x80, 0x80,
-					0x20, 0x20, 0x80, 0x80,
-					0x80, 0x80, 0x80, 0x80,
-					0x80, 0x80, 0x80, 0x80,
-					0x80, 0x80, 0x80, 0x80,
-					0x80, 0x80, 0x80, 0x80,
-					0x80, 0x80, 0xE0, 0xE0,
-					0x80, 0x80, 0xE0, 0xE0,
-				},
-				Cr: []uint8{
-					0xE0, 0xE0, 0x80, 0x80,
-					0xE0, 0xE0, 0x80, 0x80,
-					0x80, 0x80, 0x80, 0x80,
-					0x80, 0x80, 0x80, 0x80,
-					0x80, 0x80, 0x80, 0x80,
-					0x80, 0x80, 0x80, 0x80,
-					0xF0, 0xF0, 0x40, 0x40,
-					0xF0, 0xF0, 0x40, 0x40,
-				},
-				YStride: 8,
-				CStride: 4,
-				Rect:    image.Rect(0, 0, 8, 8),
-			},
-		},
 		"I420": {
 			src: &image.YCbCr{
 				SubsampleRatio: image.YCbCrSubsampleRatio420,
@@ -373,118 +207,6 @@ func TestScale(t *testing.T) {
 				Rect:    image.Rect(0, 0, 4, 4),
 			},
 		},
-		"I420SameSize": {
-			src: &image.YCbCr{
-				SubsampleRatio: image.YCbCrSubsampleRatio420,
-				Y: []uint8{
-					0xF0, 0xF0, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00,
-					0xF0, 0xF0, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x80, 0x80, 0x30, 0x30, 0x00, 0x00,
-					0x00, 0x00, 0x80, 0x80, 0x30, 0x30, 0x00, 0x00,
-				},
-				Cb: []uint8{
-					0x20, 0x20, 0x80, 0x80,
-					0x20, 0x20, 0x80, 0x80,
-					0x80, 0x80, 0xE0, 0xE0,
-					0x80, 0x80, 0xE0, 0xE0,
-				},
-				Cr: []uint8{
-					0xE0, 0xE0, 0x80, 0x80,
-					0xE0, 0xE0, 0x80, 0x80,
-					0xF0, 0xF0, 0x40, 0x40,
-					0xF0, 0xF0, 0x40, 0x40,
-				},
-				YStride: 8,
-				CStride: 4,
-				Rect:    image.Rect(0, 0, 8, 8),
-			},
-			width:  8,
-			height: 8,
-			expected: &image.YCbCr{
-				SubsampleRatio: image.YCbCrSubsampleRatio420,
-				Y: []uint8{
-					0xF0, 0xF0, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00,
-					0xF0, 0xF0, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x80, 0x80, 0x30, 0x30, 0x00, 0x00,
-					0x00, 0x00, 0x80, 0x80, 0x30, 0x30, 0x00, 0x00,
-				},
-				Cb: []uint8{
-					0x20, 0x20, 0x80, 0x80,
-					0x20, 0x20, 0x80, 0x80,
-					0x80, 0x80, 0xE0, 0xE0,
-					0x80, 0x80, 0xE0, 0xE0,
-				},
-				Cr: []uint8{
-					0xE0, 0xE0, 0x80, 0x80,
-					0xE0, 0xE0, 0x80, 0x80,
-					0xF0, 0xF0, 0x40, 0x40,
-					0xF0, 0xF0, 0x40, 0x40,
-				},
-				YStride: 8,
-				CStride: 4,
-				Rect:    image.Rect(0, 0, 8, 8),
-			},
-		},
-		"I420NonSquareImage": {
-			src: &image.YCbCr{
-				SubsampleRatio: image.YCbCrSubsampleRatio420,
-				Y: []uint8{
-					0xF0, 0xF0, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xF0, 0x10, 0x10,
-					0xF0, 0xF0, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xF0, 0x10, 0x10,
-					0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0x00, 0x00, 0x40, 0x40, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0x00, 0x00, 0x40, 0x40, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x80, 0x80, 0x30, 0x30, 0x00, 0x00, 0x30, 0x30, 0x00, 0x00,
-					0x00, 0x00, 0x80, 0x80, 0x30, 0x30, 0x00, 0x00, 0x30, 0x30, 0x00, 0x00,
-				},
-				Cb: []uint8{
-					0x20, 0x20, 0x80, 0x80, 0x50, 0x50,
-					0x20, 0x20, 0x80, 0x80, 0x50, 0x50,
-					0x80, 0x80, 0xE0, 0xE0, 0x30, 0x30,
-					0x80, 0x80, 0xE0, 0xE0, 0x30, 0x30,
-				},
-				Cr: []uint8{
-					0xE0, 0xE0, 0x80, 0x80, 0xB0, 0xB0,
-					0xE0, 0xE0, 0x80, 0x80, 0xB0, 0xB0,
-					0xF0, 0xF0, 0x40, 0x40, 0xC0, 0xC0,
-					0xF0, 0xF0, 0x40, 0x40, 0xC0, 0xC0,
-				},
-				YStride: 12,
-				CStride: 6,
-				Rect:    image.Rect(0, 0, 12, 8),
-			},
-			width:  6,
-			height: 4,
-			expected: &image.YCbCr{
-				SubsampleRatio: image.YCbCrSubsampleRatio420,
-				Y: []uint8{
-					0xF0, 0x10, 0x00, 0x00, 0xF0, 0x10,
-					0x00, 0x00, 0x40, 0x00, 0x40, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x80, 0x30, 0x00, 0x30, 0x00,
-				},
-				Cb: []uint8{
-					0x20, 0x80, 0x50,
-					0x80, 0xE0, 0x30,
-				},
-				Cr: []uint8{
-					0xE0, 0x80, 0xB0,
-					0xF0, 0x40, 0xC0,
-				},
-				YStride: 6,
-				CStride: 3,
-				Rect:    image.Rect(0, 0, 6, 4),
-			},
-		},
 	}
 	for name, algo := range scalerTestAlgos {
 		algo := algo
@@ -525,100 +247,6 @@ func TestScale(t *testing.T) {
 	}
 }

-func TestScaleFastBoxSampling(t *testing.T) {
-	cases := map[string]struct {
-		src           image.Image
-		width, height int
-		expected      image.Image
-	}{
-		"I420NonSquareImage": {
-			src: &image.YCbCr{
-				SubsampleRatio: image.YCbCrSubsampleRatio420,
-				Y: []uint8{
-					0xF0, 0xF0, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xF0, 0x10, 0x10,
-					0xF0, 0xF0, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xF0, 0x10, 0x10,
-					0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0x00, 0x00, 0x40, 0x40, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0x00, 0x00, 0x40, 0x40, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x80, 0x80, 0x30, 0x30, 0x00, 0x00, 0x30, 0x30, 0x00, 0x00,
-					0x00, 0x00, 0x80, 0x80, 0x30, 0x30, 0x00, 0x00, 0x30, 0x30, 0x00, 0x00,
-				},
-				Cb: []uint8{
-					0x20, 0x20, 0x80, 0x80, 0x50, 0x50,
-					0x20, 0x20, 0x80, 0x80, 0x50, 0x50,
-					0x80, 0x80, 0xE0, 0xE0, 0x30, 0x30,
-					0x80, 0x80, 0xE0, 0xE0, 0x30, 0x30,
-				},
-				Cr: []uint8{
-					0xE0, 0xE0, 0x80, 0x80, 0xB0, 0xB0,
-					0xE0, 0xE0, 0x80, 0x80, 0xB0, 0xB0,
-					0xF0, 0xF0, 0x40, 0x40, 0xC0, 0xC0,
-					0xF0, 0xF0, 0x40, 0x40, 0xC0, 0xC0,
-				},
-				YStride: 12,
-				CStride: 6,
-				Rect:    image.Rect(0, 0, 12, 8),
-			},
-			width:  6,
-			height: 4,
-			expected: &image.YCbCr{
-				SubsampleRatio: image.YCbCrSubsampleRatio420,
-				Y: []uint8{
-					0xF0, 0x80, 0x08, 0x00, 0x78, 0x80,
-					0x08, 0x00, 0x20, 0x20, 0x20, 0x20,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x40, 0x58, 0x18, 0x18, 0x18,
-				},
-				Cb: []uint8{
-					0x20, 0x50, 0x68,
-					0x68, 0xB0, 0x88,
-				},
-				Cr: []uint8{
-					0xE0, 0xB0, 0x98,
-					0xD0, 0x98, 0x80,
-				},
-				YStride: 6,
-				CStride: 3,
-				Rect:    image.Rect(0, 0, 6, 4),
-			},
-		},
-	}
-
-	for name, c := range cases {
-		c := c
-		t.Run(name, func(t *testing.T) {
-			trans := Scale(c.width, c.height, ScalerFastBoxSampling)
-			r := trans(ReaderFunc(func() (image.Image, func(), error) {
-				return c.src, func() {}, nil
-			}))
-			for i := 0; i < 4; i++ {
-				out, _, err := r.Read()
-				if err != nil {
-					t.Fatalf("Unexpected error: %v", err)
-				}
-				if !reflect.DeepEqual(c.expected, out) {
-					t.Errorf("Expected output image:\n%v\ngot:\n%v\nrepeat: %d", c.expected, out, i)
-				}
-				// Destroy output contents
-				switch v := out.(type) {
-				case *image.RGBA:
-					v.Stride = 10
-					v.Pix = v.Pix[:1]
-					v.Rect.Max.X = 1
-				case *image.YCbCr:
-					v.YStride = 10
-					v.CStride = 100
-					v.Y = v.Y[:1]
-					v.Cb = v.Cb[:2]
-					v.Cr = v.Cr[:1]
-					v.Rect.Max.X = 1
-				}
-			}
-		})
-	}
-}
-
 func BenchmarkScale(b *testing.B) {
 	for name, algo := range scalerBenchAlgos {
 		algo := algo
--- a/pkg/io/video/scaler_cgo.c
+++ b/pkg/io/video/scaler_cgo.c
@@ -29,7 +29,7 @@ void fastBoxSampling(
    const int sw, const int sh, const int sstride,
    uint32_t* tmp)
 {
-  memset(tmp, 0, dw * dh * ch * sizeof(tmp[0]));
+  memset(tmp, 0, dw * dh * ch);

  for (int sy = 0; sy < sh; sy++)
  {
--- a/pkg/io/video/scaleycrcb.go
+++ b/pkg/io/video/scaleycrcb.go
@@ -30,18 +30,10 @@ func (p *rgbLikeYCbCr) At(x, y int) color.Color {
 }

 func (p *rgbLikeYCbCr) Set(x, y int, c color.Color) {
-	switch v := c.(type) {
-	case color.RGBA:
-		p.y.SetGray(x, y, color.Gray{v.R})
+	rgb := c.(*color.RGBA64)
+	p.y.SetGray(x, y, color.Gray{uint8(rgb.R / 0x100)})
 	if (image.Point{x, y}.In(p.cb.Rect)) {
-			p.cb.SetGray(x, y, color.Gray{v.G})
-			p.cr.SetGray(x, y, color.Gray{v.B})
-		}
-	case *color.RGBA64:
-		p.y.SetGray(x, y, color.Gray{uint8(v.R / 0x100)})
-		if (image.Point{x, y}.In(p.cb.Rect)) {
-			p.cb.SetGray(x, y, color.Gray{uint8(v.G / 0x100)})
-			p.cr.SetGray(x, y, color.Gray{uint8(v.B / 0x100)})
-		}
+		p.cb.SetGray(x, y, color.Gray{uint8(rgb.G / 0x100)})
+		p.cr.SetGray(x, y, color.Gray{uint8(rgb.B / 0x100)})
 	}
 }
--- a/pkg/prop/prop.go
+++ b/pkg/prop/prop.go
@@ -145,17 +145,13 @@ func (p *MediaConstraints) FitnessDistance(o Media) (float64, bool) {
 	cmps.add(p.Width, o.Width)
 	cmps.add(p.Height, o.Height)
 	cmps.add(p.FrameFormat, o.FrameFormat)
-	// The next line is comment out for now to not include framerate in the fitness function.
-	// As camera.Properties does not have access to the list of available framerate at the moment,
-	// no driver can be matched with a framerate constraint.
-	// Note this also affect screen caputre as screen.Properties does not fill in the Framerate field.
-	// cmps.add(p.FrameRate, o.FrameRate)
 	cmps.add(p.SampleRate, o.SampleRate)
 	cmps.add(p.Latency, o.Latency)
 	cmps.add(p.ChannelCount, o.ChannelCount)
 	cmps.add(p.IsBigEndian, o.IsBigEndian)
 	cmps.add(p.IsFloat, o.IsFloat)
 	cmps.add(p.IsInterleaved, o.IsInterleaved)
+
 	return cmps.fitnessDistance()
 }
Author	SHA1	Message	Date
Valentin Cocaud	896ab2d264	Allow to enable frame copy on a video track	2022-05-13 17:08:17 +02:00
Valentin Cocaud	280bc2de13	updating go.mod	2022-03-01 15:30:05 +01:00
Valentin Cocaud	58767d8fb4	🚧 replace by fork	2022-03-01 15:10:52 +01:00
Valentin Cocaud	662d1ac3a7	fix dependency errors	2022-03-01 15:01:08 +01:00
Valentin Cocaud	b1f7693135	remove idea files	2022-03-01 14:46:58 +01:00
Valentin Cocaud	d8ff6be0f3	Write test instead of type checking hack	2022-03-01 14:46:55 +01:00
Valentin Cocaud	41da6ab56a	Update pkg/codec/codec.go Co-authored-by: Atsushi Watanabe <atsushi.w@ieee.org>	2022-03-01 14:39:12 +01:00
Valentin Cocaud	419afd453a	Add an interface for easier customization of the EncoderController Making the ReadCloser an Controllable allows to uncouple the controller implementation from the encoder. This is not needed for the 2 codec controller already implemented (openh264 and vpx) but is more future proof in case it required for other codecs.	2022-03-01 14:39:12 +01:00
Valentin Cocaud	80be2a7a57	Force key frame on PLI	2022-03-01 14:39:12 +01:00