packet2.h

/*
# _____     ___ ____     ___ ____
#  ____|   |    ____|   |        | |____|
# |     ___|   |____ ___|    ____| |    \    PS2DEV Open Source Project.
#-----------------------------------------------------------------------
# (c) 2020 h4570 Sandro Sobczyński <sandro.sobczynski@gmail.com>
# Licenced under Academic Free License version 2.0
# Review ps2sdk README & LICENSE files for further details.
*/
 
#ifndef __PACKET2_H__
#define __PACKET2_H__
 
#include <packet2_types.h>
 
#ifdef __cplusplus
extern "C"
{
#endif
 
    // ---
    // Packet2 management
    // ---
 
    packet2_t *packet2_create(u16 qwords, enum Packet2Type type, enum Packet2Mode mode, u8 tte);
 
    packet2_t *packet2_create_from(qword_t *base, qword_t *next, u16 qwords, enum Packet2Type type, enum Packet2Mode mode, u8 tte);
 
    void packet2_free(packet2_t *packet2);
 
    void packet2_reset(packet2_t *packet2, u8 clear_mem);
 
    static inline void packet2_update(packet2_t *packet2, qword_t *qw) { packet2->next = qw; }
 
    // ---
    // Basic add
    // ---
 
    static inline void packet2_advance_next(packet2_t *packet2, u32 i)
    {
        packet2->next = (qword_t *)((u8 *)packet2->next + i);
    }
 
    static inline void packet2_add_u128(packet2_t *packet2, const u128 val)
    {
        *((u128 *)packet2->next) = val;
        packet2_advance_next(packet2, sizeof(u128));
    }
 
    static inline void packet2_add_s64(packet2_t *packet2, const s64 val)
    {
        *((s64 *)packet2->next) = val;
        packet2_advance_next(packet2, sizeof(s64));
    }
 
    static inline void packet2_add_2x_s64(packet2_t *packet2, const s64 v1, const s64 v2)
    {
        packet2_add_s64(packet2, v1);
        packet2_add_s64(packet2, v2);
    }
 
    static inline void packet2_add_s128(packet2_t *packet2, const s128 val)
    {
        *((s128 *)packet2->next) = val;
        packet2_advance_next(packet2, sizeof(s128));
    }
 
    static inline void packet2_add_u64(packet2_t *packet2, const u64 val)
    {
        *((u64 *)packet2->next) = val;
        packet2_advance_next(packet2, sizeof(u64));
    }
 
    static inline void packet2_add_u32(packet2_t *packet2, const u32 val)
    {
        *((u32 *)packet2->next) = val;
        packet2_advance_next(packet2, sizeof(u32));
    }
 
    static inline void packet2_add_s32(packet2_t *packet2, const s32 val)
    {
        *((s32 *)packet2->next) = val;
        packet2_advance_next(packet2, sizeof(s32));
    }
 
    static inline void packet2_add_float(packet2_t *packet2, const float val)
    {
        *((float *)packet2->next) = val;
        packet2_advance_next(packet2, sizeof(float));
    }
 
    static inline void packet2_add_data(packet2_t *packet2, void *t_data, u32 t_size)
    {
        u32 i;
        for (i = 0; i < t_size; i++)
            packet2_add_u128(packet2, ((u128 *)t_data)[i]);
    }
 
    static inline void packet2_pad96(packet2_t *packet2, const u32 val)
    {
        while ((((u32)packet2->next + 4) & 0xf) != 0)
            packet2_add_u32(packet2, val);
    }
 
    static inline void packet2_pad128(packet2_t *packet2, const u32 val)
    {
        while (((u32)packet2->next & 0xf) != 0)
            packet2_add_u32(packet2, val);
    }
 
    // ---
    // Other
    // ---
 
    void packet2_print(packet2_t *packet2, u32 qw_count);
 
    void packet2_print_qw_count(packet2_t *packet2);
 
    void packet2_add(packet2_t *a, packet2_t *b);
 
    static inline u32 packet2_get_qw_count(packet2_t *packet2) { return ((u32)packet2->next - (u32)packet2->base) >> 4; }
 
    static inline u8 packet2_doesnt_have_even_number_of_quads(packet2_t *packet2) { return ((u32)packet2->next & 0xF) != 0; }
 
    static inline u8 packet2_is_dma_tag_opened(packet2_t *packet2) { return packet2->tag_opened_at != NULL; }
 
    static inline u8 packet2_is_vif_code_opened(packet2_t *packet2) { return packet2->vif_code_opened_at != NULL; }
 
#ifdef __cplusplus
}
#endif
 
#endif /* __PACKET2_H__ */