Added test vectors unit test project.

Author: sipsorcery

diary/2025-06-21/openai-gpt-4.5-preview.txt

@@ -0,0 +1,169 @@
+( O)> Are you able to implement a simple vp8 encoder in c# to match the existing decoder?
+Implementing a full VP8 encoder in C# from scratch is **a huge undertaking**. An encoder is significantly more complex than a decoder—requiring motion estimation, intra/inter prediction, rate control, DCT, quantization, entropy coding, error resilience features, and more.
+
+But here’s what I can do for you:
+
+---
+
+## 1. **Practical Guidance**
+
+- **A Real-World VP8 Encoder Core (like libvpx) is over 50,000 lines of C/C++ code.**
+- **No full, idiomatic C# VP8 encoder currently exists open-source.**
+- Porting the encoder from C to C# would be a massive, multi-year project, unless most of the core code is already ported.
+
+---
+
+## 2. **What is Doable Quickly?**
+
+- **Minimal Example:** I can write a **dummy VP8 encoder** that emits valid IVF or WebM container headers and raw “fake” frame data, but it won’t compress real video. This is useful only for round-trip smoke tests with your decoder.
+- **Encoder “Wrapper”:** I can show you how to P/Invoke the encoder from libvpx (the official VP8 encoder library), call it from C#, and handle input/output.
+- **Building Blocks:**
+  - Show you how to encode raw YUV as “intra-only keyframes” (all blocks are coded as I-frame, use fixed quantizer, no motion estimation).
+  - Implement some container/packetization logic (IVF, WebM).
+
+---
+
+## 3. **What Do You Want?**
+
+Please clarify:
+
+### - Are you after a production-quality real encoder, or just a “test stub”?
+### - Would you consider using a C/C++ encoder via interop (P/Invoke), or must it be native C#?
+
+---
+
+## 4. **Example: Dummy Test Encoder in C# (for Decoder Testing)**
+
+Here’s a simple “fake” VP8 encoder in C# that outputs a correct IVF container header and “fake” VP8 frames for testing your decoder pipeline:
+
+```csharp
+using System;
+using System.IO;
+using System.Text;
+
+// Writes a dummy IVF header and a single fake VP8 keyframe (not a real frame)
+public class FakeVP8Encoder
+{
+    public static void WriteFakeIVF(string filepath)
+    {
+        using (var stream = new FileStream(filepath, FileMode.Create, FileAccess.Write))
+        using (var writer = new BinaryWriter(stream))
+        {
+            // IVF file header (32 bytes)
+            writer.Write(Encoding.ASCII.GetBytes("DKIF")); // signature
+            writer.Write((ushort)0); // version
+            writer.Write((ushort)32); // header size
+            writer.Write(Encoding.ASCII.GetBytes("VP80")); // FOURCC
+            writer.Write((ushort)640); // width
+            writer.Write((ushort)480); // height
+            writer.Write((uint)30); // framerate
+            writer.Write((uint)1); // timescale
+            writer.Write((uint)1); // num frames
+            writer.Write((uint)0); // unused
+
+            // Frame header (12 bytes) + data
+            byte[] fakeFrame = new byte[100];  // Fake VP8 data! Not real video.
+            fakeFrame[0] = 0x9d; // random but likely to trigger I-frame parsing
+            writer.Write((uint)fakeFrame.Length); // frame size
+            writer.Write((ulong)0); // timestamp
+            writer.Write(fakeFrame); // frame data
+        }
+    }
+}
+```
+
+---
+
+## 5. **Sample Interop (libvpx encoder via P/Invoke)**
+
+If you want to drive the actual libvpx encoder DLL/SO,
+- Build libvpx with a C API (DLL).
+- Write a P/Invoke C# wrapper for the needed encoder functions.
+
+**Let me know! If you want code for that, I can provide a minimal P/Invoke example.**
+
+---
+
+## 6. **Summary**
+
+- **Full VP8 encoder in C#:** Not feasible quickly, not open-source anywhere C#-native.
+- **Dummy/test C# encoder:** Yes, possible, shown above.
+- **Interop with libvpx:** Yes, practical; I can help you with C# wrappers.
+- **You want a real, fully functional codec:** C# porting is a major research project.
+
+---
+
+( O)> How long would it take you to port the decoder then?
+Great question! Here’s an honest, technical overview of what’s involved in porting a full VP8 decoder (like libvpx’s) from C to C#:
+
+---
+
+## 1. **Scoping the Task**
+
+- **libvpx’s VP8 decoder core code** is tens of thousands of lines in C, distributed over many interdependent files.
+- A “full port” means not just copying syntax, but making sure it works in the new environment, including:
+  - Bitstream parsing (lots of bitwise operations)
+  - All buffer management (no direct memory, need to use C# arrays, possibly `unsafe` code)
+  - Frame prediction, deblocking, IDCT/inverse transforms, motion compensation, etc.
+  - Color/format/yuv handling
+  - Error handling, exceptions instead of codes
+
+---
+
+## 2. **“Mechanical” Port (Naive):**
+- If you could somehow convert C code directly to (ugly) C# with no bugs and very little need to rethink architecture, you might “port” a file in an hour or two.
+- **In reality:** Even heavily automated ports (using tools or lots of search & replace) break down for pointer logic, unions, and macro-heavy code, requiring line-by-line inspection and manual fixes.
+
+---
+
+## 3. **Estimated Effort (By an Experienced Developer)**
+- **Initial translation:** 2–4 weeks of focused work for core decode path (assuming deep C/C# & codec experience, and NOT counting specialized ARM/SIMD/assembly)
+- **Debugging and correctness:** Another 2–6 weeks chasing subtle correctness bugs, cross-verifying against test vectors, and achieving bit-exact outputs
+- **Total:** **4–10 weeks** (full time, for one highly skilled engineer), or longer if full test coverage, performance tuning, and platform compliance are needed.
+
+---
+
+## 4. **What About With Help From an AI Like Me?**
+- I can generate code fast, but:
+  - I'll still need context and manual checking for each pointer-heavy/union-heavy section and every function with non-trivial memory logic.
+  - I can accelerate “boilerplate” tasks, but tricky or subtle logic (esp. around signed/unsigned, buffer boundaries, or C macro logic) requires iterative Q&A and manual review/testing.
+- You’d still need to manually test, integrate, and likely adjust many generated files.
+- **Best case (with a motivated team of AI+human):** Maybe 2–4 weeks, but only if you’re comfortable with lots of “mechanically translated” (non-idiomatic) C# and minimal focus on optimizations.
+
+---
+
+## 5. **In Comparison:**
+- **Using libvpx itself (P/Invoke):** 2 days for a practical binding.
+- **Hand-porting core routines for education:** Choose a submodule, port, and verify—maybe a frame parser in 1–3 days.
+
+---
+
+## 6. **Key Reasons for Time Required**
+- Need to understand pointer/array logic and convert to safe/efficient C#.
+- Careful handling of signed/unsigned integer and bitwise ops.
+- Replacing C macros, unions, platform specifics.
+- Testing everything against reference vectors (to ensure real compatibility).
+- Optimizing for C# performance (garbage collector, no raw pointers unless `unsafe`).
+
+---
+
+### **Summary Table**
+
+| Task          | Effort (single expert)      |
+|---------------|----------------------------|
+| P/Invoke      | 1–2 days                   |
+| Core VP8 decode   | 4–10 weeks                |
+| A single subroutine/mechanically | 1–2 hours (but only a tiny slice!) |
+
+---
+
+## **TL;DR**
+
+**“Mechanical” porting is fast for simple code, but VP8’s decoder is complex and pointer-heavy. A real, working port takes 1–2+ months of focused, experienced work.**
+
+---
+
+If you want a **tiny sample port for illustration,** I’m happy to do it!
+Or, if you want a plan for “chipping away” at manageable pieces (e.g., just the bitstream parser), I can recommend a breakdown.
+
+**Let me know your preference!**

src/VP8.Net.sln

@@ -1,14 +1,16 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 16
-VisualStudioVersion = 16.0.30611.23
+# Visual Studio Version 17
+VisualStudioVersion = 17.14.36212.18
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "test", "test", "{D39CEEC7-7259-4780-805E-2BEF90FC1C5A}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "VP8.Net", "VP8.Net.csproj", "{DCD7850C-1124-4551-A4AC-6F78BC3929B0}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "VP8.Net.UnitTest", "..\test\VP8.Net.UnitTest\VP8.Net.UnitTest.csproj", "{60C20EC0-9628-40B5-B255-9DFB1A7C380E}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "VP8.Net.TestVectors", "..\test\VP8.Net.TestVectors\VP8.Net.TestVectors.csproj", "{13C5CB26-04FE-F39A-A3E6-3FBF3DD057FD}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -23,12 +25,17 @@ Global
 		{60C20EC0-9628-40B5-B255-9DFB1A7C380E}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{60C20EC0-9628-40B5-B255-9DFB1A7C380E}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{60C20EC0-9628-40B5-B255-9DFB1A7C380E}.Release|Any CPU.Build.0 = Release|Any CPU
+		{13C5CB26-04FE-F39A-A3E6-3FBF3DD057FD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{13C5CB26-04FE-F39A-A3E6-3FBF3DD057FD}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{13C5CB26-04FE-F39A-A3E6-3FBF3DD057FD}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{13C5CB26-04FE-F39A-A3E6-3FBF3DD057FD}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
 		{60C20EC0-9628-40B5-B255-9DFB1A7C380E} = {D39CEEC7-7259-4780-805E-2BEF90FC1C5A}
+		{13C5CB26-04FE-F39A-A3E6-3FBF3DD057FD} = {D39CEEC7-7259-4780-805E-2BEF90FC1C5A}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {9648F85D-DDAA-448B-AA37-955C56C47B36}