kCompressedPhase.h

Go to the documentation of this file.

#ifndef K_FIRESYNC_COMPRESSED_PHASE_H
#define K_FIRESYNC_COMPRESSED_PHASE_H

#include <kFireSync/kFsDef.h>
#include <kFireSync/Data/kCompressedPhase.x.h>

//typedef kObject kCompressedPhaseStream;            --forward-declared in kFsDef.x.h  

//typedef kObject kCompressedPhase;            --forward-declared in kFsDef.x.h  

kFsFx(kStatus) kCompressedPhase_Construct(kCompressedPhase* data, kAlloc allocator); 

kFsFx(kStatus) kCompressedPhase_Clear(kCompressedPhase data);

kInlineFx(kStatus) kCompressedPhase_SetSubframeIndex(kCompressedPhase data, kSize index)
{
    kObj(kCompressedPhase, data);

    obj->subframeIndex = index;
    
    return kOK; 
}

kInlineFx(kSize) kCompressedPhase_SubframeIndex(kCompressedPhase data)
{
    kObj(kCompressedPhase, data);

    return obj->subframeIndex;
}

kInlineFx(kStatus) kCompressedPhase_SetFinalSubframe(kCompressedPhase data, kBool isFinal)
{
    kObj(kCompressedPhase, data);

    obj->isFinalSubframe = isFinal;

    return kOK;
}

kInlineFx(kBool) kCompressedPhase_IsFinalSubframe(kCompressedPhase data)
{
    kObj(kCompressedPhase, data);

    return obj->isFinalSubframe;
}

kFsFx(kStatus) kCompressedPhase_SetPhasePrediction(kCompressedPhase data, k32u prediction); 

kInlineFx(k32u) kCompressedPhase_PhasePrediction(kCompressedPhase data)
{
    kObj(kCompressedPhase, data); 

    return obj->phasePrediction; 
}

kInlineFx(kStatus) kCompressedPhase_SetSubframeLength(kCompressedPhase data, kSize length)
{
    kObj(kCompressedPhase, data); 

    obj->subframeLength = length; 

    return kOK;
}

kInlineFx(kSize) kCompressedPhase_SubframeLength(kCompressedPhase data)
{
    kObj(kCompressedPhase, data); 

    return obj->subframeLength; 
}

kFsFx(kStatus) kCompressedPhase_SetLength(kCompressedPhase data, kSize dimension, kSize length); 

kFsFx(kSize) kCompressedPhase_Length(kCompressedPhase data, kSize dimension); 

kFsFx(kStatus) kCompressedPhase_DefineStream(kCompressedPhase data, kCompressedPhaseStreamId streamId, kCompressedPhaseEncoding encoding, kCompressedPhaseStream* stream);

kFsFx(kStatus) kCompressedPhase_BeginAttach(kCompressedPhase data); 

kFsFx(kStatus) kCompressedPhase_AttachPacket(kCompressedPhase data, kCompressedPhaseStream stream, const void* packet, kSize packetSize); 

kFsFx(kStatus) kCompressedPhase_SetItemCount(kCompressedPhase data, kCompressedPhaseStream stream, kSize itemCount); 

kFsFx(kStatus) kCompressedPhase_BeginWrite(kCompressedPhase data); 

kFsFx(kStatus) kCompressedPhase_WriteDelta(kCompressedPhase data, kCompressedPhaseStream stream, k32s delta); 

kFsFx(kStatus) kCompressedPhase_WriteFail(kCompressedPhase data, kCompressedPhaseStream stream, k32s index, k32s value); 

kFsFx(kStatus) kCompressedPhase_WriteNull(kCompressedPhase data, kCompressedPhaseStream stream, k32s index, k32s count); 

kFsFx(kStatus) kCompressedPhase_EndWrite(kCompressedPhase data); 

kFsFx(kStatus) kCompressedPhase_FindStream(kCompressedPhase data, kCompressedPhaseStreamId streamId, kCompressedPhaseStream* stream);

kFsFx(kStatus) kCompressedPhase_ReadPhaseStreams(kCompressedPhase data, kArrayList delta, kArrayList fail1, kArrayList fail2, kArrayList null, kObject* context);

kFsFx(kStatus) kCompressedPhase_ReadIntensityStreams(kCompressedPhase data, kArrayList delta, kArrayList fail1, kArrayList fail2, kArrayList null, kObject* context);

kInlineFx(kBool) kCompressedPhase_HasStream(kCompressedPhase data, kCompressedPhaseStreamId streamId)
{
    return kSuccess(kCompressedPhase_FindStream(data, streamId, kNULL)); 
}

