helper.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2003, Matt Beard
 *
 *  This software is provided 'as-is', without any express or implied warranty.
 *  In no event will the authors be held liable for any damages arising from
 *  the use of this software.
 *
 *  Permission is granted to anyone to use this software for any purpose,
 *  including commercial applications, and to alter it and redistribute it
 *  freely, subject to the following restrictions:
 *
 *    1. The origin of this software must not be misrepresented; you must
 *       not claim that you wrote the original software. If you use this
 *       software in a product, an acknowledgment in the product
 *       documentation would be appreciated but is not required.
 *  
 *    2. Altered source versions must be plainly marked as such, and must
 *       not be misrepresented as being the original software.
 *  
 *    3. This notice may not be removed or altered from any source
 *       distribution.
 */

#ifndef MXFLIB__HELPER_H
#define MXFLIB__HELPER_H


#include <time.h>
#include <string>

namespace mxflib
{
    // Declare the global null-ul which is 16 zero bytes
    extern const UL Null_UL;
    
    inline std::string Int2String(int Num, int Digits = 0)
    {
        char Buffer[18];
        if(Digits > 16) Digits = 16;
        sprintf(Buffer, "%0*d", Digits, Num);
        return std::string(Buffer);
    }

    inline std::string UInt2String(int Num, int Digits = 0)
    {
        char Buffer[18];
        if(Digits > 16) Digits = 16;
        sprintf(Buffer, "%0*u", Digits, Num);
        return std::string(Buffer);
    }

    // Support old capitalization of unsigned integers
    inline std::string Uint2String(int Num, int Digits = 0) { return UInt2String(Num, Digits); }

    inline std::string Int2HexString(int Num, int Digits = 0)
    {
        char Buffer[18];
        if(Digits > 16) Digits = 16;
        sprintf(Buffer, "%0*x", Digits, Num);
        return std::string(Buffer);
    }


    inline std::string Time2String(full_time Time, bool StrictISO = false)
    {
        char Buffer[32];
        
        if(StrictISO)
            strftime(Buffer, 31, "%Y-%m-%dT%H:%M:%S.", gmtime( &Time.time ));
        else
            strftime(Buffer, 31, "%Y-%m-%d %H:%M:%S.", gmtime( &Time.time ));

        // Append the milliseconds
        sprintf(&Buffer[strlen(Buffer)], "%03d", Time.msBy4 * 4);

        return std::string(Buffer);
    }


    inline std::string Now2String(bool StrictISO = false)
    {
        full_time now = GetTime();
        
        return Time2String(now, StrictISO);
    }


    UInt32 MakeBER(UInt8 *Data, int MaxSize, UInt64 Length, UInt32 Size = 0);



    inline DataChunkPtr MakeBER(UInt64 Length, UInt32 Size = 0)
    {
        // Buffer for building BER
        UInt8 Buff[9];

        UInt32 Bytes = MakeBER(Buff, 9, Length, Size);

        // Return as a DataChunk
        return new DataChunk(Bytes, Buff);
    }

    Length ReadBER(UInt8 **Data, int MaxSize);


    int EncodeOID( UInt8* presult, UInt64 subid, int length );

    UMIDPtr MakeUMID(int Type, const UUIDPtr AssetID = NULL);

    DataChunkPtr FileReadChunk(FileHandle InFile, UInt64 Size);



    U32Pair ReadIFFHeader(FileHandle InFile, bool BigEndian = true);



    inline U32Pair ReadRIFFHeader(FileHandle InFile)
    {
        return ReadIFFHeader(InFile, false);
    }



    inline U32Pair ReadAIFFHeader(FileHandle InFile)
    {
        return ReadIFFHeader(InFile, true);
    }



    std::pair<UInt32, Length> ReadAtomHeader(FileHandle InFile, bool SkipWide = true);


    DataChunkPtr Hex2DataChunk(std::string Hex);

    void SetDictionaryPath(std::string NewPath);

    inline void SetDictionaryPath(const char *NewPath) { SetDictionaryPath(std::string(NewPath)); }


    std::string LookupDictionaryPath(const char *Filename);
    
    inline std::string LookupDictionaryPath(std::string Filename) { return LookupDictionaryPath(Filename.c_str()); }


    std::string SearchPath(const char *Path, const char *Filename);

    inline std::string SearchPath(std::string Path, std::string Filename) { return SearchPath(Path.c_str(), Filename.c_str()); }


    // File read primitives

    inline UInt8 ReadU8(FileHandle Handle) { unsigned char Buffer[1]; if(FileRead(Handle, Buffer, 1) == 1) return GetU8(Buffer); else return 0; }

    inline UInt16 ReadU16(FileHandle Handle) { unsigned char Buffer[2]; if(FileRead(Handle, Buffer, 2) == 2) return GetU16(Buffer); else return 0; }

    inline UInt32 ReadU32(FileHandle Handle) { unsigned char Buffer[4]; if(FileRead(Handle, Buffer, 4) == 4) return GetU32(Buffer); else return 0; }

    inline UInt64 ReadU64(FileHandle Handle) { unsigned char Buffer[8]; if(FileRead(Handle, Buffer, 8) == 8) return GetU64(Buffer); else return 0; }

    inline Int8 ReadI8(FileHandle Handle) { return (Int8)ReadU8(Handle); }

    inline Int16 ReadI16(FileHandle Handle) { return (Int16)ReadU16(Handle); }
    
    inline Int32 ReadI32(FileHandle Handle) { return (Int32)ReadU32(Handle); }
    
    inline Int64 ReadI64(FileHandle Handle) { return (Int64)ReadU64(Handle); }

    inline UInt8 ReadU8_LE(FileHandle Handle) { unsigned char Buffer[1]; if(FileRead(Handle, Buffer, 1) == 1) return GetU8_LE(Buffer); else return 0; }

    inline UInt16 ReadU16_LE(FileHandle Handle) { unsigned char Buffer[2]; if(FileRead(Handle, Buffer, 2) == 2) return GetU16_LE(Buffer); else return 0; }

    inline UInt32 ReadU32_LE(FileHandle Handle) { unsigned char Buffer[4]; if(FileRead(Handle, Buffer, 4) == 4) return GetU32_LE(Buffer); else return 0; }

    inline UInt64 ReadU64_LE(FileHandle Handle) { unsigned char Buffer[8]; if(FileRead(Handle, Buffer, 8) == 8) return GetU64_LE(Buffer); else return 0; }

    inline Int8 ReadI8_LE(FileHandle Handle) { return (Int8)ReadU8_LE(Handle); }

    inline Int16 ReadI16_LE(FileHandle Handle) { return (Int16)ReadU16_LE(Handle); }
    
    inline Int32 ReadI32_LE(FileHandle Handle) { return (Int32)ReadU32_LE(Handle); }
    
    inline Int64 ReadI64_LE(FileHandle Handle) { return (Int64)ReadU64_LE(Handle); }



    bool IsPartitionKey(const UInt8 *Key);


    bool IsWideString(std::string &String);


    int ReadHexString(const char **Source, int Max, UInt8 *Dest, const char *Sep);


    inline int ReadHexString(const char *Source, int Max, UInt8 *Dest, const char *Sep)
    {
        const char *p = Source;
        return ReadHexString(&p, Max, Dest, Sep);
    }


    bool StringToUL(UInt8 *Data, std::string Val);
    

    inline ULPtr StringToUL(std::string Val)
    {
        UInt8 Data[16];
        if(!StringToUL(Data, Val)) return NULL;
        return new UL(Data);
    }
}

#endif // MXFLIB__HELPER_H

---