//*@@@+++@@@@******************************************************************

//

// Copyright © Microsoft Corp.

// All rights reserved.

// 

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are met:

// 

// • Redistributions of source code must retain the above copyright notice,

//   this list of conditions and the following disclaimer.

// • Redistributions in binary form must reproduce the above copyright notice,

//   this list of conditions and the following disclaimer in the documentation

//   and/or other materials provided with the distribution.

// 

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE

// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

// POSSIBILITY OF SUCH DAMAGE.

//

//*@@@---@@@@******************************************************************

#include "JXRMeta.h"

#include "JXRGlue.h"

// read and write big and little endian words/dwords from a buffer on both big and little endian cpu's

// with full buffer overflow checking

ERR getbfcpy(U8* pbdest, const U8* pb, size_t cb, size_t ofs, U32 n)

{

    ERR err = WMP_errSuccess;

    FailIf(ofs + n > cb, WMP_errBufferOverflow);

    memcpy(pbdest, &pb[ofs], n);

Cleanup:

    return err;

}

ERR getbfw(const U8* pb, size_t cb, size_t ofs, U16* pw)

{

    ERR err = WMP_errSuccess;

    FailIf(ofs + sizeof(U16) > cb, WMP_errBufferOverflow);

    *pw = (U16)( pb[ofs] + ( pb[ofs + 1] << 8 ) );

Cleanup:

    return err;

}

ERR getbfdw(const U8* pb, size_t cb, size_t ofs, U32* pdw)

{

    ERR err = WMP_errSuccess;

    FailIf(ofs + sizeof(U32) > cb, WMP_errBufferOverflow);

    *pdw = pb[ofs] + ( pb[ofs + 1] << 8 ) + ( pb[ofs + 2] << 16UL ) + ( pb[ofs + 3] << 24UL );

Cleanup:

    return err;

}

ERR getbfwbig(const U8* pb, size_t cb, size_t ofs, U16* pw)

{

    ERR err = WMP_errSuccess;

    FailIf(ofs + sizeof(U16) > cb, WMP_errBufferOverflow);

    *pw = (U16)( pb[ofs + 1] + ( pb[ofs] << 8 ) );

Cleanup:

    return err;

}

ERR getbfdwbig(const U8* pb, size_t cb, size_t ofs, U32* pdw)

{

    ERR err = WMP_errSuccess;

    FailIf(ofs + sizeof(U32) > cb, WMP_errBufferOverflow);

    *pdw = pb[ofs + 3] + ( pb[ofs + 2] << 8 ) + ( pb[ofs + 1] << 16UL ) + ( pb[ofs] << 24UL );

Cleanup:

    return err;

}

ERR getbfwe(const U8* pb, size_t cb, size_t ofs, U16* pw, U8 endian)

{

    if ( endian == WMP_INTEL_ENDIAN )

        return ( getbfw(pb, cb, ofs, pw) );

    else

        return ( getbfwbig(pb, cb, ofs, pw) );

}

ERR getbfdwe(const U8* pb, size_t cb, size_t ofs, U32* pdw, U8 endian)

{

    if ( endian == WMP_INTEL_ENDIAN )

        return ( getbfdw(pb, cb, ofs, pdw) );

    else

        return ( getbfdwbig(pb, cb, ofs, pdw) );

}

ERR setbfcpy(U8* pb, size_t cb, size_t ofs, const U8* pbset, size_t cbset)

{

    ERR err = WMP_errSuccess;

    FailIf(ofs + cbset > cb, WMP_errBufferOverflow);

    memcpy(&pb[ofs], pbset, cbset);

Cleanup:

    return err;

}

ERR setbfw(U8* pb, size_t cb, size_t ofs, U16 dw)

{

    ERR err = WMP_errSuccess;

    FailIf(ofs + sizeof(U16) > cb, WMP_errBufferOverflow);

    pb[ofs] = (U8)dw;

    pb[ofs + 1] = (U8)( dw >> 8 );

Cleanup:

    return err;

}

ERR setbfdw(U8* pb, size_t cb, size_t ofs, U32 dw)

