WIP: Floating point pixel manipulation

firmware/lm32/Makefile

@@ -18,6 +18,7 @@ OBJECTS=isr.o \
         processor.o \
         hdmi_in0.o \
         hdmi_in1.o \
+        mix.o\
         hdmi_out0.o \
         hdmi_out1.o \
         pattern.o \

firmware/lm32/ci.c

@@ -8,6 +8,7 @@
 #include <generated/sdram_phy.h>
 #include <time.h>
 
+#include "mix.h"
 #include "config.h"
 #include "fx2.h"
 #include "hdmi_in0.h"
@@ -61,6 +62,16 @@ static void help_output0(void)
 	puts("  output0 on                     - enable output0");
 	puts("  output0 off                    - disable output0");
 }
+
+static void help_output0_mult_factor(void)
+{
+	puts("output0 multfactor (alias: 'm0')");
+	puts("  set0                           - set mult at input0");
+	puts("  set1                           - set mult at input1");
+	puts("  val0                           - mask values at mixer input0");
+	puts("  val1                           - mask values at mixer input1");
+}
+
 #endif
 
 #ifdef CSR_HDMI_OUT1_BASE
@@ -83,6 +94,14 @@ static void help_encoder(void)
 }
 #endif
 
+static void help_floatmult(void)
+{
+	puts("floatmult commands (alias: 'f')");
+	puts("  floatmult in1 val             - set floatmult in1 equal val");
+	puts("  floatmult in2 val             - set floatmult in2 equal val");
+	puts("  floatmult out                 - print floatmult out");
+}
+
 static void help_debug(void)
 {
     puts("debug commands (alias 'd')");
@@ -118,6 +137,8 @@ static void help(void)
 #ifdef CSR_HDMI_OUT0_BASE
 	help_output0();
 	puts("");
+	help_output0_mult_factor();
+	puts("");
 #endif
 #ifdef CSR_HDMI_OUT1_BASE
 	help_output1();
@@ -127,6 +148,8 @@ static void help(void)
 	help_encoder();
 	puts("");
 #endif
+	help_floatmult();
+	puts("");
 	help_debug();
 }
 
@@ -495,7 +518,6 @@ static char *get_token(char **str)
 	return d;
 }
 
-
 void ci_prompt(void)
 {
 	printf("HDMI2USB>");
@@ -637,6 +659,36 @@ void ci_service(void)
 			help_encoder();
 	}
 #endif
+
+	else if((strcmp(token, "mix_mult") == 0) || (strcmp(token, "m0") == 0)) {
+		token = get_token(&str);
+
+		if (strcmp(token, "set0") == 0){
+			hdmi_out0_driver_mult_factor0_write(atoi(get_token(&str)));
+			printf("HDMI_OUT0 mult factor = %d\n", hdmi_out0_driver_mult_factor0_read());
+			printf("HDMI_OUT1 mult factor = %d\n", hdmi_out0_driver_mult_factor1_read());
+		}
+
+		else if (strcmp(token, "set1") == 0){
+			hdmi_out0_driver_mult_factor1_write(atoi(get_token(&str)));			
+			printf("HDMI_OUT0 mult factor = %d\n", hdmi_out0_driver_mult_factor0_read());
+			printf("HDMI_OUT1 mult factor = %d\n", hdmi_out0_driver_mult_factor1_read());
+		}
+
+		else if(strcmp(token, "val0") == 0){
+			printf("HDMI_OUT0 mult factor = %d\n", hdmi_out0_driver_mult_factor0_read());
+		}	
+
+		else if(strcmp(token, "val1") == 0){
+			printf("HDMI_OUT1 mult factor = %d\n", hdmi_out0_driver_mult_factor1_read());
+		}	
+
+		else {
+			help_output0_mult_factor();
+		}
+
+	}
+
 	else if((strcmp(token, "status") == 0) || (strcmp(token, "s") == 0)) {
 		token = get_token(&str);
 		if(strcmp(token, "on") == 0)
@@ -757,4 +809,5 @@ void ci_service(void)
 	}
 
 	ci_prompt();
-}
+
+}

firmware/lm32/main.c

@@ -18,6 +18,7 @@
 #include "hdmi_out1.h"
 #include "fx2.h"
 #include "version.h"
