Depending on processor feature sets (such as NANO & SiMD & Crypto processor, Manageable in integer)
Wavelet Curve compress, Normally from left because we code Left to right & that is optimal for our hardware.
Can be numeric sequence Direction point 1=D D=1,2,3,4 2=Db = 1,2,3,4 | Displacement Dp = 1,2,3,4 Assuming Left To Right or curve displacement = Time
We must present a point between Px (pixel) & Pr (predict); In maths this would be a remainder,
We can draw a pixel in the Remainder Point; The Interpolation point (PI); When? When we upscale!,
We can use two principles, Px (actual pixel), Pr (Predicted Pixel), PI Pixel Interpolation!
We can guess with both Px & Pr on the content of PI & both Predict & Interpolate the pixel...
As additional Data; This does not worry us a lot.
(c)Rupert S
*
The principle is 2 Stage interpolation with splines:
We measure points between 2 values; for examples:
Px to Px (Side by side comparison interpolation)
Px to Pr, Pr1, Pr2,Pr3 (motion & predicted content), Upward Time & Circumference Interpolation.
Px to Px2,Px3 (Time increasing potential interpolation, Both static content & calculated motion)
We calculate Pixels between 2 values.
Time content comes in 2 categories:
Predicted location & Content:Pr
Static location: Px (recorded location per frame)
Finally comes Pi: Calculated locations & Content between Pixels
*
*
Interpolation & Extrapolation Policy : RS
We can conclude Interpolation & Tessellation have requirements : 2D & 3D Spline Interpolation & Extrapolation; Gaussian methods on linear surfaces,
We extrapolate the new; Such as blade edge; We can however layout a simple grid to our supposition edge & interpolate.
We do not need to extrapolate where we have planed to draw; With so much as a 3cm polygon with 4 Lines & 2 edges,
We can however draw a fractal blade; For example : HellSinger from Elric Melbone.
*
https://sg.indeed.com/career-advice/career-development/interpolation-vs-extrapolation
Massive Datasets https://www.aimsciences.org/DCDS/article/2023/43/3&4
Python Libraries Interpolation:
15 Types
https://help.scilab.org/section_64fa3f01fdb19353faf0c6806a64a533.html
Gaussian
https://gmd.copernicus.org/articles/16/1697/2023/
https://gmd.copernicus.org/articles/16/1697/2023/gmd-16-1697-2023.pdf
SiMD Gaussian Blending & Dithering - Better_Fixed_Point_Filtering_with_Averaging_Trees
https://andrew.adams.pub/Better_Fixed_Point_Filtering_with_Averaging_Trees.pdf
Vectorization of Kernel and Image Subsampling in FIR Image Filtering
http://bncss.org/index.php/bncss/article/viewFile/101/105
Implementation of a High-Quality Dolby Digital Decoder Using SiMD MMX™ Technology
https://smtnet.com/library/files/upload/dolby-intel.pdf
JIT Compile Displacement Micromap : Interpolation & Extrapolation Policy : RS
Compress its internal geometry representations into the compressed format Just in time,
Optimizing, Allocating & de-allocating in accord with Mesh Shaders & Cache availability.
VK_NV_displacement_micromap, which for Vulkan ray-tracing can help with added detail
No Comment https://www.phoronix.com/news/Vulkan-1.3.245-Released
VK_NV_displacement_micromap allows a displacement micromap structure to be attached to the geometry of the acceleration structure,
allow the application to compress its internal geometry representations into the compressed format ahead of time.
*
Our options for interpolation (don't forget Gaussian)
bsplin3val — 3d spline arbitrary derivative evaluation function
cshep2d — bidimensional cubic shepard (scattered) interpolation
eval_cshep2d — bidimensional cubic shepard interpolation evaluation
interp — cubic spline evaluation function
interp1 — 1D interpolation in nearest, linear or spline mode
interp2d — bicubic spline (2d) evaluation function
interp3d — 3d spline evaluation function
interpln — linear interpolation
linear_interpn — n dimensional linear interpolation
lsq_splin — weighted least squares cubic spline fitting
mesh2d — Triangulation of n points in the plane
smooth — smoothing by spline functions
splin — cubic spline interpolation
splin2d — bicubic spline gridded 2d interpolation
splin3d — spline gridded 3d interpolation
*
2D-3D Spline Interpolations with background complementary colour layer smooth blend
Right on the kindle paper white 2D Spline is good for a single layer, 3D Spline is good if you rasterize a shader behind the text and shade it: The method would not cost over 1% of processing power on a 2 core ARM 400Mhz, If the image is relatively static.
On full Colour HDR WebBrowser, The 3D Spline method makes sense with complementary colour blending...
On mostly static content; 3% of total page processing costs.
On mostly Static Text with mobile images a combination of 2D & 3D Spline; 7% to 15% of cost.
interp2d — bicubic spline (2d) evaluation function
interp3d — 3d spline evaluation function
Rupert S
*
High Definition Fusions : HDF Technique:RS (use scaling references example 4+3+2)
I know that many of you, Use a machine learning based technique that enhances the sharpness & realism when upscaling,
The Voxel technique is very complementary to this view; Taking a 4 Pixel cube & transforming the look with additional details.
High Definition Fusions : HDF Technique:RS (use scaling references example 4+3+2)
I would call this technique High Definition Fusions : HDF,
4 times the size frame buffer with upscaled into the buffer..
The Second thread then loads additional high resolution samples into the buffer with a blend.
You have to observe the Details such as edges & X-OR mask the data inplace..
Merge the data with the High definition component first load & the real details loaded ontop & then Gaussian Sharpen blended & smoothed.
Ideally the sample data is from the original source in high resolution.
FSR & VSR can potentially work this way.
Rupert S
Font Scaling : RS
A really good example is downscaling a 300Pt Font into a raster image for the 8pt Version..
But we Cache a buffer with all our letters & Gaussian blend from 32Pt to 8pt,
For that we need to MipMap a 300pt Vector font.
300pt Font Cache
Rasterize at 300pt
Mipmaps : 300pt, 200pt, 180pt, 96pt, 60pt, 30pt
Gausian blend & cache at our size.
(our size is probably 96pt or 120pt by screen & 600pt & 300pt by printer)
That looks 100's of times better!
Rupert S
*
Content Adaptation Dimming Zone Technology
Remember Content Adaptation Dimming Zone Technology,
works for smaller frame buffers,
With many devices 4GB RAM or more than simply enhance 8Bit & 10Bit per channel to 16Bit Smoothing Anti-Aliasing,
Micro buffering allows much more,
Single Zone [SS][SubS] Buffers could run you into 24MB Thread Buffer with an over head initial Buffer of 256MB Write Back Cached Rewritable Main buffer
(So you can align Micro Contrast HDR WCG)
RS
*
Role : sSSubSampra Micro frame buffers a cube
The LED Brightness curve; The logarithmic voltage & WATT brightness & colour variance,
In computer chips this is basically the Response in light to the voltage & WATT input..
By controlling this upto 16Bit Dithered dynamic voltage control; usually with a modulated resister/ Transistor..
Such as a POT Potentiated differentiator; We can control the LED by altering the voltage & input WATT,
We can also input a fluctuating digital signal, A signal that we dither,
We take the signal of a SiMD or CPU & process this though a DAC or directly modulate the signal from the pin,
By analysing the output; We can produce the result of a digital waveform with reduced voltage..
Max voltage = 16Bit * 11111>111:16b , Per connection & Usually we would Access the array to DIMM Post the LED,
We can also micro array the LED Access with groups of LED & Cable.
However we need a method of pre calculating the Digital Dither to 16Bit,
But due to the RAM requirements we may be posting 10Bit from the frame buffer!
This is where sSSubSampra Micro frame buffers a cube of LED & Gaussian Dithers the colour palette & composes the group of pixels to the LED Electronics.
We can quick post from SiMD if they can post DSC codec compressed bytes to the DSC Processor or display LED,
All we need are the shapes from DSC to be available for direct posting : DIM Post to screen,
Passthrough & recompression can be optimised; Using the DMA & Codec Compression Shapes, Both to Upscale & to speed up the display,
For all we need is that DSC has shapes we can refine in SiMD; From 8Bit to 32Bit SiMD Post is potentially possible by directly DMA Writing RAM to output.
Speed differences are a few ns for a few more circuits.
RS
*
Full Screen Sync, Single Cycle Multithreaded with [SS:SubS]Method : sSSubSampra
Line post is traditional on CRT (because of single ray & analogue line by line TV Aerial signal.
Digital Age & we TV Aerial receive per frame digital compressed MP4 & H263/4/5/6 & VP9..
We still send per frame content as a line in effect,
However the Single post method requires a complete Compressed Frame; In HDR WCG 12Bit this requires considerable RAM for frame buffer...
You can output a frame; GIMP Uses 500MB of RAM for a single editable image,
With single/Multiple line DIM Post a buffer of at least 32MB would be required..
Post processing constitutes at best 1/2/3/4/8 lines & memory retention!
Full Screen Sync, Single Cycle MultiThread with [SS:SubS]Method
The outlined method is my sSSubSampra : Dimming Zone : RS Method
Because the Screen is divided into Frame Buffer Cubes : SS & Sub Cubes SubS,
We Buffer the frame & Cache & Post in Cubes [SS] with Sub Cubes [SubS]; These Cubes constitute smaller work units with smaller RAM Requirements.
4K Image HDR 16Bit x RGBA = 500MB RAM Uncompressed.
(3840 X 2160) Image / 64 = 129,600px or (60px by 33.75px) * 64
(60px by 33.75px) = * 8
[SS] = 480px by 270px
[SubS] = 60px by 33.75px
As we can see the DIM Post DMA Write is only 8MB to 16MB with full post processing multi-threaded.
Rupert S
*sSSubSampra : Dimming Zone : RS
Technique for Dimming Zones on all LED class devices.
(MipMaps: As AMD has a great MipMap in FidelityFX!:
So what advantage in creating our own? Well, let's see!)
For a start our MipMap needs to be Higher than screen resolution!
So we need to Gaussian Sharpen to a larger frame buffer,
Then we need to Sub-Sample > Dimming Zones, So why ? So we can lighten & darken parts of the dimming zone!
We can shade [SS] Sample Zones & Sub Sample [SubS]
A screen usually needs a linear maximum & minimum light level; So we set these levels.
Divide SubS into a waveform filter with 3 to 8 levels of brightness
So what do we need? Read above!
Super Sample Frame buffer
[SS]
For [SS] = 4 [SubS] * N
Example Dimming Zone MipMap Zone
[SS][SS]
[SS][SS]
[SubS][SubS][SubS][SubS]
[SubS][SubS][SubS][SubS]
[SubS][SubS][SubS][SubS]
[SubS][SubS][SubS][SubS]
Rupert S
*
*Texture [SSSubN] : RS
sSSubTexture
[SS Texture with sub parts SubS]
N*[SubS Texture](Squares * N)
Refer to [SS/(N*SubS)]
Packed Layers for filtering
[6 * Same Size MipMap Sub Samples, Dark First with light layered ontop]
Very Light
Light
Lighter
Darker
Dark
Very Dark
*
We can treat each layer using ML, Logical Gaussian Filters & Sharpens & Colour Vividness & Clarity.
We DMA Move the frame by priority order, Dark first to very light.
DMA Move [Texture Block][ VL, L, Lr, Dr, D, VD] Very Dark Arrives first to paint; This gives us the advantage of only lightening the screen,
But we do need the entire block to be DMA Transferred in 1 to 3 Ticks; This has a flashing effect if we don't paint the order in a single frame; So we must.
Rupert S
*
MipMap Brightness Layer Example : sSSubTexture
The example of a code:
Fetch colour range (of the LED, For example Reds, Greens, Blues),
Grouped Colour range fetch saves on loads; But 16Bit SiMD can only load a small range; So a single colour,
If we have 16Bit per channel we only load one colour range per Pull,
So we perform 3; Red, Green, Blue; Or 4 Red, Green, Blue, Black..
When i say range i mean how light the pixel is; But we also blend the colour with the surrounding pixels subtly to anti alias,
To Anti Alias we need to bias colour reproduction to brightness closer to the next colour pixels,
High Dynamic contrast; Still link colour brightness so the pixels blend,
Higher contrast removes waveform similarity,
In lower contrast scenarios such as dark walls colours form in waves & therefore are smooth & able to be blended,
Lower contrast colour combinations lack distinct details & therefore are well compressed,
Sharp high contrast colours are edges & liable to be aliased; We therefore link the local pixels & subtly match colours,
For the example 7 shade MipMap we block groups of pixels into textures of different brightness; 7 levels,
We can blend & sharpen each level of brightness for optimal expression of vivid visual information.
RS
*
Content Adaptation Dimming Zone Technology can be on 2 fronts:
Display Signal Adaptive Content
The HDMI & DisplayPort signal can be Dynamically adjusted for Colour & Gamut range,
Example 8Bit/16Bit: RGB + Brightness & Darkness peak with on screen Profile & Gamma Curve
The Dimming Zone Technology can then adapt to Display Source DDC & Available ICC - Internet Consortium Colour Profile : HDR BT2020, BT2084, BT709
Directly on the display, In the firmware.
Personally I believe that with Both; We will get the best.
RS
By this technique, You are not obliged to have a Micro Dimming Array..
But obviously Quality of the screen will be higher with a Micro Dimming array!
The idea being that you can contrast and optimize all parts of a screen locally..
You will not need a Seperate Tile Micro Dimming Cable system.
You will significantly improve Micro Dimming with tiles to be honest & Improve it with sSSubSampra micro contrast & colour.
sSSubSampra significantly improves Multiprocessing of all image effects such as sharpening, Smoothing & filtering.
RS
*
Audio, Video & High precision Float ML
tensors & full onnx configuration : Upscaling : While we are not sure how much ML we need & at what precision,
We can be sure that 32Bit (per channel) Value RGBA (Multiple layer) requires at least 8Bit to 16Bit per channel final precision; So here is a list:
Required Value of output, Neural Network precision guide table: RS
Input
8Bit, 10Bit, 12Bit, 16Bit
Input network precision average bit retention (for RAM some error is allowed)
6Bit, 8Bit, 10Bit, 14Bit, 16Bit
Classifiers as we know can be,
Int 2Bit 4Bit, 8Bit, 16Bit, 32Bit
2 Bit is unlikely & 32Bit is for Dream Smooth 16Bit+ Precision output
Output Float (Mostly FP & F16b)
16Bit = { 8Bit, 10Bit, 12Bit }
24Bit, 32Bit, 64Bit = { 16Bit, 32Bit, 48Bit }
We can upscale : Audio, Video, Content & Polygons, We classify Quality by expectations & Quantify by percent %
Rupert S
*
Classifier Behaviour
F16 Compare Object Classifiers { Meta Data such as descriptors for the blind, Colour, Shape to Data }
F16:Int8 Compare Shape to table
Int8 Identify shape more subtly than Sharpen : Define Shape Sx
F16 Compare Database to X
F16 Int8 Compare edge alias to X
Int8 Define [Edge X & Compare] | Send to Edge Sharpen matrix
Set Shape to sharpen Elliptic
Sharpen or blur or Gaussian : Define Shape = Sh
Sharpen or blur or Gaussian or spline3d interpolation
*
Audio, Video & High precision Float ML : Colour palette example function
With the High precision Float ML method we are capable of offering our VESA configuration on a compatible colour profile,
sRGB, BT709, BT2020, BT2084 & widen the palette!
So why ? 2 reasons:
Gaussian blending & Bi Linear pixel blending; We require a very subtle palette to bled well,
But we do not have RAM & processors to burn!
Gaussian blending is efficient in the [SS][SubS] Pattern; Where we are dealing with patterns of Micro Dimming & adaptive contrast..
The smaller pattern & Brightness MipMap layers mean we can blend layers as we need,
Dark zones for example are noise hell; So we can Gaussian them; But we can sample details.
Brighter parts of the image are sure to have details that we need; But we handle each layer within the matrix..
Smaller RAM Loads & faster Writes, Better Caching per frame.
Rupert S
*
Quad pixel is part of the texture format.
As described in Example 2, 3, 4
The principle of how to work a Quad or Ten Pixels into a shape,
Easier to describe in texture format words; A shape is made in a SiMD to be sent to a group of pixels,
Grouping pixels means fewer DMA transfers; Because a SiMD is , 8bit, 16Bit, 32Bit, 64Bit..
Both the shape & the shade are described in a single request..
Alternatively the pixel is subject to higher precision colour (64Bit for example); Therefore we can smooth blend with subtle shading & colour,
We can also send 2 frames per send if we divide the SiMD into two lower precision parts..
But we have to receive the DMA as if we are interpreting 2 lower bit Integer/Floats; As of:
Integer floats with remainder theory :
https://science.n-helix.com/2021/02/multi-operation-maths.html
https://science.n-helix.com/2018/01/integer-floats-with-remainder-theory.html
Wavelet Formation, Write [Px2] from [Px1] overlap as required by motion:
Write round in sequence or Write [Px1] Centric Texture to [Px1]>[Px2]
[DMA]
[Px2][Px2][Px2]
[Px2][Px1][Px2]
[Px2][Px2][Px2]
Method 2 [DMA] write [Px1][Px2][Px3] & more as required & repeat (Example SiMD 64Bit = 4 x 16Bit)
[DMA][Px1][Px2][Px3]
[DMA][Px1][Px2][Px3]
Rupert S
*
Feature Properties Meta Data Tables & Tags DDC
LUT Colour Capacity Properties
Important Colour & LUT Caps for AMD
https://www.phoronix.com/news/AMD-Color-Steam-Deck
This reminds us to expose Caps both towards & from the OS & HDMI & DisplayPort,
Caps are exposed by the display in the form of LUT Table ICC such as BT2084, BT2020, BT709,
Obviously the GPU selects LUT Tables such as BT2084 from the HDMI port,
But what about exposure of colour caps from the GPU to the Display ?
The method of mutual lock for colour palette is a sure win,
Exposing additional capacities such as JIT Compiler, OpenCL, Vulkan & Direct Compute; Directly to the display!
But Why? Acceleration & Colour qualities; For example exposing the LUT Compiler from the GPU Directly to the display in DDM Immediate mode ALLM,
Colour & Cap exposure Would improve Colour rendering & additionally allow the displays to directly process LUT on the GPU,
Other features exposed through meta data could & would improve total rendering capacity & also utilise more of the DisplayPorts Capacity & bandwidth assignment.
RS
*Basic Upscaling Kernel Starter Set, Contains a basic set of what we hope to achieve.
Learning from proverb; Future Productions inc
OpenCL Kernel Builder
https://drive.google.com/file/d/1d_bWbZl9fAZXsLbN_jZdqSxdWzraLSIz/view?usp=share_link
Texture Encode Source
https://drive.google.com/file/d/1udWU4slmZkUGcagcJl1KwFWh5FJ5ScoN/view?usp=sharing
FSR Scaler
https://drive.google.com/file/d/1D27MOBYKVkKib1JzP_eFucp8RRrzAhd6/view?usp=share_link
Python ML Image denoisers, Very heavy denoising
https://github.com/cszn/BSRGAN
https://github.com/cszn/SCUNet
Crucial Codec source for projects
H266 https://drive.google.com/file/d/1Zt0CrP5p8ld7xnki1B9X4wz6Opyv13aH/view?usp=share_link
AV1 https://drive.google.com/file/d/179pqqS36v--t_BDjyhe1x_oVeYuxkWBw/view?usp=share_link
AAC https://drive.google.com/file/d/1YJy1yAdmEdjSMhtUjvTEU-y9HqJXFzzN/view?usp=share_link
LC3 https://drive.google.com/file/d/1_Gnf_PLN81YepCugmaRNofib7zLOHBNO/view?usp=share_link
DSC https://drive.google.com/file/d/1hbTFsFqzQTqLbhOaEwY-QkM4y3uAglXX/view?usp=share_link
X86Features-Emu
https://drive.google.com/file/d/1-bF_JH3ON3KsDOAsb8H3xy7I0W1nq6A2/view?usp=share_link
Upscale DL
https://is.gd/UpscaleWinDL
https://github.com/GPUOpen-LibrariesAndSDKs/RadeonML
https://github.com/GPUOpen-LibrariesAndSDKs/RadeonImageFilter
https://science.n-helix.com/2022/10/ml.html
*
https://github.com/ssube/diffusers/tree/feature/onnx-upscale
https://github.com/huggingface/diffusers
https://huggingface.co/ssube/stable-diffusion-x4-upscaler-onnx
https://huggingface.co/uwg/upscaler/tree/main
https://huggingface.co/nvmmonkey/optimal_upscale/tree/main
https://huggingface.co/gmp-dev/gmp-upscaler/tree/main/ESRGAN
Neural Engine
https://github.com/godly-devotion/MochiDiffusion
ML List & Services
https://huggingface.co/models?sort=downloads&search=upscale
https://huggingface.co/models
https://huggingface.co/pricing
*
Cubic SubSampling reference :
https://science.n-helix.com/2023/03/path-trace.html
https://science.n-helix.com/2023/02/smart-compression.html
In simple principle SubS uses Probable interaction PDF & Ray Boxing (Isolated Cell Cube = [SS]/[SubS]),
We only therefore only need to Predict Sample for likely cube overflows into adjacent boxes.
Resampling first; As we are resampling a ray box for probable intersection with our primary target (viewer),
Our motive is that the viewer is the only one to see the rays; Only Science project need to know all; But not always,
We need a sample that does interact with the Observer/Viewer!
So we simply need a bounding box with a direction mesh (multiply by X) that shows probable cause to interact!
We know that Viewer X is the only person seeing that interaction & So we know that if we point a triangle towards a light source; We directly interact with a subsample array,
We do not need them all!
PDF Similarity is used with the Ray Box to allocate work to probable cause; Located at User interaction AKA Observer/Viewer.
https://gpuopen.com/download/publications/Efficient_Spatial_Resampling_Using_the_PDF_Similarity.pdf
https://gpuopen.com/download/publications/I3D2023_SubspaceCulling_updated.pdf
*
ReSTIR Additions
Super Sampling is a technique of loading a texture; Upscaling the texture into a 4x to 8x larger size Cache,
Lacroze & Gaussian Blends combined with sharpening (Also available in AA & Gaussian Sharpening & 3D Spline Interpolation),
Added to sharpening & upscaling is Bi & Tri Linear Interpolation..
Interpolation requires that you estimate points between pixels in the texture or image..
The implementation of Method Example 1 to 4 including Mipmapping [SS][SubS] Frame buffer With Multithreading Micro Framebuffer Groups..
Allows Super-Sampling with Micro-Block Frame Recursive & Forward temporal Predict.
The simple storage of a frame in advance enables the technique,
Once a frame is in the buffer the next frame is managed with:
Included Recursive & Forward frame interpolation.
Sharpening & Image Gaussian Blend, Sharpen & Sub-Sampling Anti-Alias
In the Micro Frame Buffer & Texture Context & Full Frame colour, WCG & HDR Quality optimisations.
Interpolation methods include:
Bit Average differential at higher DPI
Gaussian blending at a higher DPI & Sharpening
Both methods have an additional Method: ML Identify & Classify ResNet
ML Identify ResNet; Identifies the Shape intention & Classifies the object by content.
We can guess that a nose is angular down for example or that a Square will stay square..
MetaData containing the identity of objects helps a lot in classifying.
ML_iRN Resolution Upscale & Texture Scaling
Texture 256 | Texture buffer Size * N +
{
3D Spline Interpolation,
Gaussian,
AntiAlias,
Lacroze
}
Texture Buffer Final | Size * N
(c)RS
*
2 Main approaches to Pixel Blend Dither : RS
Strict Clarity; Very low blend count
Alpha Blending; Under 20% colour differentiated Rendering; In fonts as an example the most recommended is 30%.
Strictly speaking a blend with more than 20% colour from a predicted location of adjacent pixels is garish,
Far too blatant & Directly inaccurate..
Potentially 3% to 7% pixel blending is quite subtle on 1024x768 & lower down to 1%,
I have a great deal of experience optimising such displays as Combined signaling on wave generators & Radio..
The Super-Sample Technique; 1% to 7% colour & Luminance & Contrast differential AntiAlias & Super Sampling + mild sharpening (light settings 1 of 10)
So yes blends of low potential difference make quite a lot of difference to perceptions of quality; Combined with subtle sharpening & AA.
Pixel blending & Sharpness in context of Average Pixel density
On a 1024x768 Display Pixel blending from a range of 1 Meter just works as a method,
At the pixel density of a 1024x768 display discolouring an adjacent pixel with a complementary colour for a predicted sub-location...
Alpha blending in effect works for real on an HD 1200x768 resolution or more quite well!
On a display with a lower pixel count than 1024x768 ; A pixel is either Yes or No.
96px or greater & 720pHD or greater & Pixel blending works well,
The higher the resolution is & the larger the distance is to view & the better this works as a method.
Rupert S
*
Pixel format optimization : Pix-AL
RGBA & BGRA, We obviously load the texture in 3 colour layers & therefore create an optimal map for dithering & smoothing purposes..
Natively aligning all colours to their corresponding pixel bit, Blue, Green, Red..
Perfect!
Examples:
RGB Offset R0.0, G0.5, B1
RGB
RGB
BGR Offset B0.0, G0.5, R1
BGR
BGR
In such examples the textures are aligned | Align = 0.0, 0.5, 1.0
Pixels consist of Arrays of colour; We align the colour Mipmap & thus sharpen the Texture & Video,
VESA DSC Codec particularly.
Remember CRT, Plasma & LED TV's Had alignment firmware automation with analogue..
We automate the prospect of aligning Pixels by Colour with Texture formats such as:
DSC, DXT5, ETC, ATC, PVRTC, ASTC & DTX Compression for display frames.
RS
*
Colour like the angels SESW16 & SESW32 for pixel (c)RS
When it comes to demosaicing you are obviously aware of pixel grid from raws; As a photographer myself; I of course researched such topics..
But you do need a grid to demosaic; In LED displays you think you need to demosaic; But in reality you are purely mixing light though the spatial anomaly called Air blur,
But you really need to demosaic the content of the pixel colour; As the primes red, Green, Blue & shades of them are present in each patch..
The principle is that when you call a pixel write; You are improving visual quality prioritizing each colour components priority for processing or patch processed:
*
To explain patched, see the process of screen write; To either write by line or groups of lines &or Patch Cube,
In that you group segments of the Screen DMA refresh into either line writes or Squares in order to make the write process faster during a frame flip.
*
mosaicing reasons, Filtering pure colours for less distorted purity,
Example common configurations of pixel:
RGB
GBR
when we post an LED group such as this we can use two methods:
single energy spike with wavelet
Colour Encoded energy Spike with wavelet
In principle single energy spike allows a full range 16Bit FP SiMD to post full range channel data with no overheads; But we need 3 R G B
In principle 3 RGB code colour DAC Spike needs to be 48Bit to be 12Bit/16Bit Sensor...
So in effect as demonstrated here in my thesis; Single Wave 16Bit spike SiMD x 3 but filtered per colour = 16Bit x 3 or 48Bit
Data wavelength reduction reduces the method to one simple thing? How to do a patch with 16Bit Energy representation only ?
single energy spike Wavelet : SESW16 SESW32 and so on.
Colour like the angels SESW16 & SESW32 for pixel (c)RS
Rupert S
*
Pixel Order: RGBA & BGRA & RGBA_f16 BGRA_f16 : RS Applies to Video & Audio rendering & Delivery
Single F16 pulse per R,G,B, F16x3
F16 Wave32 10xRGB & 2 Control Filter F16
F32 Wave32 10xRGB but 2x F16 & 2 Control Filter F32
Depending on how much control a device has over how to draw/light a pixel...
The Method of prioritising the colour that is mainly processed; May have advantages.
In principle with my display as the example; If we light all 3 colours at the same time per pixel then...
BGRA is the apparent order; So a DMA Paint with {BGR}A is going to sharpen the colours in that order & also filter them for noise in that order!
So what effect does this have ?
All 3 colours can be drawn in a single pass; Although we could separate 3 Passes per frame if we want...
3 mono passes with 3 Layers of pure F16 R G B; In my case B G R,
Alternatively 3 Pure F16 Energy Rating pulses for the 3 colours per pixel.
What is the relevance of F16 x 3 ? Can't we do an F16 Palette with all 3 colours ?
Well no because my display is 10Bit so the output would be 30Bit!
30Bit is a lot more complex to produce from SiMD; Probably use 32Bit SiMD..
So not a problem; But all 3 colours would process in 32Bit & that is more work.
F16 Wavelet pure energy levels x 3 R G B means at most 3 cycles or 3 SiMD Units,
Bear in mind that SiMD is anywhere from Wave32 32 Operations, Wave64 64 Operations..
We could use F16 Wave32 and colour 10 Red, 10 Green, 10 Blue per cycle
Single F16 pulse per R,G,B, F16x3
F16 Wave32 10xRGB & 2 Control Filter F16
F32 Wave32 10xRGB but 2x F16 & 2 Control Filter F32
So in essence F16 makes more sense depending on what hardware we use,Filtering each colour in pure F16 Identically & with the same Shader!More precise than F32 / 10Bit per R, G, B & 2 Control bits.
Rupert S
*
6 Way Matrix Spline Interlace Multiplier : RS
Matrix consist of a 6 way La{1:2:3} to Lb{1:2:3} Edge Detect & then interpolation with smoothing,
Edge detection promotes importance of aligned colour points,
This is called a 6 Way Matrix with Lma favouring La & Lmb favouring Lb; Lm is Lma 50/50 Lmb
Maths Basic
1920x1080 = 1918 lines | 6 way + 2 sides (up down) 3 Way & 1078 | 6 Way + 2 sides (Left Right) 3 Way
La{1:2:3}
Matrix Interpolation 1 to 3 lines
Lb{1:2:3}
La 1 2 3
Matrix Lma 1 2 3
Matrix Lm 1 2 3
Matrix Lmb 1 2 3
Lb 1 2 3
As you can see the matrix is 6 ways on real lines & multiplies or doubles lines,
Matrix can be 1+1/3, 1+2/3, 1+1, Etcetera.
This method is relatively simple & fast.
Rupert S
*
Identified material ML Shaped Edge Detect Gaussian sharpen & blend (c)Rupert S
When i say fast i mean, MOV {X,Y}stack | add {x + y} DIV {xy}/2 | MOV {stack} {FrameBuffer} :
I am afraid that this is about as FAST as Good upscaling under 2Ghz gets
