Monday, February 27, 2023


Similar Wavelet Conversion with minimal reprocessing : Smart Access : RS

(repeated encoding cost reduction) i know you are a coder, you could help ffmpeg & avx on the FX8320E, Likewise consoles face same issue with FFMPEG & Codecs & likewise with media acceleration by non repetition of encoding

Similar Wavelet Conversion with minimal reprocessing : Smart Access : RS

Printing Technology 'When you "Tie" the Knot' : 
We want those Hand drawn Donald duck, Micky & Daffy in true line drawn splendour, 
But hand drawing 8K is hell, 
Remaster printing technology : For all monitors, TV's & Operating systems : DTS, Dolby : Functioning wave conversion

Smart-De-Compression : repeated encoding cost reduction : (c)Rupert S

Wavelet Classifiers

Compressed Data, GZip, BZip, LZH

Primarily our goal is to Originate Encode in a form that is Compatable with the hardware chain,

For example in the case of HDD > CPU > GPU the right Texture & Number formats, Often 16Bit or 32Bit float & Texture,

However with Video we have to expand the frame wavelets into Compatable Texture formats!

We convert the Video Wavelet in Smart Access to the closest Texture format wavelet; Or directly play the video! But suppose we are using Bink Video? We directly convert & keep wavelets that are the same in the new texture,

We therefore select a texture format like NV12 or ETC2; One that has the most Similar Wavelets & can therefore reduce Conversion Cost of the frame by as much as 100% (If all wavelets are the same)!

We know Wavelet types & Colour depth of all texture classes; So we will select one with a good range,
In most cases we play MP4+ Wavelets; So we can Use a JPG type texture; So all the compression wavelets remain minimally processed.

A single Frame + previous B Frame; Into a single texture of the same Wavelet Compression Classification,

The result is minimal processing CPU Cycles.


Overall reducing costs of higher resolution resolving; As available in 264 > 265 > 266/VVC & other Media Encoders : Rupert S

You can see that, formats such as 265 & 264 are related, Obviously at a higher resolution in the case of 265!
But in many Wavelet transform cases we can minimise the Processing cost, We do however need to know like Google's ML Voice Encoder; The ones we do not need to change (minimum benefaction)

My chief challenge of Wavelet thought is a multiple frame picture of an eye (WebP for example),
The resolution is 640x480 & We know in most probabilities that; The Eye was transformed to wavelet in HD,

So we have a wavelet curve; Black centre & A surrounding Iris!
We need to expand that wavelet so we will suppose that the higher precision version of the wavelet will add details?

We must explore how the wavelet transforms a Higher Resolution form into a lower resolution form,
We can therefore in theory use the same wavelet at higher resolving depth?

We might be able to convert a lower resolving wavelet in 12Bit into the 16Bit version & have a better understanding of the higher quality version!

We can therefore most probably reuse the wavelet; Transforming from 264 to 265 & upscale & compress more,

Overall reducing costs of higher resolution resolving; As available in 264 > 265 > 266/VVC

#WaveletProve Both that the wavelet is infinite & that; The Breton
shirt wavelet has a pattern represented in 12Bit but liberating into
the profound on 16Bit, 32Bit & more!

(To understand wavelet context, in textile & theory & of course Audio & Video)

Can we prove the wavelet of a Breton shirt for infinity, like mauri
My augment being that we can upscale that Breton shirt! & prove it's
17th century values...
Both that the wavelet is infinite & that; The Breton shirt wavelet has
a pattern represented in 12Bit but liberating into the profound on
16Bit, 32Bit & more!

Example Wavelets to prove upscaling is possible

Rupert S

Wavelet Upscaling : JPG / Video / Games

Example 2 Voxel to High Quality : RS

The Story : HP : V-FX Wavelet Voxel Transforms : V-FX-WVT (c)RS (Harry Potter + More)

I was wondering what to add to Wavelet transforms; Well i was thinking about Harry Potter,
Full body FX are Half Resolution; In Fact they are Depth of Field Voxels,

For people who don't know Voxel is when you make a Cube of the right shade from a picture & set it at the right depth!

For those criticizing such an act as lazy; You would have to understand how fast technology has developed!

Some characters Fly at a very low resolution & Others like Harry Potter & Melfoy Don't!

You would have to realise that V-FX is based on the ability of the person to be in the role... They perform ;-)


