codec.h

Go to the documentation of this file.

#ifndef _CODEC_H
#define _CODEC_H

static const SEGMENT StartMarkerSegment = ((0x56 << 24) | (0x43 << 16) | (0x2D << 8) | 0x35);

typedef enum _codec_tag
{
        CODEC_TAG_ImageWidth = 20,                      
        CODEC_TAG_ImageHeight = 21,                     
        CODEC_TAG_BitsPerComponent = 101,       
        CODEC_TAG_ChannelCount = 12,            
        CODEC_TAG_SubbandCount = 14,            
        CODEC_TAG_ChannelNumber = 62,           
        CODEC_TAG_SubbandNumber = 48,           
        CODEC_TAG_LowpassPrecision = 35,        
        CODEC_TAG_Quantization = 53,            
        CODEC_TAG_PrescaleShift = 109,          
        CODEC_TAG_ChannelWidth = 104,           
        CODEC_TAG_ChannelHeight = 105,          

#if _DEBUG
        // Optional tag-value pairs used for debugging
        CODEC_TAG_PixelFormat = 1001,           
#endif

        CODEC_TAG_LargeCodeblock = 0x6000,      

        CODEC_TAG_SMALL_CHUNK = 0x4000,         
        CODEC_TAG_LARGE_CHUNK = 0x2000,         

        CODEC_TAG_CHUNK_MASK = (CODEC_TAG_SMALL_CHUNK | CODEC_TAG_LARGE_CHUNK),

#if VC5_ENABLED_PART(VC5_PART_IMAGE_FORMATS)
        // Codec tags used by VC-5 Part 3 bitstreams
        CODEC_TAG_PatternWidth = 106,                           
        CODEC_TAG_PatternHeight = 107,                          
        CODEC_TAG_ComponentsPerSample = 108,            
        CODEC_TAG_ImageFormat = 84,                                     
        CODEC_TAG_MaxBitsPerComponent = 102,            

        // Small chunk elements defined by VC-5 Part 3
        CODEC_TAG_VendorSpecificData = 0x4000,          
        CODEC_TAG_InversePermutation = 0x4001,          
        CODEC_TAG_InverseTransform = 0x4002,            
        CODEC_TAG_InverseTransform16 = 0x4003,          
        CODEC_TAG_UniqueImageIdentifier = 0x4004,       
#endif

#if VC5_ENABLED_PART(VC5_PART_LAYERS)
        CODEC_TAG_LayerCount = 120,                                     
        CODEC_TAG_LayerNumber = 121,                            
        CODEC_TAG_LayerPattern = 122,                           
#endif

#if VC5_ENABLED_PART(VC5_PART_SECTIONS)
        CODEC_TAG_ImageCount = 130,                                     
        CODEC_TAG_ImageNumber = 131,                            
    
    // Predefined codec tags for structures in the VC-5 bitstream
    CODEC_TAG_ImageSectionTag = 0x2700,         
    CODEC_TAG_HeaderSectionTag = 0x2500,        
    CODEC_TAG_LayerSectionTag = 0x2600,         
    CODEC_TAG_ChannelSectionTag = 0x2400,       
    CODEC_TAG_WaveletSectionTag = 0x2100,       
    CODEC_TAG_SubbandSectionTag = 0x2000,       
#endif

#if VC5_ENABLED_PART(VC5_PART_METADATA)
        // Small and large chunks of metadata
        CODEC_TAG_SmallMetadata = 0x4010,                       
        CODEC_TAG_LargeMetadata = 0x6100,                       
#endif

} CODEC_TAG;

#if VC5_ENABLED_PART(VC5_PART_IMAGE_FORMATS)

typedef enum _image_format
{
        IMAGE_FORMAT_UNKNOWN = 0,               
        IMAGE_FORMAT_RGBA,                              
        IMAGE_FORMAT_YCbCrA,                    
        IMAGE_FORMAT_BAYER,                             
        IMAGE_FORMAT_CFA,                               


        /***** Add new encoded formats above this line *****/

        IMAGE_FORMAT_COUNT,                             

} IMAGE_FORMAT;

#endif

#if VC5_ENABLED_PART(VC5_PART_SECTIONS)

/*
 @brief Enumeration of the predefined section numbers
 
 The predefined section numbers are defined in ST 2073-2.
 */
typedef enum _section_number
{
    SECTION_NUMBER_IMAGE = 1,       
    SECTION_NUMBER_HEADER = 2,      
    SECTION_NUMBER_LAYER = 3,       
    SECTION_NUMBER_CHANNEL = 4,     
    SECTION_NUMBER_WAVELET = 5,     
    SECTION_NUMBER_SUBBAND = 6,     
    
    //TODO: Add more section number definitions as required
    
    SECTION_NUMBER_MINIMUM = SECTION_NUMBER_IMAGE,
    SECTION_NUMBER_MAXIMUM = SECTION_NUMBER_SUBBAND,
    
} SECTION_NUMBER;

/*
 @Macro for creating a section number bit mask from a section number
 
 The macro does not check that the section number argument is valid.
 */
#define SECTION_NUMBER_MASK(section_number)  (1 << (section_number - 1))