+#include "mix.h"
 
 int main(void)
 {
@@ -62,6 +63,7 @@ int main(void)
 #endif
 	ci_prompt();
 	while(1) {
+		mult_service();
 		processor_service();
 		ci_service();
 

firmware/lm32/mix.c

@@ -0,0 +1,58 @@
+#include <generated/csr.h>
+#include <generated/mem.h>
+#include <hw/flags.h>
+#include <system.h>
+#include <time.h>
+#include <stdbool.h>
+
+#include "processor.h"
+#include "hdmi_in0.h"
+#include "hdmi_in1.h"
+#include "pattern.h"
+#include "mix.h"
+
+static const unsigned int mult_bar[20] = {
+	0 	  ,
+	10854 ,
+	11878 ,
+	12493 ,
+	12902 ,
+	13312 ,
+	13517 ,
+	13722 ,
+	13926 ,
+	14131 ,
+	14336 ,
+	14438 ,
+	14541 ,
+	14643 ,
+	14746 ,
+	14848 ,
+	14950 ,
+	15053 ,
+	15155 ,
+	15258 
+
+
+};
+
+#define FILL_RATE 20 			// In Hertz, double the standard frame rate
+
+void mult_service(void)
+{
+	static int last_event;
+	static int counter;
+
+//	if (mix_status) {
+		if(elapsed(&last_event, identifier_frequency_read()/FILL_RATE)) {
+			counter = counter+1;
+			if(counter >= (FILL_RATE-1)) {
+				counter = 0;
+			}
+		}
+//	}
+
+	hdmi_out0_driver_mult_factor0_write(mult_bar[counter]);
+	hdmi_out0_driver_mult_factor1_write(mult_bar[20-1-counter]);
+
+}

firmware/lm32/mix.h

@@ -0,0 +1,12 @@
+
+#ifndef __MIX_H
+#define __MIX_H
+
+#include <stdbool.h>
+
+static bool mix_status;
+static const unsigned int mult_bar[20];
+
+void mult_service(void);
+
+#endif

firmware/lm32/processor.c

@@ -508,15 +508,21 @@ void processor_update(void)
 #ifdef CSR_HDMI_OUT0_BASE
 	/*  hdmi_out0 */
 #ifdef CSR_HDMI_IN0_BASE
-	if(processor_hdmi_out0_source == VIDEO_IN_HDMI_IN0)
+	if(processor_hdmi_out0_source == VIDEO_IN_HDMI_IN0) {
 		hdmi_out0_fi_base0_write(hdmi_in0_framebuffer_base(hdmi_in0_fb_index));
+		hdmi_out0_fi_base1_write(pattern_framebuffer_base());
+	}
 #endif
 #ifdef CSR_HDMI_IN1_BASE
-	if(processor_hdmi_out0_source == VIDEO_IN_HDMI_IN1)
+	if(processor_hdmi_out0_source == VIDEO_IN_HDMI_IN1) {
 		hdmi_out0_fi_base0_write(hdmi_in1_framebuffer_base(hdmi_in1_fb_index));
+		hdmi_out0_fi_base1_write(hdmi_in1_framebuffer_base(hdmi_in1_fb_index));
+	}
 #endif
-	if(processor_hdmi_out0_source == VIDEO_IN_PATTERN)
+	if(processor_hdmi_out0_source == VIDEO_IN_PATTERN) {
 		hdmi_out0_fi_base0_write(pattern_framebuffer_base());
+		hdmi_out0_fi_base1_write(pattern_framebuffer_base());
+	}
 #endif
 
 #ifdef CSR_HDMI_OUT1_BASE
@@ -529,8 +535,8 @@ void processor_update(void)
 	if(processor_hdmi_out1_source == VIDEO_IN_HDMI_IN1)
 		hdmi_out1_fi_base0_write(hdmi_in1_framebuffer_base(hdmi_in1_fb_index));
 #endif
-	if(processor_hdmi_out1_source == VIDEO_IN_PATTERN)
-		hdmi_out1_fi_base0_write(pattern_framebuffer_base());
+//	if(processor_hdmi_out1_source == VIDEO_IN_PATTERN)
+//		hdmi_out1_fi_base0_write(pattern_framebuffer_base());
 #endif
 
 #ifdef ENCODER_BASE
@@ -545,8 +551,8 @@ void processor_update(void)
 		encoder_reader_base_write((hdmi_in1_framebuffer_base(hdmi_in1_fb_index)));
 	}
 #endif
-	if(processor_encoder_source == VIDEO_IN_PATTERN)
-		encoder_reader_base_write(pattern_framebuffer_base());
+//	if(processor_encoder_source == VIDEO_IN_PATTERN)
+//		encoder_reader_base_write(pattern_framebuffer_base());
 #endif
 }
 