{

    ERR err = WMP_errSuccess;

    FailIf(ofs + sizeof(U32) > cb, WMP_errBufferOverflow);

    pb[ofs] = (U8)dw;

    pb[ofs + 1] = (U8)( dw >> 8 );

    pb[ofs + 2] = (U8)( dw >> 16 );

    pb[ofs + 3] = (U8)( dw >> 24 );

Cleanup:

    return err;

}

ERR setbfwbig(U8* pb, size_t cb, size_t ofs, U16 dw)

{

    ERR err = WMP_errSuccess;

    FailIf(ofs + sizeof(U16) > cb, WMP_errBufferOverflow);

    pb[ofs + 1] = (U8)dw;

    pb[ofs] = (U8)( dw >> 8 );

Cleanup:

    return err;

}

ERR setbfdwbig(U8* pb, size_t cb, size_t ofs, U32 dw)

{

    ERR err = WMP_errSuccess;

    FailIf(ofs + sizeof(U32) > cb, WMP_errBufferOverflow);

    pb[ofs + 3] = (U8)dw;

    pb[ofs + 2] = (U8)( dw >> 8 );

    pb[ofs + 1] = (U8)( dw >> 16 );

    pb[ofs] = (U8)( dw >> 24 );

Cleanup:

    return err;

}

//================================================================

// BufferCalcIFDSize (arbitrary endian)

// StreamCalcIFDSize (little endian)

//

// count up the number of bytes needed to store the IFD and all

// associated data including a subordinate interoperability IFD if any

//================================================================

ERR BufferCalcIFDSize(const U8* pbdata, size_t cbdata, U32 ofsifd, U8 endian, U32* pcbifd)

{

    ERR err = WMP_errSuccess;

    U16 cDir;

    U16 i;

    U32 ofsdir;

    U32 cbifd = 0;

    U32 cbEXIFIFD = 0;

    U32 cbGPSInfoIFD = 0;

    U32 cbInteroperabilityIFD = 0;

    *pcbifd = 0;

    Call(getbfwe(pbdata, cbdata, ofsifd, &cDir, endian));

    cbifd = sizeof(U16) + cDir * SizeofIFDEntry + sizeof(U32);

    ofsdir = ofsifd + sizeof(U16);

    for ( i = 0; i < cDir; i++ )

    {

        U16 tag = 0;

        U16 type = 0;

        U32 count = 0;

        U32 value = 0;

        U32 datasize = 0;

        Call(getbfwe(pbdata, cbdata, ofsdir, &tag, endian));

        Call(getbfwe(pbdata, cbdata, ofsdir + sizeof(U16), &type, endian));

        Call(getbfdwe(pbdata, cbdata, ofsdir + 2 * sizeof(U16), &count, endian));

        Call(getbfdwe(pbdata, cbdata, ofsdir + 2 * sizeof(U16) + sizeof(U32), &value, endian));

        FailIf(type == 0 || type >= sizeof(IFDEntryTypeSizes) / sizeof(IFDEntryTypeSizes[0]), WMP_errFail);

        if ( tag == WMP_tagEXIFMetadata )

        {

            Call(BufferCalcIFDSize(pbdata, cbdata, value, endian, &cbEXIFIFD));

        }

        else if ( tag == WMP_tagGPSInfoMetadata )

        {

            Call(BufferCalcIFDSize(pbdata, cbdata, value, endian, &cbGPSInfoIFD));

        }

        else if ( tag == WMP_tagInteroperabilityIFD )

        {

            Call(BufferCalcIFDSize(pbdata, cbdata, value, endian, &cbInteroperabilityIFD));

        }

        else

        {

            datasize = IFDEntryTypeSizes[type] * count;

            if ( datasize > 4 )

                cbifd += datasize;

        }

        ofsdir += SizeofIFDEntry;

    }

    if ( cbEXIFIFD != 0 )

        cbifd += ( cbifd & 1 ) + cbEXIFIFD;

    if ( cbGPSInfoIFD != 0 )

        cbifd += ( cbifd & 1 ) + cbGPSInfoIFD;

    if ( cbInteroperabilityIFD != 0 )

        cbifd += ( cbifd & 1 ) + cbInteroperabilityIFD;

    *pcbifd = cbifd;

Cleanup:

    return err;

}

ERR StreamCalcIFDSize(struct WMPStream* pWS, U32 uIFDOfs, U32 *pcbifd)

{

    ERR err = WMP_errSuccess;

    size_t offCurPos = 0;

    Bool GetPosOK = FALSE;

    U16 cDir;

    U32 i;

    U32 ofsdir;

    U32 cbifd = 0;

    U32 cbEXIFIFD = 0;

    U32 cbGPSInfoIFD = 0;

    U32 cbInteroperabilityIFD = 0;

    *pcbifd = 0;

    Call(pWS->GetPos(pWS, &offCurPos));

    GetPosOK = TRUE;

    Call(GetUShort(pWS, uIFDOfs, &cDir));

    cbifd = sizeof(U16) + cDir * SizeofIFDEntry + sizeof(U32);

    ofsdir = uIFDOfs + sizeof(U16);

    for ( i = 0; i < cDir; i++ )

    {

        U16 tag = 0;

        U16 type = 0;

        U32 count = 0;

        U32 value = 0;

        U32 datasize = 0;

        Call(GetUShort(pWS, ofsdir, &tag));

        Call(GetUShort(pWS, ofsdir + sizeof(U16), &type));

        Call(GetULong(pWS, ofsdir + 2 * sizeof(U16), &count));

        Call(GetULong(pWS, ofsdir + 2 * sizeof(U16) + sizeof(U32), &value));

        FailIf(type == 0 || type >= sizeof(IFDEntryTypeSizes) / sizeof(IFDEntryTypeSizes[0]), WMP_errUnsupportedFormat);

        if ( tag == WMP_tagEXIFMetadata )

        {

            Call(StreamCalcIFDSize(pWS, value, &cbEXIFIFD));

        }

        else if ( tag == WMP_tagGPSInfoMetadata )

        {

            Call(StreamCalcIFDSize(pWS, value, &cbGPSInfoIFD));

        }

        else if ( tag == WMP_tagInteroperabilityIFD )

        {

            Call(StreamCalcIFDSize(pWS, value, &cbInteroperabilityIFD));

        }

        else

        {

            datasize = IFDEntryTypeSizes[type] * count;

            if ( datasize > 4 )

                cbifd += datasize;

        }

        ofsdir += SizeofIFDEntry;

    }

    if ( cbEXIFIFD != 0 )

        cbifd += ( cbifd & 1 ) + cbEXIFIFD;

    if ( cbGPSInfoIFD != 0 )

        cbifd += ( cbifd & 1 ) + cbGPSInfoIFD;

    if ( cbInteroperabilityIFD != 0 )

        cbifd += ( cbifd & 1 ) + cbInteroperabilityIFD;

    *pcbifd = cbifd;

Cleanup:

    if ( GetPosOK )

        Call(pWS->SetPos(pWS, offCurPos));

    return ( err );

}

// src IFD copied to dst IFD with any nested IFD's

// src IFD is arbitrary endian, arbitrary data arrangement

// dst IFD is little endian, data arranged in tag order

// dst IFD tags are ordered the same as src IFD so src IFD tags must be in order

ERR BufferCopyIFD(const U8* pbsrc, U32 cbsrc, U32 ofssrc, U8 endian, U8* pbdst, U32 cbdst, U32* pofsdst)