kInlineFx(kSize) kCompressedPhase_StreamCount(kCompressedPhase data)
{
    kObj(kCompressedPhase, data);

    return kArrayList_Count(obj->streams); 
}

kInlineFx(kCompressedPhaseStream) kCompressedPhase_StreamAt(kCompressedPhase data, kSize index)
{
    kObj(kCompressedPhase, data);

    return kArrayList_AsT(obj->streams, index, kCompressedPhaseStream); 
}

kInlineFx(kSize) kCompressedPhase_ItemCount(kCompressedPhase data, kCompressedPhaseStream stream)
{
    kObjN(kCompressedPhaseStream, streamObj, stream);

    return streamObj->itemCount;
}

kInlineFx(kSize) kCompressedPhase_PacketCount(kCompressedPhase data, kCompressedPhaseStream stream)
{
    kObj(kCompressedPhaseStream, stream); 

    return kArrayList_Count(obj->packetList); 
}

kInlineFx(kSize) kCompressedPhase_PacketSize(kCompressedPhase data, kCompressedPhaseStream stream, kSize index)
{
    kObjN(kCompressedPhaseStream, streamObj, stream);
    kCompressedPhasePacket* packet = kArrayList_AtT(streamObj->packetList, index, kCompressedPhasePacket); 

    return packet->size;
}

kInlineFx(kPointer) kCompressedPhase_PacketData(kCompressedPhase data, kCompressedPhaseStream stream, kSize index)
{
    kObjN(kCompressedPhaseStream, streamObj, stream);
    kCompressedPhasePacket* packet = kArrayList_AtT(streamObj->packetList, index, kCompressedPhasePacket); 

    return packet->data;
}

kInlineFx(kSize) kCompressedPhase_StreamSize(kCompressedPhase data, kCompressedPhaseStream stream)
{
    kObjN(kCompressedPhaseStream, streamObj, stream);
   
    return streamObj->streamSize;
}

kInlineFx(kCompressedPhaseStreamId) kCompressedPhase_Id(kCompressedPhase data, kCompressedPhaseStream stream)
{
    kObjN(kCompressedPhaseStream, streamObj, stream);

    return streamObj->id;
}

kInlineFx(kCompressedPhaseEncoding) kCompressedPhase_Encoding(kCompressedPhase data, kCompressedPhaseStream stream)
{
    kObjN(kCompressedPhaseStream, streamObj, stream);

    return streamObj->encoding;
}

kFsFx(kStatus) kCompressedPhase_IntensityBitDepths(kCompressedPhase data, k32u* deltaBitDepth, k32u* fail1BitDepth, k32u* fail2BitDepth, k32u* nullBitDepth);

kFsFx(kStatus) kCompressedPhase_PhaseBitDepths(kCompressedPhase data, k32u* deltaBitDepth, k32u* fail1BitDepth, k32u* fail2BitDepth, k32u* nullBitDepth);


//typedef kObject kCompressedPhaseReader;            --forward-declared in kFsDef.x.h  

kFsFx(kStatus) kCompressedPhaseReader_Construct(kCompressedPhaseReader* reader, kAlloc allocator); 

kFsFx(kStatus) kCompressedPhaseReader_Begin(kCompressedPhaseReader reader, kCompressedPhase data, kCompressedPhaseStream stream); 

kInlineFx(kStatus) kCompressedPhaseReader_ReadDelta(kCompressedPhaseReader reader, k32s* delta)
{
    kObj(kCompressedPhaseReader, reader); 

    return xkCompressedPhaseStream_ReadDelta(obj->stream, delta);
}

kInlineFx(kStatus) kCompressedPhaseReader_ReadFail(kCompressedPhaseReader reader, k32s* index, k32s* value)
{
    kObj(kCompressedPhaseReader, reader); 

    return xkCompressedPhaseStream_ReadFail(obj->stream, index, value);
}

kInlineFx(kStatus) kCompressedPhaseReader_ReadNull(kCompressedPhaseReader reader, k32s* index, k32s* count)
{
    kObj(kCompressedPhaseReader, reader); 

    return xkCompressedPhaseStream_ReadNull(obj->stream, index, count);
}

kInlineFx(kSize) kCompressedPhaseReader_ItemCount(kCompressedPhaseReader reader)
{
    kObj(kCompressedPhaseReader, reader); 

    return xkCompressedPhaseStream_ItemCount(obj->stream);
}

kInlineFx(kBool) kCompressedPhaseReader_IsIntensity(kCompressedPhase data)
{
    return kSuccess(kCompressedPhase_FindStream(data, kCOMPRESSED_PHASE_STREAM_ID_INTENSITY_DELTA, kNULL));
}

#endif