V-FX Wavelet Voxel Transforms : V-FX-WVT (c)RS (Harry Potter + More)


The Wavelet is the JPG Pixel Group of a single Group of pixels at the same size as the composing Voxels of the V-FX

A Voxel is a Cube of Pixels set in 3D

When it comes to Transforms; This piece is called:

Transforms for classic movies : How you upscale VFX : RS

Firstly the VOXEL (Simple Wavelet Cube) needs to be compared to a fully dressed original character,

Then you need to map the correct features into The voxel cube space; After you Average Anti-Alias & Upscale the Cube Map (Original V-FX + Original Video Frame Person)

You then need to map an effective Wavelet of the Original V-FX with a modifier Layer of transparent Wavelet (The Photo in High Detail, This is also a Wavelet Series)



Example 3 : Lessons to learn : Wavelets : Upscaling (c)RS

Now about the Voxel 4x4 cube map 'Transform wavelet' is a simple JPG Wavelet
(if used properly compressed & older games did not because processors where not very fast (33Mhz)

High resolution 'Transform Wavelet' (Overlayed) is a full to higher resolution JPG Wavelet
In Upscaling we need to get from one to the other,
Transform Wavelet from Voxel Wavelet,

Sample Scaling:But supposing we have samples of like minded objects?
We can use Machine Learning to imprint a pattern!

But great looking as this is, not perfect as seen in Example 3 About Example 2 : HP!

Wavelet permutation:

Resolve the wavelet to full precision, Workable; But we need to know the result is correct!ML Can help; But that is very subjective..

Mostly this works.

Identity Follow through:

Machine Learning that identifies the subject matter [Samsung & LG TV's 2020+ Example]

So what do we do? We Add the lot! haha

Rupert S


Example 4 : Lessons to learn : Wavelets : Upscaling (c)RS

2 Pattern Matrix Wavelet (c)RS

Wavelets are patterns; With Colour infilling (why not a wavelet itself!

Well wavelets come in forms (Gif)8Bit, 10Bit, 12Bit, 16Bit(JPG)

We can advance the precision by using a higher Precision (16Bit, 24Bit, 32Bit); But we need to save storage space!

First thing is to use bF16 & bF32; This keeps the majority of the data from being sub pixels.

Second thing is to make maximum use of multiple Precisions, Mix F16 with F32..
Google Lyra Codec demonstrates this in Machine Learning.

Third : Keep Precision within margins, Small Textures do well in 8Bit Matrix Wavelets...
But 16Bit Colour Precision & 16Bit Precision both look good in HD High Quality HDR WCG

(Usable as encryption archetype): Chaos:A:B:T:Pi:Arc:Sin:Tan
Very usable /dev/rnd Random Ring : TRNG : GPU : CPU : Asics : Using Chaos Wavelet

{Wavelet:Colour Point) A to B as expression of Pi
{Wavelet:Colour Point} A to B as expression of Arc, Sin, Tan

[2PMW File Array]
[Header : Easy Identifier : Basic Name]
{Header Packed Wavelet Groups] [1 Image Wavelet : Colour Shading Wavelet 2, 4, 8 Group]

[Image Array lines]
|Packed Groups of] : [ Image Wavelet 1 : Colour Shading Wavelet Associations, 1 to 8]
[Packed Groups of] : [ Image Wavelet 1 : Colour Shading Wavelet Associations, 1 to 8]
[Packed Groups of] : [ Image Wavelet 1 : Colour Shading Wavelet Associations, 1 to 8]



Audio/Video/Image Format : Packing Vectors (c)RS

Several choices of Interpolation; With low computation cost to higher Cycle Performance..
Depending on processor feature sets (such as NANO & SiMD & Crypto processor, Manageable in integer)

Vector Wavelet Examples : Math object

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

Distance N from source edge, Curve:Sin/Tan
(Example) D=1 Db=3 Dp1=2 Dp2=3 | Curve = Tan3+Db2

Logarithmic Pack,
Integer Comparator : N+N2+N3=N+1+2+3 | Sequence

Example 5 : Predict Scaling : SiMD/AVX.SSE3 : (c)RS

SiMD Interpolation grids & Predict with Raytracing & General SiMD
Reference Grid

With the Interception/Processing of Predict Statements in Frames of Video & Audio; Using a simple Grid:

Pr = Predict (motion) Px = Pixel t1:2:3 time period


Basically you can see the pixels move in frame Px1 & Predicted in Pr2 & Pr3,
Raytracing SiMD predict future motion though maths; We can use the SiMD to,

Both predict & interpolate/Upscale from 8bit, 10Bit, 12Bit, 14Bit to 16Bit values or rather wavelets,
Because Raytracing SiMD are high precision maths; They prove advantageous if we have them; SiMD/AVX.SSE3

Interpolation : Prxi Pxri : {PxPrPi} Theory : RS

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.
Massive Datasets

Python Libraries Interpolation:

15 Types


SiMD Gaussian Blending & Dithering - Better_Fixed_Point_Filtering_with_Averaging_Trees

Vectorization of Kernel and Image Subsampling in FIR Image Filtering

Super temporal Resolution Imaging of Membrane Potential via Stroboscopic Microscopy

Implementation of a High-Quality Dolby Digital Decoder Using SiMD MMX™ Technology

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
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)



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.



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
For [SS] = 4 [SubS] * N

Example Dimming Zone MipMap Zone


Rupert S


*Texture [SSSubN] : RS


[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
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.



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.


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.



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

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 :

Wavelet Formation, Write [Px2] from [Px1] overlap as required by motion:
Write round in sequence or Write [Px1] Centric Texture to [Px1]>[Px2]


Method 2 [DMA] write [Px1][Px2][Px3] & more as required & repeat (Example SiMD 64Bit = 4 x 16Bit)


Rupert S


Feature Properties Meta Data Tables & Tags DDC

LUT Colour Capacity Properties

Important Colour & LUT Caps for AMD

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.



Upscaling & FMA

For when {(A+B/2)} = C Expressions
For when {U, X, Y, Z} = N Expressions


Basic Upscaling Kernel Starter Set, Contains a basic set of what we hope to achieve.

Learning from proverb; Future Productions inc

OpenCL Kernel Builder

Texture Encode Source

FSR Scaler

Python ML Image denoisers, Very heavy denoising

Crucial Codec source for projects


Upscale DL


Neural Engine

ML List & Services

Cubic SubSampling reference :

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.


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,

Texture Buffer Final | Size * N



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..



RGB Offset R0.0, G0.5, B1

BGR Offset B0.0, G0.5, R1

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.



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:

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

Matrix Interpolation 1 to 3 lines

               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

Suitable for WebASM & WebGPU

Basic thought Upscaling ASM : RS

MOV {X,Y:X2,Y2:Xn,Yn}FrameBuffer1
var upscale = add {x + y} DIV {xy}/2 | MOV {XY + upscale}FrameBufferTemp
MOV {FrameBufferTemp+FrameBuffer1} LOC {FrameBuffer2(FrameBufferTemp+1 FrameBuffer1+0)}

Var table1 = input
Var table2 = interpolate
Var table3 = output

Var xy = 2/(X+Y)
For var table1 = {X1, Y1 : Xn, Yn} Then Var table2 = xy{X1, Y1 : Xn, Yn};
Then table3 = ({table1X + table2X+1} + {table1Y + table2Y+1})

the tunisian & Ukraine low resolution cam footage has too low a frame rate for eye or hand motion

Interpolation and has lines, probably less than 25fps, the clear minded need to double the frame rate

So strangely enough, Double frame rate by copying predict frame & upscale the in-between frame before; Upscaling the previous frame & future frame with frame to frame interpolation & sideways & line to line inter-predicted interpolation..

Inter-predict interpolation sounds like a CPU heavy configuration; However the use of Gaussian (heavy or light precision) & spline interpolation, both temporal & resizing...

Because applied on top of or under the Identified material ML Shaped Edge Detect Gaussian sharpen & blend,

not too CPU heavy on 2Ghz+ AVX2 / SiMD / NANO


Example use of upscaling of non uniform size

One way to use this is if you want to change the Vertical/Horizontal plane so that it is more dense,

With the MicroLED and MicroLensing formula; you may require something more than a long LED Pixel..
So the 6 Way Matrix is ideal when you simply want to resize the image in one or two directions...

While the screen is still stated as 16:9 for formula; You might have square LED Pixels!
But you still would prefer not to use a lot of CPU for it; Mind you if you operate per line HD is still 1080 operations per frame.

But if you output 16 Lines per send & overlap the last 2 lines in the next write cycle:

77.14 14Line Writes + 2 lines of overlap for 16 Line write.
AKA 77 dimming zones vertical; With as many modifications as you want on line write.

This stops banding, printers show the effect of overlap printing but screens are the inverse; In printing we print slightly less in the banding area.



MathML & scaling

Additional scaling example is the recently introduced MathML & scaling available in chrome source

In reference to scaling in displays & fonts we have two additional sources of internal resolution enhancement,
At least in terms of web browsers and Use Interfaces UI

With the two manageable systems we could potentially do quite a lot without increasing bandwidth costs..

Scaling down slightly higher resolution fonts & images & videos; To stunning details!

To be frank MathML appears not to be machine learning optimised; However in CSS markup we could use MathML..
To dynamically scale a webpage to DPI & Size & where preferred to a lower scaling & thus improved readability!

If we can take scaling as automatic input & read the results internally we could do quite a bit with it,
However MathML is quite good for things like price range conversion : £ Euro & $ & yen

we can use MathML quite flexibly; But is it a calculator ? It should be,
So we shall see!


MathML is not only useful for displaying mathematical content, but also for performing calculations and conversions..

This means that mathematical content can be displayed at any size and resolution without pixelation or distortion.

Another example of scaling in displays and fonts is the use of internal resolution enhancement techniques, such as subpixel rendering and antialiasing,

These techniques improve the appearance and readability of text and images by smoothing out jagged edges and enhancing contrast,

For instance, MathML can be used to convert between different currency units, such as pounds, euros, dollars, and yen.

MathML can also handle complex calculations involving fractions, roots, powers, trigonometry, and more.



TOPCloud Scaled Flexible WebASM & WebGPU & MathML!

Quite flexible for use on Monitors & TV's; Light processor load on simple tasks & offloadable such as TOPCloud!

You may be thinking Offloading is impracticable because that requires one of two things:

JIT Compiler Dongle..
USB device such as Firestick or GPU & CPU (With OpenCL Compat)

Server! so internet & service provision!
Impossible? No; WebAdvert supported TV's need both!
So why not HPC TOPCloud? could make a HOT TV a lot cooler & Eco friendly with Server repeating tasks:

Quality Service
Service availability

TOPCloud Offload Logic:

In terms of WebASM & WebGPU & MathML; TOPCloud provides sufficient advantages to be considered a core utility..

While Offloading repeating content such as Siteload core stack (Server) & Localising configuration such as Webpage size & DPI & Dynamic font arrangements that require thought.

In terms of Offloaded function & Efficient system load for large configurations..

Especially efficient configurations such as TPU, Coral, GPU work & Cloud CPU that have large optimised stacks & installed drivers.



3D Matrix Web Codecs

Are presented as being JIT Compiler re-encoded when required; Frequently WebASM, WebGPU Code, JS...
Audio, Video, Sensation, Code Runtimes.

Web Codecs for devices are a modern concept & are available for common websites such as news & music,
devices such as Alexa Echo & Google Dot & Bluetooth Devices?

Media players & BT devices particularly suffer from small Storage potential!
So Web Codecs downloaded to the device from a source; Such as a smart phone or computer..
Are a clear-minded solution!

JIT Compiler

3D Matrix Tables in FMA, Mul & ADD code to be automatically recompiled locally when required!
Directed to a common API, Direct Compute, WebGPU, WebASM, Jit Compiler OpenCL

Many Operations can be done from unique device specific optimisation; Examples:

API, DirectX & OpenCL & Vulkan & WebGPU & WebASM
Texture & Audio Shaders.
Digital Streaming

Bluetooth NANO SiMD & API
Digital TV in H266, VP9 & AV1,

Locally compiled accelerators should be respected first; Such as the output & input 3D Matrix & CPU & GPU Acceleration engine..

Code can include Matrix converters into common output format such as WebP & Textures & BC, DXT Compression presentation; Vulkan, OpenCL & DirectX & Texture & Audio Shaders.

Java, JS & WebASM are examples with operator mechanisms & JIT Compiler optimisation..
Minimising storage requirements for good compatibility while maximising performance.




Scaling; We can classify by colour or creativity. (c)RS

If you use TOPCloud, you can share between different displays in the TOP's Sense..
but mostly you would need cloud presence,

Mostly this would be about making the most out of TOP heavy Business GPU & personal ones in your computer or consoles.

But sharing common tasks such as scaling movies by type or by identifying a single movie to upscale...

Now you might be asking what we would be doing there?
Well a single movie uses the same materials in our ML; We can analyse the class & optimise the scaling by class..

For those familiar with games & FSR; We familiarise our code with a single game!
By doing this we improve our product and can therefore classify by:

Type, FPS for example & RTS

We can classify by colour or creativity...

We do not simply have to roll the dice on General Scaling, We can use classifiers:

Frame Rate
Colour & Composure

Rupert S

PoCL Source & Code


Vector Instructions
Vector Encoding : VECSR


Specification for Open Compute & Gaussian Interpolation & JIT Compile
Displacement Micromap : Interpolation & Extrapolation Policy : RS

Concept of JIT OpenCL

Demosaicking DoFP images using edge compensation method based on correlation

FPGA 'Xilinx Virtex-II' HPC application Multiple-Applications & Image-Net & Matrix-Multiplication - H-SIMD machine _ configurable parallel computing for data-intensive HPC

A SIMD architecture for hard real-time systems

Multiple Parallel SiMD Single Cycle - A Multi‐instruction Streams Extension Mechanism for SIMD Processor

Ideal for 4Bit Int4 XBox & Int8 GPU
PULP-NN: accelerating quantized neural networks on parallel ultra-low-power RISC-V processors - Bus-width 8-bit, 4-bit, 2-bit and 1-bit

Useful for Presentation with AA, work Rendering/Upscaling Shaders

OpenCL, Hardline minimal code kernels,
(Code AA Processing yourself) Useful for work Rendering/Upscaling Shaders

Shaders; Useful for texture cache & presentation
CL Shaders 2
V1.6 Shaders,

Gaussian Interpolation, Useful for upscaling & AA

Texture Encode Source

Image Optimisation Training Datasets:(Download Folder to directory)

Upscaling Training Sample Set:
Upscaling Training Sample Set, Eco Samples:
Space Training Samples Set


Python ML Image denoisers, Very heavy denoising

To Compress using CPU/GPU: MS-OpenCL

PoCL Source & Code


The Smart-access

[Innate Compression, Decompression, QoS To Optimise the routing, Task Management To optimise the process] : Task Managed Transfer : DMA:PIO : Transparent Task Sharing Protocols

The following is the initiation of the Smart-access Age

Vector Encoding : VECSR

QoS To Optimise the routing:Task Management To optimise the process

FPGA 'Xilinx Virtex-II' HPC application Multiple-Applications & Image-Net & Matrix-Multiplication - H-SIMD machine _ configurable parallel computing for data-intensive HPC

A SIMD architecture for hard real-time systems

Ideal for 4Bit Int4 XBox & Int8 GPU
PULP-NN: accelerating quantized neural networks on parallel ultra-low-power RISC-V processors - Bus-width 8-bit, 4-bit, 2-bit and 1-bit

Transversal processing availability : Transparent Task Sharing Protocols

Machine Learning

Innate Compression, Decompression

Strobe Line by Line Run Length Compression DVB, NTSC, VESA :RS Approved

Examples of compression

Gain the diplomacy of a Scaler Scailing Cause : News on the Gaining
Diplomacy World Wide

Gain the diplomacy of a Scaler Scailing Cause : News on the Gaining
Diplomacy World Wide 2

Sound Open Firmware : Supported by Intel, AMD, Realtek, MediaTek, DTS, Dolby, RS & so-on
S.O.F provides an open source audio DSP firmware and SDK for audio or signal processing on modern DSPs


Good stuff for all networks nation wide, the software is certificate signed & verified
When it comes to pure security, We are grateful
TLS Optimised
Ethernet Security

These are the addresses directly of some good ones; DNS & NTP & PTP 2600:c05:3010:50:47::1 2607:fca8:b000:1::3 2607:fca8:b000:1::4 2a06:98c1:54::c12b


Andro-linux libs : x86 & ARM : Learn

Python Deep Learning:

AndroLinuxML :
Linux :
Windows :

good stuff for all networks nation wide, the software is certificate signed & verified
When it comes to pure security, We are grateful
TLS Optimised
Ethernet Security

No comments: