blaze-rs 1.0.3

A Rustified OpenCL Experience
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

use std::ptr::NonNull;
use image::ImageBuffer;
use crate::{prelude::*, memobj::{MapMutBox, MapMut, MapBox, AsMem, AsMutMem}, image::{IntoSlice, channel::RawPixel}, event::WaitList};

pub struct MapImage2D<P: RawPixel, D, C: Context> {
    event: RawEvent,
    mem: D,
    width: usize,
    height: usize,
    ptr: NonNull<P::Subpixel>,
    ctx: C
}

impl<P: RawPixel, D: AsMem, C: Context> MapImage2D<P, D, C> {
    #[inline(always)]
    pub unsafe fn new (ctx: C, src: D, slice: impl IntoSlice<2>, wait: impl Into<WaitList>) -> Result<Self> {
        let range = slice.into_slice([src.width()?, src.height()?]);
        let (ptr, _, _, event) = src.map_read_write(range, ctx.next_queue(), wait)?;
        let ptr : NonNull<P::Subpixel> = NonNull::new(ptr).unwrap();

        Ok(Self { 
            event, ptr, ctx,
            width: range.width(),
            height: range.height(),
            mem: src
        })
    }
}

impl<P: RawPixel, D: AsMem, C: Context> Event for MapImage2D<P, D, C> {
    type Output = ImageBuffer<P, MapBox<P::Subpixel, D, C>>;

    #[inline(always)]
    fn as_raw (&self) -> &RawEvent {
        &self.event
    }

    #[inline]
    fn consume (self, err: Option<Error>) -> Result<Self::Output> {
        if let Some(err) = err { return Err(err); }
        let len = self.height.checked_mul(self.width).and_then(|x| x.checked_mul(P::CHANNEL_COUNT as usize)).unwrap();

        let buf = unsafe {
            MapBox::from_raw_parts_in(self.mem, self.ptr.as_ptr(), len, self.ctx)
        };

        Ok(ImageBuffer::from_raw(u32::try_from(self.width).unwrap(), u32::try_from(self.height).unwrap(), buf).unwrap())
    }
}

pub struct MapMutImage2D<P: RawPixel, D: AsMutMem, C: Context> {
    event: RawEvent,
    mem: D,
    width: usize,
    height: usize,
    ptr: NonNull<P::Subpixel>,
    ctx: C
}

impl<P: RawPixel, D: AsMutMem, C: Context> MapMutImage2D<P, D, C> {
    #[inline(always)]
    pub unsafe fn new (ctx: C, src: D, slice: impl IntoSlice<2>, wait: impl Into<WaitList>) -> Result<Self> {
        let range = slice.into_slice([src.width()?, src.height()?]);
        let (ptr, _, _, event) = src.map_read_write(range, ctx.next_queue(), wait)?;
        let ptr : NonNull<P::Subpixel> = NonNull::new(ptr).unwrap();

        Ok(Self { 
            event, ptr, ctx,
            width: range.width(),
            height: range.height(),
            mem: src
        })
    }
}

impl<P: RawPixel, D: AsMutMem, C: Context> Event for MapMutImage2D<P, D, C> {
    type Output = ImageBuffer<P, MapMutBox<P::Subpixel, D, C>>;

    #[inline(always)]
    fn as_raw (&self) -> &RawEvent {
        &self.event
    }

    #[inline]
    fn consume (self, err: Option<Error>) -> Result<Self::Output> {
        if let Some(err) = err { return Err(err); }

        let buf;
        unsafe {
            let len = self.height.checked_mul(self.width).and_then(|x| x.checked_mul(P::CHANNEL_COUNT as usize)).unwrap();
            let ptr = core::slice::from_raw_parts_mut(self.ptr.as_ptr(), len);
            buf = MapMutBox::from_raw_in(ptr, MapMut::new_in(self.ctx, self.mem));
        }

        Ok(ImageBuffer::from_raw(u32::try_from(self.width).unwrap(), u32::try_from(self.height).unwrap(), buf).unwrap())
    }
}