{

    ERR err = WMP_errSuccess;

    U16 cDir;

    U16 i;

    U16 ofsEXIFIFDEntry = 0;

    U16 ofsGPSInfoIFDEntry = 0;

    U16 ofsInteroperabilityIFDEntry = 0;

    U32 ofsEXIFIFD = 0;

    U32 ofsGPSInfoIFD = 0;

    U32 ofsInteroperabilityIFD = 0;

    U32 ofsdstnextdata;

    U32 ofsdst = *pofsdst;

    U32 ofssrcdir;

    U32 ofsdstdir;

    U32 ofsnextifd;

    Call(getbfwe(pbsrc, cbsrc, ofssrc, &cDir, endian));

    Call(setbfw(pbdst, cbdst, ofsdst, cDir));

    ofsnextifd = ofsdst + sizeof(U16) + SizeofIFDEntry * cDir;

    ofsdstnextdata = ofsnextifd + sizeof(U32);

    ofssrcdir = ofssrc + sizeof(U16);

    ofsdstdir = ofsdst + sizeof(U16);

    for ( i = 0; i < cDir; i++ )

    {

        U16 tag = 0;

        U16 type = 0;

        U32 count = 0;

        U32 value = 0;

        U32 size = 0;

        Call(getbfwe(pbsrc, cbsrc, ofssrcdir, &tag, endian));

        Call(setbfw(pbdst, cbdst, ofsdstdir, tag));

        Call(getbfwe(pbsrc, cbsrc, ofssrcdir + sizeof(U16), &type, endian));

        Call(setbfw(pbdst, cbdst, ofsdstdir + sizeof(U16), type));

        Call(getbfdwe(pbsrc, cbsrc, ofssrcdir + 2 * sizeof(U16), &count, endian));

        Call(setbfdw(pbdst, cbdst, ofsdstdir + 2 * sizeof(U16), count));

        Call(getbfdwe(pbsrc, cbsrc, ofssrcdir + 2 * sizeof(U16) + sizeof(U32), &value, endian));

        Call(setbfdw(pbdst, cbdst, ofsdstdir + 2 * sizeof(U16) + sizeof(U32), 0));

        FailIf(type == 0 || type >= sizeof(IFDEntryTypeSizes) / sizeof(IFDEntryTypeSizes[0]), WMP_errFail);

        if ( tag == WMP_tagEXIFMetadata )

        {

            ofsEXIFIFDEntry = (U16) ofsdstdir;

            ofsEXIFIFD = value;

        }

        else if ( tag == WMP_tagGPSInfoMetadata )

        {

            ofsGPSInfoIFDEntry = (U16) ofsdstdir;

            ofsGPSInfoIFD = value;

        }

        else if ( tag == WMP_tagInteroperabilityIFD )

        {

            ofsInteroperabilityIFDEntry = (U16) ofsdstdir;

            ofsInteroperabilityIFD = value;

        }

        else

        {

            U32 ofsdstdata = ofsdstdir + 2 * sizeof(U16) + sizeof(U32);

            U32 ofssrcdata = ofssrcdir + 2 * sizeof(U16) + sizeof(U32);

            size = count * IFDEntryTypeSizes[type];

            if ( size > 4 )

            {

                ofssrcdata = value;

                Call(setbfdw(pbdst, cbdst, ofsdstdata, ofsdstnextdata));

                ofsdstdata = ofsdstnextdata;

                ofsdstnextdata += size;

            }

            FailIf(ofssrcdata + size > cbsrc || ofsdstdata + size > cbdst, WMP_errBufferOverflow);

            if ( size == count || endian == WMP_INTEL_ENDIAN )

                // size == count means 8-bit data means endian doesn't matter

                memcpy(&pbdst[ofsdstdata], &pbsrc[ofssrcdata], size);

            else

            {   // big endian source and endian matters

                U32 j;

                switch ( IFDEntryTypeSizes[type] )

                {

                case 2:

                    for ( j = 0; j < count; j++ )

                    {

                        U16 w;

                        getbfwbig(pbsrc, cbsrc, ofssrcdata + j * sizeof(U16), &w);

                        setbfw(pbdst, cbdst, ofsdstdata + j * sizeof(U16), w);

                    }

                    break;

                case 8:

                    if ( type == WMP_typDOUBLE )

                    {

                        for ( j = 0; j < count; j++ )

                        {

                            U32 dwlo;

                            U32 dwhi;

                            getbfdwbig(pbsrc, cbsrc, ofssrcdata + j * 8, &dwhi);

                            getbfdwbig(pbsrc, cbsrc, ofssrcdata + j * 8 + sizeof(U32), &dwlo);

                            setbfdw(pbdst, cbdst, ofsdstdata + j * 8, dwlo);

                            setbfdw(pbdst, cbdst, ofsdstdata + j * 8 + sizeof(U32), dwhi);

                        }

                        break;

                    }

                    count *= 2;

                    // RATIONAL's fall through to be handled as LONG's

                case 4:

                    for ( j = 0; j < count; j++ )

                    {

                        U32 dw;

                        getbfdwbig(pbsrc, cbsrc, ofssrcdata + j * sizeof(U32), &dw);

                        setbfdw(pbdst, cbdst, ofsdstdata + j * sizeof(U32), dw);

                    }

                    break;

                }

            }

        }

        ofssrcdir += SizeofIFDEntry;

        ofsdstdir += SizeofIFDEntry;

    }

    Call(setbfdw(pbdst, cbdst, ofsnextifd, 0));    // no nextIFD

    if ( ofsEXIFIFDEntry != 0 )

    {

        ofsdstnextdata += ( ofsdstnextdata & 1 );

        Call(setbfdw(pbdst, cbdst, ofsEXIFIFDEntry + 2 * sizeof(U16) + sizeof(U32), ofsdstnextdata));

        Call(BufferCopyIFD(pbsrc, cbsrc, ofsEXIFIFD, endian, pbdst, cbdst, &ofsdstnextdata));

    }

    if ( ofsGPSInfoIFDEntry != 0 )

    {

        ofsdstnextdata += ( ofsdstnextdata & 1 );

        Call(setbfdw(pbdst, cbdst, ofsGPSInfoIFDEntry + 2 * sizeof(U16) + sizeof(U32), ofsdstnextdata));

        Call(BufferCopyIFD(pbsrc, cbsrc, ofsGPSInfoIFD, endian, pbdst, cbdst, &ofsdstnextdata));

    }

    if ( ofsInteroperabilityIFDEntry != 0 )

    {

        ofsdstnextdata += ( ofsdstnextdata & 1 );

        Call(setbfdw(pbdst, cbdst, ofsInteroperabilityIFDEntry + 2 * sizeof(U16) + sizeof(U32), ofsdstnextdata));

        Call(BufferCopyIFD(pbsrc, cbsrc, ofsInteroperabilityIFD, endian, pbdst, cbdst, &ofsdstnextdata));

    }

    *pofsdst = ofsdstnextdata;

Cleanup:

    return err;

}