/*
 @brief Data type for the bit mask that represents enabled sections
 
 The bit mask indicates which section numbers defined in ST 2073-2 are enabled
 at runtime.
 */
typedef uint32_t ENABLED_SECTIONS;

#endif

enum band_encoding {
        BAND_ENCODING_ZEROTREE = 1,
        BAND_ENCODING_CODEBOOK,
        BAND_ENCODING_RUNLENGTHS,
        BAND_ENCODING_16BIT,
        BAND_ENCODING_LOSSLESS
};

typedef struct _codec_state
{
        uint16_t channel_number;                
        DIMENSION channel_width;                
        DIMENSION channel_height;               
        PRECISION bits_per_component;   

        uint16_t subband_number;                

#if VC5_ENABLED_PART(VC5_PART_IMAGE_FORMATS)
        IMAGE_FORMAT image_format;                      
        DIMENSION pattern_width;                        
        DIMENSION pattern_height;                       
        DIMENSION components_per_sample;        
        PRECISION max_bits_per_component;       
#endif

#if VC5_ENABLED_PART(VC5_PART_LAYERS)
        COUNT layer_count;                  
    COUNT layer_number;                 
    uint16_t layer_pattern;             
    uint32_t decoded_layer_mask;        
#endif

        uint_least8_t channel_count;    
        uint_least8_t wavelet_count;    
        uint_least8_t subband_count;    

        size_t channel_position;

        uint32_t encoded_format;                        
        uint32_t encoded_quality;                       

        uint32_t decoded_subband_mask;          

        bool progressive;                                       

        bool top_field_first;                           

        bool frame_inverted;                            

        uint_least8_t group_length;                     

#if 0
        uint8_t active_codebook;                        
        bool difference_coding;                         
#endif

        bool end_of_sample;

        bool end_of_layer;

        bool header;

        bool codeblock;

        struct
        {
                //DIMENSION width;                              //!< Width of the decoded band
                //DIMENSION height;                             //!< Height of the decoded band
                uint_least8_t subband;                  
                //uint_least8_t encoding;               //!< Band encoding method
                uint16_t quantization;                  

        } band;                 

        DIMENSION image_width;                  
        DIMENSION image_height;                 

        PRECISION lowpass_precision;    

#if _DEBUG
        struct
        {
                PIXEL_FORMAT format;                    

        } input;
#endif

        //uint_fast8_t prescale_table[MAX_WAVELET_COUNT];
        PRESCALE prescale_table[MAX_WAVELET_COUNT];

        struct _picture_aspect_ratio
        {
                uint_least16_t x;               
                uint_least16_t y;               

        } picture_aspect_ratio;         

#if VC5_ENABLED_PART(VC5_PART_LAYERS)
        //uint32_t interlaced_flags;
        //uint32_t protection_flags;

        struct
        {
                int width;                      
                int height;                     

        } layer;                

#endif
    
#if VC5_ENABLED_PART(VC5_PART_SECTIONS)
    int section_number;     
    int section_length;     
#endif

} CODEC_STATE;

#if 0

typedef struct _codec
{
        FILE *logfile;                          
        CODEC_ERROR error;                      
        ALLOCATOR *allocator;           
        CODEC_STATE codec;                      
        VERSION version;                        

        ENABLED_PARTS enabled_parts;

} CODEC;
#endif

// Initialize the codec state
CODEC_ERROR PrepareCodecState(CODEC_STATE *codec);

uint32_t EncoderVersion(uint32_t value);

uint32_t RepackedEncoderVersion(uint32_t value);

void SetCodecVersion(uint8_t version[3], uint16_t value);

#if VC5_ENABLED_PART(VC5_PART_IMAGE_FORMATS)
IMAGE_FORMAT DefaultImageFormat(PIXEL_FORMAT pixel_format);
#endif

int EncodedPrecision(PIXEL_FORMAT format);

int InputPrecision(PIXEL_FORMAT format);

CODEC_ERROR UpdatePrescaleTable(CODEC_STATE *codec, TAGWORD value);

CODEC_ERROR UpdateSampleFlags(CODEC_STATE *codec, TAGWORD value);

CODEC_ERROR UpdateCodecFlags(CODEC_STATE *codec, TAGWORD value);

CODEC_ERROR UpdateFrameStructureFlags(CODEC_STATE *codec, TAGWORD value);

int LowpassChannelOffset(CODEC_STATE *codec, PIXEL_FORMAT output_format);

CODEC_ERROR SetBandCoding(CODEC_STATE *codec, TAGWORD value);

#if VC5_ENABLED_PART(VC5_PART_IMAGE_FORMATS)
const char *ImageFormatString(IMAGE_FORMAT image_format);
#endif

bool IsPartEnabled(ENABLED_PARTS enabled_parts, int part_number);

#if VC5_ENABLED_PART(VC5_PART_SECTIONS)
bool IsSectionEnabled(ENABLED_SECTIONS enabled_sections, SECTION_NUMBER section_number);
bool IsImageSectionEnabled(ENABLED_PARTS enabled_parts, ENABLED_SECTIONS enabled_sections);
#endif

#endif