rfreeimage 0.1.0

data/vendor/FreeImage/Source/LibJXR/jxrgluelib/JXRMeta.c

@@ -0,0 +1,905 @@
+//*@@@+++@@@@******************************************************************
+//
+// 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;
+        U16 type;
+        U32 count;
+        U32 value;
+        U32 datasize;
+
+        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;
+        U16 type;
+        U32 count;
+        U32 value;
+        U32 datasize;
+
+        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;
+        U16 type;
+        U32 count;
+        U32 value;
+        U32 size;
+
+        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;
+        U16 type;
+        U32 count;
+        U32 value;
+        U32 size;
+
+        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;
+
+    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;
+
+        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);
+                }
+
+            }
+            break;
+
+        case WMP_typFLOAT:
+        case WMP_typLONG:
+            if (pDE->uCount <= 1)
+            {
+                if (NULL == pbData)
+                    pbData = (U8*)&pDE->uValueOrOffset;
+
+                Call(PutULong(pWS, offPos, *(U32*)pbData)); offPos += 4;
+            }
+            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 U32 uLong = *(U32*)(pbData + i*sizeof(U32));
+                        Call(PutULong(pWS, offPos, uLong)); // Write one at a time for endian purposes - but inefficient
+                    }
+                    Call(pWS->SetPos(pWS, offPos));
+                    *pcbDataWrittenToOffset = pDE->uCount * sizeof(U32);
+                }
+            }
+            break;
+
+        default:
+            assert(FALSE); // Alert the programmer
+            Call(WMP_errInvalidParameter);
+            break;
+    }
+
+Cleanup:
+    *pOffPos = offPos;
+    return err;
+}
+