// src IFD copied to dst IFD with any nested IFD's

// src IFD is little endian, arbitrary data arrangement

// dst IFD is little endian, data arranged in tag order

// dst IFD tags are ordered the same as src IFD so src IFD tags must be in order

ERR StreamCopyIFD(struct WMPStream* pWS, U32 ofssrc, U8* pbdst, U32 cbdst, U32* pofsdst)

{

    ERR err = WMP_errSuccess;

    size_t offCurPos = 0;

    Bool GetPosOK = FALSE;

    U16 cDir;

    U16 i;

    U16 ofsEXIFIFDEntry = 0;

    U16 ofsGPSInfoIFDEntry = 0;

    U16 ofsInteroperabilityIFDEntry = 0;

    U32 ofsEXIFIFD = 0;

    U32 ofsGPSInfoIFD = 0;

    U32 ofsInteroperabilityIFD = 0;

    U32 ofsdstnextdata;

    U32 ofsdst = *pofsdst;

    U32 ofssrcdir;

    U32 ofsdstdir;

    U32 ofsnextifd;

    Call(pWS->GetPos(pWS, &offCurPos));

    GetPosOK = TRUE;

    Call(GetUShort(pWS, ofssrc, &cDir));

    Call(setbfw(pbdst, cbdst, ofsdst, cDir));

    ofsnextifd = ofsdst + sizeof(U16) + SizeofIFDEntry * cDir;

    ofsdstnextdata = ofsnextifd + sizeof(U32);

    ofssrcdir = ofssrc + sizeof(U16);

    ofsdstdir = ofsdst + sizeof(U16);

    for ( i = 0; i < cDir; i++ )

    {

        U16 tag = 0;

        U16 type = 0;

        U32 count = 0;

        U32 value = 0;

        U32 size = 0;

        Call(GetUShort(pWS, ofssrcdir, &tag));

        Call(setbfw(pbdst, cbdst, ofsdstdir, tag));

        Call(GetUShort(pWS, ofssrcdir + sizeof(U16), &type));

        Call(setbfw(pbdst, cbdst, ofsdstdir + sizeof(U16), type));

        Call(GetULong(pWS, ofssrcdir + 2 * sizeof(U16), &count));

        Call(setbfdw(pbdst, cbdst, ofsdstdir + 2 * sizeof(U16), count));

        Call(GetULong(pWS, ofssrcdir + 2 * sizeof(U16) + sizeof(U32), &value));

        Call(setbfdw(pbdst, cbdst, ofsdstdir + 2 * sizeof(U16) + sizeof(U32), 0));

        FailIf(type == 0 || type >= sizeof(IFDEntryTypeSizes) / sizeof(IFDEntryTypeSizes[0]), WMP_errFail);

        if ( tag == WMP_tagEXIFMetadata )

        {

            ofsEXIFIFDEntry = (U16) ofsdstdir;

            ofsEXIFIFD = value;

        }

        else if ( tag == WMP_tagGPSInfoMetadata )

        {

            ofsGPSInfoIFDEntry = (U16) ofsdstdir;

            ofsGPSInfoIFD = value;

        }

        else if ( tag == WMP_tagInteroperabilityIFD )

        {

            ofsInteroperabilityIFDEntry = (U16) ofsdstdir;

            ofsInteroperabilityIFD = value;

        }

        else

        {

            U32 ofsdstdata = ofsdstdir + 2 * sizeof(U16) + sizeof(U32);

            U32 ofssrcdata = ofssrcdir + 2 * sizeof(U16) + sizeof(U32);

            size = count * IFDEntryTypeSizes[type];

            if ( size > 4 )

            {

                ofssrcdata = value;

                Call(setbfdw(pbdst, cbdst, ofsdstdata, ofsdstnextdata));

                ofsdstdata = ofsdstnextdata;

                ofsdstnextdata += size;

            }

            FailIf(ofsdstdata + size > cbdst, WMP_errBufferOverflow);

            Call(pWS->SetPos(pWS, ofssrcdata));

            Call(pWS->Read(pWS, &pbdst[ofsdstdata], size));

        }

        ofssrcdir += SizeofIFDEntry;

        ofsdstdir += SizeofIFDEntry;

    }

    Call(setbfdw(pbdst, cbdst, ofsnextifd, 0));    // no nextIFD

    if ( ofsEXIFIFDEntry != 0 )

    {

        ofsdstnextdata += ( ofsdstnextdata & 1 );

        Call(setbfdw(pbdst, cbdst, ofsEXIFIFDEntry + 2 * sizeof(U16) + sizeof(U32), ofsdstnextdata));

        Call(StreamCopyIFD(pWS, ofsEXIFIFD, pbdst, cbdst, &ofsdstnextdata));

    }

    if ( ofsGPSInfoIFDEntry != 0 )

    {

        ofsdstnextdata += ( ofsdstnextdata & 1 );

        Call(setbfdw(pbdst, cbdst, ofsGPSInfoIFDEntry + 2 * sizeof(U16) + sizeof(U32), ofsdstnextdata));

        Call(StreamCopyIFD(pWS, ofsGPSInfoIFD, pbdst, cbdst, &ofsdstnextdata));

    }

    if ( ofsInteroperabilityIFDEntry != 0 )

    {

        ofsdstnextdata += ( ofsdstnextdata & 1 );

        Call(setbfdw(pbdst, cbdst, ofsInteroperabilityIFDEntry + 2 * sizeof(U16) + sizeof(U32), ofsdstnextdata));

        Call(StreamCopyIFD(pWS, ofsInteroperabilityIFD, pbdst, cbdst, &ofsdstnextdata));

    }

    *pofsdst = ofsdstnextdata;

Cleanup:

    if ( GetPosOK )

        Call(pWS->SetPos(pWS, offCurPos));

    return err;

}