gateware/csc/common.py

@@ -16,13 +16,21 @@ def saturate(i, o, minimum, maximum):
 def coef(value, cw=None):
     return int(value * 2**cw) if cw is not None else value
 
-
 def rgb_layout(dw):
     return [("r", dw), ("g", dw), ("b", dw)]
 
+def rgb16f_layout(dw):
+    return [("rf", dw), ("gf", dw), ("bf", dw)]
 
 def ycbcr444_layout(dw):
     return [("y", dw), ("cb", dw), ("cr", dw)]
 
 def ycbcr422_layout(dw):
     return [("y", dw), ("cb_cr", dw)]
+
+def pix_layout(dw):
+    return [("pix", dw)]
+
+def pixf_layout(dw):
+    return [("pixf", dw)]
+

gateware/csc/rgb16f2rgb.py

@@ -0,0 +1,73 @@
+# rgb16f2rgb
+
+from migen.fhdl.std import *
+from migen.genlib.record import *
+from migen.flow.actor import *
+
+from gateware.csc.common import *
+
+@DecorateModule(InsertCE)
+class PIXF2PIXDatapath(Module):
+    """ 
+    Converts a 16 bit half precision floating point 
+    number defined in the range [0-1] to 8 bit unsigned 
+    int represented by a pixel in the range [0-255]
+    """
+    latency = 2
+    def __init__(self, pixf_w, pix_w):
+        self.sink = sink = Record(pixf_layout(pixf_w))
+        self.source = source = Record(pix_layout(pix_w))
+
+        # # #
+
+        # delay pixf signals
+        pixf_delayed = [sink]
+        for i in range(self.latency):
+            pixf_n = Record(pixf_layout(pixf_w))
+            self.sync += getattr(pixf_n, "pixf").eq(getattr(pixf_delayed[-1], "pixf"))
+            pixf_delayed.append(pixf_n)
+
+
+        # Hardware implementation:
+
+        # Stage 1
+        # Unpack frac and exp components
+        # Correct exponent offset for shifting later
+        frac = Signal(11)
+        exp = Signal(5)
+        exp_offset = Signal((6,True))
+
+        self.sync += [
+
+            exp_offset.eq(15 - sink.pixf[10:15] -1),    
+            frac[:10].eq(sink.pixf[:10]),
+            frac[10].eq(1),
+        ]
+
+        # Stage 2
+        # Right shift frac by exp_offset
+        # Most significant 8 bits of frac assigned to uint8 pix 
+        self.sync += [
+        If(exp_offset<0,
+            source.pix.eq(255)
+        ).Else(
+            source.pix.eq((frac >> exp_offset)[3:]),
+        )
+        ]
+
+
+class RGB16f2RGB(PipelinedActor, Module):
+    def __init__(self, rgb16f_w=16, rgb_w=8, coef_w=8):
+        self.sink = sink = Sink(EndpointDescription(rgb16f_layout(rgb16f_w), packetized=True))
+        self.source = source = Source(EndpointDescription(rgb_layout(rgb_w), packetized=True))
+
+        # # #
+
+        for name in ["r", "g", "b"]:
+            self.submodules.datapath = PIXF2PIXDatapath(rgb16f_w, rgb_w)
+            PipelinedActor.__init__(self, self.datapath.latency)
+            self.comb += self.datapath.ce.eq(self.pipe_ce)
+            self.comb += getattr(self.datapath.sink, "pixf").eq(getattr(sink, name +"f"))
+            self.comb += getattr(source, name).eq(getattr(self.datapath.source, "pix"))
+
+        self.latency = self.datapath.latency