How would I optimize that piece of code using Unity?

Although a GPU solution is probably better and faster in your case, I don't have enough knowledge about this so I'll leave it to someone else to write that answer :)

Here I'll show you an example of how to edit textures using Unity's job system. This example is not tailored to your needs, but I think it should be enough of an example to help you along implement your functionality yourself should you choose not to use a GPU solution for any reason.

In the below example I made a Parallel job that swaps the red and green channels, this can however be altered to do whetever you want ofcourse.

public class Example : MonoBehaviour
{
    [SerializeField] private Texture2D _inputTexture; // Texture that we are reading, should have read/write enabled set to true and Compression set to None
    [SerializeField] private RawImage rawImage;
    private Texture2D _outputTexture;

    private NativeArray<Color32> inputArray;
    private NativeArray<Color32> outputArray;

    private NativeArray<byte> yourCustomArray; // Can be any (struct)type So byte, int, Color32, etc. all work

    private void Awake()
    {
        // Copy original texture to a new Texture2D for testing
        _outputTexture = new Texture2D(_inputTexture.width, _inputTexture.height, _inputTexture.format, _inputTexture.mipmapCount > 1);
        Graphics.CopyTexture(_inputTexture, _outputTexture);

        // Get the underlying NativeArrays which can be used by the jobs system
        inputArray = _inputTexture.GetRawTextureData<Color32>(); // Could use GetPixelData instead when working with mipmaps
        outputArray = _outputTexture.GetRawTextureData<Color32>();

        // Assign outputtexture to a rawimage
        rawImage.texture = _outputTexture;

        yourCustomArray = new NativeArray<byte>(inputArray.Length, Allocator.Persistent);
    }

    private void OnDestroy()
    {
        yourCustomArray.Dispose(); // We need to manually dispose our NativeArrays. The arrays retrieved from the Textures are disposed by the textures so we don't care here
    }

    private void Update()
    {
        var job = new ConvertJobParallel()
        {
            input = inputArray,
            output = outputArray,
            yourData = yourCustomArray
        };

        JobHandle handle1 = job.Schedule(inputArray.Length, 100); // The 100 here is a magic number, it is basically a number that says how many items (Color32 in our example) are handled in one 'batch' where each batch can run async on any thread
        JobHandle.ScheduleBatchedJobs(); // Start running (all) our previously scheduled jobs
        handle1.Complete(); // Wait on the main thread fot this job to complete
        _outputTexture.Apply(); // Copy changes to gpu
    }

    [BurstCompile] // <-- For this you need to add the Burst package using the Unity package manager, this attribute is completely optional but it improves performance by a lot (like 10 times faster)
    public struct ConvertJobParallel : IJobParallelFor
    {
        [ReadOnly] public NativeArray<Color32> input;
        public NativeArray<Color32> output;
        public NativeArray<byte> yourData;

        // This gets called by the job system. index ranges between 0 and the 'arrayLength' specified in the first parameter of Schedule()
        public void Execute(int index)
        {
            // This is simply a demo test, it swaps the red and green channels, here you put your logic
            Color32 inputColor = input[index];
            output[index] = new Color32(inputColor.g, inputColor.r, inputColor.b, inputColor.a);
        }
    }
}

So in your case you can change the yourCustomArray and yourData to whatever you want, you can add more NativeArrays if you want to in a similar way, you can also add variables to your job that contain only one value (like public uint data_delta; for example). Note however that you should consider any variable that is not a NativeArray as readonly in your job.

EDIT Forgot to mention this, in this test I immediatly call Complete() after scheduling the job. If possible you should always make sure that you do other things in between scheduling and awaiting for the job to complete to fully utilize multithreading. So for instance, schedule at the start of the frame and complete at the end of the frame or in a later frame depending on your needs.

Edit2 Based on comments and the updated code you posted. The Execute(int index) method of the ConvertJobParallel will be run multithreaded by Unity. When you call job.Schedule(inputArray.Length, 100); you are telling Unity you want to call Execute inputArray.Length times in batches of 100. Unity will then handle that these batches of 100 are distributed among different threads. This also means that altering the variables of ConvertJobParallel inside the Execute job is problematic. The only thing which you can write to and persists after the job are the contents of the NativeArray's you pass along. That layer++ you do won't work as you expect it, as it won't increment the actual layer outside the job. So these parts should be moved outside the job (Actually, anything inside your original code outside this loop for (int i = 0; i < layer_size; i++) should be moved outside the job

You should also try to cache the NativeArrays of the Textures you are using if possible. These NativeArrays contain the actual bytes of this Texture on CPU side. Meaning if you change any value of that nativeArray, you change the value of the Texture itself and vice-versa. But it won't be copied to the GPU untill you call texture.Apply(). Note that the url you posted of how you retrieve the texture, it uses a cached texture if possible, so if it returns a cached texture whose NativeArray you retrieved in the past, you don't need to update your cached NativeArray, your NativeArray should contain the correct bytes already.

So my change to you current posted code would be something like this: The Job itself:

[BurstCompile] // <-- For this you need to add the Burst package using the Unity package manager, this attribute is completely optional but it improves performance by a lot (like 10 times faster)
public struct ConvertJobParallel : IJobParallelFor
{
    [ReadOnly] public NativeArray<byte> input;
    public NativeArray<byte> output;
    [NativeDisableParallelForRestriction] public NativeArray<byte> history;
    public NativeArray<byte> average;

    // These should always be considered read only, as writing to them is problematic. Execute gets called async on many threads.
    // So editing these values inside execute does not yield the wanted results
    public int _history_scan_depth;
    public int _layer_size;
    public int _data_delta;
    public int _layer;

    // This gets called by the job system. index ranges between 0 and the 'arrayLength' specified in the first parameter of Schedule()
    public void Execute(int index)
    {
        byte b = input[index];
        uint avrg = 0;
        for (int k = 0; k < _history_scan_depth; k++)
        {
            avrg += history[k * _layer_size + index];
        }
        average[index] = (byte)(avrg / _history_scan_depth);

        if (math.abs(b - average[index]) < _data_delta)
        {
            output[index] = b;
        }

        history[_layer * _layer_size + index] = b;
    }
}

Scheduling the job:

if (history_scan_depth > history_capacity)
    history_scan_depth = history_capacity;

var job = new ConvertJobParallel()
{
    input = inputArray,
    output = outputArray,
    history = historyArray,
    average = averageArray,
    _history_scan_depth = history_scan_depth,
    _layer_size = layer_size,
    _data_delta = data_delta,
    _layer = layer
};

layer++;
if (layer >= history_scan_depth)
    layer = 0;

JobHandle handle1 = job.Schedule(inputArray.Length, 100); // The 100 here is a magic number, it is basically a number that says how many items (Color32 in our example) are handled in one 'batch' where each batch can run async on any thread
JobHandle.ScheduleBatchedJobs(); // Start running (all) our previously scheduled jobs
handle1.Complete(); // Wait on the main thread fot this job to complete

_outputTexture.Apply(); // Copy changes to gpu

In this example, I'm not sure what _data_delta should be, in your comment to the original post I read 500, but since you are comparing it to a byte which max value is 250 I tested this at 50. _outputTexture.LoadRawTextureData(outputArray); You shouldn't really call this, as you just want to be Editing the NativeArray of that texture directly, rather then copying another one to it every frame, I do this in my original post by creating a new Texture2D with correct width, height and format and then use GetRawTextureData to get the outputArray that is directly mapped to the Texture2D.