//================================================================

ERR GetUShort(

    __in_ecount(1) struct WMPStream* pWS,

    size_t offPos,

    __out_ecount(1) U16* puValue)

{

    ERR err = WMP_errSuccess;

    U8  cVal;

    Call(pWS->SetPos(pWS, offPos));

    Call(pWS->Read(pWS, &cVal, sizeof(cVal)));

    puValue[0] = (U16) cVal;

    Call(pWS->Read(pWS, &cVal, sizeof(cVal)));

    puValue[0] += ((U16) cVal) << 8;

Cleanup:

    return err;

}

ERR PutUShort(

    __in_ecount(1) struct WMPStream* pWS,

    size_t offPos,

    U16 uValue)

{

    ERR err = WMP_errSuccess;

    U8  cVal = (U8) uValue;

    Call(pWS->SetPos(pWS, offPos));

    Call(pWS->Write(pWS, &cVal, sizeof(cVal)));

    cVal = (U8) (uValue >> 8);

    Call(pWS->Write(pWS, &cVal, sizeof(cVal)));

Cleanup:

    return err;

}

ERR GetULong(

    __in_ecount(1) struct WMPStream* pWS,

    size_t offPos,

    __out_ecount(1) U32* puValue)

{

    ERR err = WMP_errSuccess;

    U8  cVal = 0;

    Call(pWS->SetPos(pWS, offPos));

    Call(pWS->Read(pWS, &cVal, sizeof(cVal)));

    puValue[0] = (U32) cVal;

    Call(pWS->Read(pWS, &cVal, sizeof(cVal)));

    puValue[0] += ((U32) cVal) << 8;

    Call(pWS->Read(pWS, &cVal, sizeof(cVal)));

    puValue[0] += ((U32) cVal) << 16;

    Call(pWS->Read(pWS, &cVal, sizeof(cVal)));

    puValue[0] += ((U32) cVal) << 24;

Cleanup:

    return err;

}

