op.h

 
#ifndef MPIX_OPERATION_H
#define MPIX_OPERATION_H
 
#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
 
#include <mpix/formats.h>
#include <mpix/port.h>
#include <mpix/ring.h>
#include <mpix/utils.h>
 
struct mpix_base_op {
    struct mpix_base_op *next;
    const uint8_t *name;
    uint32_t format_src;
    uint32_t format_dst;
    uint16_t width;
    uint16_t height;
    uint16_t line_offset;
    uint16_t window_size;
    uint16_t threshold;
    bool is_heap;
    struct mpix_ring ring;
    void (*run)(struct mpix_base_op *op);
    uint32_t start_time_us;
    uint32_t total_time_us;
};
 
static inline size_t mpix_op_pitch(struct mpix_base_op *op)
{
    return op->width * mpix_bits_per_pixel(op->format_src) / BITS_PER_BYTE;
}
 
static inline void *mpix_op_by_format(void *list, uint32_t format_src, uint32_t format_dst)
{
    struct mpix_base_op **op_list = list;
 
    for (size_t i = 0; op_list[i] != NULL; i++) {
        if (op_list[i]->format_src == format_src &&
            op_list[i]->format_dst == format_dst) {
            return op_list[i];
        }
    }
    return NULL;
}
 
static inline uint8_t *mpix_op_get_input_bytes(struct mpix_base_op *op, size_t sz)
{
    uint8_t *data;
 
    data = mpix_ring_read(&op->ring, sz);
    assert(data != NULL /* Asked for more input bytes than available in the buffer */);
 
    return data;
}
 
static inline uint8_t *mpix_op_get_output_bytes(struct mpix_base_op *op, size_t sz)
{
    uint8_t *data;
 
    assert(op->next != NULL /* Missing  operation at the end, cannot get output buffer */);
 
    data = mpix_ring_write(&op->next->ring, sz);
    assert(data != NULL /* Asked for more output bytes than available in the buffer */);
 
    return data;
}
 
static inline uint8_t *mpix_op_peek_input_bytes(struct mpix_base_op *op, size_t sz)
{
    uint8_t *data;
 
    data = mpix_ring_peek(&op->ring, sz);
    assert(data != NULL /* Asked for more input bytes than peekable in the buffer */);
 
    return data;
}
 
static inline uint8_t *mpix_op_get_output_line(struct mpix_base_op *op)
{
    return mpix_op_get_output_bytes(op, mpix_op_pitch(op->next) * 1);
}
 
static inline const uint8_t *mpix_op_get_input_line(struct mpix_base_op *op)
{
    return mpix_op_get_input_bytes(op, mpix_op_pitch(op));
}
 
static inline uint8_t *mpix_op_peek_input_line(struct mpix_base_op *op)
{
    return mpix_op_peek_input_bytes(op, mpix_op_pitch(op->next) * 1);
}
 
static inline const uint8_t *mpix_op_get_all_input(struct mpix_base_op *op, size_t *sz)
{
    *sz = mpix_ring_tailroom(&op->ring);
    return mpix_ring_read(&op->ring, *sz);
}
 
static inline uint8_t *mpix_op_peek_output(struct mpix_base_op *op, size_t *sz)
{
    *sz = mpix_ring_tailroom(&op->ring);
    return op->ring.data + op->ring.head;
}
 
static inline void mpix_op_run(struct mpix_base_op *op)
{
    if (op != NULL && op->run != NULL) {
        /* Start the counter of the next operation */
        op->start_time_us = mpix_port_get_uptime_us();
 
        while (mpix_ring_total_used(&op->ring) >= op->threshold &&
               op->line_offset < op->height) {
            op->run(op);
        }
    }
}
 
static inline void mpix_op_done(struct mpix_base_op *op)
{
    uint32_t done_time_us = mpix_port_get_uptime_us();
 
    /* Flush the timestamp to the counter */
    op->total_time_us += (op->start_time_us == 0) ? (0) : (done_time_us - op->start_time_us);
 
    /* Run the next operation in the chain now that more data is available */
    mpix_op_run(op->next);
 
    /* Resuming to this operation, reset the time counter */
    op->start_time_us = mpix_port_get_uptime_us();
}
 
#endif