ERR PutULong(

    __in_ecount(1) struct WMPStream* pWS,

    size_t offPos,

    U32 uValue)

{

    ERR err = WMP_errSuccess;

    U8  cVal = (U8) uValue;

    Call(pWS->SetPos(pWS, offPos));

    Call(pWS->Write(pWS, &cVal, sizeof(cVal)));

    cVal = (U8) (uValue >> 8);

    Call(pWS->Write(pWS, &cVal, sizeof(cVal)));

    cVal = (U8) (uValue >> 16);

    Call(pWS->Write(pWS, &cVal, sizeof(cVal)));

    cVal = (U8) (uValue >> 24);

    Call(pWS->Write(pWS, &cVal, sizeof(cVal)));

Cleanup:

    return err;

}

ERR ReadBinaryData(__in_ecount(1) struct WMPStream* pWS,

                   const __in_win U32 uCount,

                   const __in_win U32 uValue,

                   U8 **ppbData)

{

    ERR err = WMP_errSuccess;

    U8 *pbData = NULL;

    Call(PKAlloc((void **) &pbData, uCount + 2)); // Allocate buffer to store data with space for an added ascii or unicode null

    if (uCount <= 4)

    {

        unsigned int i;

        for (i = 0; i < uCount; i++)

            pbData[i] = ((U8*)&uValue)[i]; // Copy least sig bytes - we assume 'II' type TIFF files

    }

    else

    {

        size_t offPosPrev = 0;

        Call(pWS->GetPos(pWS, &offPosPrev));

        Call(pWS->SetPos(pWS, uValue));

        Call(pWS->Read(pWS, pbData, uCount));

        Call(pWS->SetPos(pWS, offPosPrev));

    }

    *ppbData = pbData;

Cleanup:

    if (Failed(err))

    {

        if (pbData)

            PKFree((void **) &pbData);

    }

    return err;

}

ERR ReadPropvar(__in_ecount(1) struct WMPStream* pWS,

                const __in_win U16 uType,

                const __in_win U32 uCount,

                const __in_win U32 uValue,

                __out_win DPKPROPVARIANT *pvar)

{

    ERR err = WMP_errSuccess;

    // U8 *pbData = NULL;

    memset(pvar, 0, sizeof(*pvar));

    if (uCount == 0)

        goto Cleanup; // Nothing to read in here

    switch (uType)

    {

        case WMP_typASCII:

            pvar->vt = DPKVT_LPSTR;

            Call(ReadBinaryData(pWS, uCount, uValue, (U8 **) &pvar->VT.pszVal));

            assert(0 == pvar->VT.pszVal[uCount - 1]); // Check that it's null-terminated

            // make sure (ReadBinaryData allocated uCount + 2 so this and unicode can have forced nulls)

            pvar->VT.pszVal[uCount] = 0;

            break;

        case WMP_typBYTE:

        case WMP_typUNDEFINED:

            // Return as regular C array rather than safearray, as this type is sometimes

            // used to convey unicode (which does not require a count field). Caller knows

            // uCount and can convert to safearray if necessary.

            pvar->vt = (DPKVT_BYREF | DPKVT_UI1);

            Call(ReadBinaryData(pWS, uCount, uValue, &pvar->VT.pbVal));

            break;

        case WMP_typSHORT:

            if (1 == uCount)

            {

                pvar->vt = DPKVT_UI2;

                pvar->VT.uiVal = (U16)(uValue & 0x0000FFFF);

            }

            else if (2 == uCount)

            {

                pvar->vt = DPKVT_UI4;

                pvar->VT.ulVal = uValue;

            }

            else

            {

                assert(FALSE); // NYI

                FailIf(TRUE, WMP_errNotYetImplemented);

            }

            break;

        default:

            assert(FALSE); // Unhandled type

            FailIf(TRUE, WMP_errNotYetImplemented);

            break;

    }

Cleanup:

    return err;

}

ERR WriteWmpDE(

    __in_ecount(1) struct WMPStream* pWS,

    size_t *pOffPos,

    const __in_ecount(1) WmpDE* pDE,

    const U8 *pbData,

    U32 *pcbDataWrittenToOffset)

{

    ERR err = WMP_errSuccess;

    size_t offPos = *pOffPos;

    assert(-1 != pDE->uCount);

    assert(-1 != pDE->uValueOrOffset);

    if (pcbDataWrittenToOffset)

    {

        assert(pbData); // Makes no sense to provide this arg without pbData

        *pcbDataWrittenToOffset = 0;

    }

    Call(PutUShort(pWS, offPos, pDE->uTag)); offPos += 2;

    Call(PutUShort(pWS, offPos, pDE->uType)); offPos += 2;

    Call(PutULong(pWS, offPos, pDE->uCount)); offPos += 4;

    switch (pDE->uType)

    {

        case WMP_typASCII:

        case WMP_typUNDEFINED:

        case WMP_typBYTE:

            if (pDE->uCount <= 4)

            {

                U8 pad[4] = {0};

                Call(pWS->SetPos(pWS, offPos));

                if (NULL == pbData)

                    pbData = (U8*)&pDE->uValueOrOffset;

                Call(pWS->Write(pWS, pbData, pDE->uCount));

                Call(pWS->Write(pWS, pad, 4 - pDE->uCount)); offPos += 4;

            }

            else

            {

                Call(PutULong(pWS, offPos, pDE->uValueOrOffset)); offPos += 4;

                // Write the data if requested to do so

                if (pbData)

                {

                    Call(pWS->SetPos(pWS, pDE->uValueOrOffset));

                    Call(pWS->Write(pWS, pbData, pDE->uCount));

                    Call(pWS->SetPos(pWS, offPos));

                    *pcbDataWrittenToOffset = pDE->uCount;

                }

            }

            break;

        case WMP_typSHORT:

            if (pDE->uCount <= 2)

            {

                U16 uiShrt1 = 0;

                U16 uiShrt2 = 0;

                if (NULL == pbData)

                    pbData = (U8*)&pDE->uValueOrOffset;

                if (pDE->uCount > 0)

                    uiShrt1 = *((U16*)pbData);

                if (pDE->uCount > 1)

                {

                    assert(FALSE); // Untested - remove this assert after this has been tested

                    uiShrt2 = *(U16*)(pbData + 2);

                }

                Call(PutUShort(pWS, offPos, uiShrt1)); offPos += 2;

                Call(PutUShort(pWS, offPos, uiShrt2)); offPos += 2;

            }

            else

            {

                assert(FALSE); // Untested - remove this assert after this has been tested

                Call(PutULong(pWS, offPos, pDE->uValueOrOffset)); offPos += 4;

                // Write the data if requested to do so

                if (pbData)

                {

                    U32 i;

                    Call(pWS->SetPos(pWS, pDE->uValueOrOffset));

                    for (i = 0; i < pDE->uCount; i++)

                    {

                        const U16 uiShort = *(U16*)(pbData + i*sizeof(U16));

                        Call(PutUShort(pWS, offPos, uiShort)); // Write one at a time for endian purposes - but inefficient

                    }

                    Call(pWS->SetPos(pWS, offPos));

                    *pcbDataWrittenToOffset = pDE->uCount * sizeof(U16);