TnbExifFile.h

[詳解]

#pragma once
#include "TnbGdiPlus.h"
#include "TnbBitmapHandle.h"
#include "TnbVector.h"
#include "TnbMap.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CExifFile : CCopyImpossible
{
public:
    struct TRational
    {
        DWORD   molecular;      
        DWORD   denominator;    
    };
    struct TSRational
    {
        long    molecular;      
        long    denominator;    
    };
 
    enum EType
    {
        ET_Byte         = PropertyTagTypeByte,      
        ET_Ascii        = PropertyTagTypeASCII,     
        ET_Short        = PropertyTagTypeShort,     
        ET_Long         = PropertyTagTypeLong,      
        ET_Rational     = PropertyTagTypeRational,  
        ET_Undefined    = PropertyTagTypeUndefined, 
        ET_SLong        = PropertyTagTypeSLONG,     
        ET_SRational    = PropertyTagTypeSRational, 
    };
 
    class CTagInfo
    {
    public:
        CTagInfo(void) : m_type(ET_Undefined), m_length(0)
        {
        }
        bool IsEmpty(void) const
        {
            return m_length == 0;
        }
        EType GetType(void) const
        {
            return m_type;
        }
        size_t GetLength(void) const
        {
            return m_length;
        }
        CVectorT<BYTE> GetByte(void) const
        {
            return m_Get(BYTE(), ET_Byte);
        }
        void SetByte(size_t len, const BYTE* P)
        {
            m_Set(len, P, ET_Byte);
        }
        void SetByte(BYTE b)
        {
            SetByte(1, &b);
        }
        LPCSTR GetAscii(void) const
        {
            LPCSTR P = NULL;
            if ( m_type == ET_Ascii )
            {
                P = reinterpret_cast<LPCSTR>(m_data.ReferBuffer());
            }
            return P;
        }
        void SetAscii(LPCSTR lpsz, size_t len = INVALID_SIZE)
        {
            if ( lpsz == NULL )
            {
                m_Set(0, lpsz, ET_Ascii);
            }
            else
            {
                if ( len == INVALID_SIZE )
                {
                    len = STRLIB::GetLen(lpsz) + 1;
                }
                ASSERT( ! ::IsBadReadPtr(lpsz, len) );
                m_Set(len, lpsz, ET_Ascii);
            }
        }
        CVectorT<WORD> GetShort(void) const
        {
            return m_Get(WORD(), ET_Short);
        }
        void SetShort(size_t len, const WORD* P)
        {
            m_Set(len, P, ET_Short);
        }
        void SetShort(WORD w)
        {
            SetShort(1, &w);
        }
        CVectorT<DWORD> GetLong(void) const
        {
            return m_Get(DWORD(), ET_Long);
        }
        void SetLong(size_t len, const DWORD* P)
        {
            m_Set(len, P, ET_Long);
        }
        void SetLong(DWORD d)
        {
            SetLong(1, &d);
        }
        CVectorT<TRational> GetRational(void) const
        {
            return m_Get(TRational(), ET_Rational);
        }
        void SetRational(size_t len, const TRational* P)
        {
            m_Set(len, P, ET_Rational);
        }
        void SetRational(DWORD d1, DWORD d2)
        {
            TRational r = { d1, d2 };
            SetRational(1, &r);
        }
        CByteVector GetUndefined(void) const
        {
            return m_Get(BYTE(), ET_Undefined);
        }
        void SetUndefined(size_t len, const BYTE* P)
        {
            m_Set(len, P, ET_Undefined);
        }
        CVectorT<long> GetSLong(void) const
        {
            return m_Get(long(), ET_SLong);
        }
        void SetSLong(size_t len, const long* P)
        {
            m_Set(len, P, ET_SLong);
        }
        void SetSLong(long l)
        {
            SetSLong(1, &l);
        }
        CVectorT<TSRational> GetSRational(void) const
        {
            return m_Get(TSRational(), ET_SRational);
        }
        void SetSRational(size_t len, const TSRational* P)
        {
            m_Set(len, P, ET_SRational);
        }
        void SetSRational(long d1, long d2)
        {
            TSRational r = { d1, d2 };
            SetSRational(1, &r);
        }
        bool Get(Gdiplus::PropertyItem& _pi)
        {
            if ( m_length != 0 )
            {
                _pi.type = static_cast<WORD>(m_type);
                _pi.length = ToDword(m_data.GetSize());
                _pi.value = m_data.GetBuffer();
                m_data.ReleaseBuffer();
                return true;
            }
            return false;
        }
        bool Set(const Gdiplus::PropertyItem& p)
        {
            switch ( p.type )
            {
            case ET_Byte: // 8ビット符号無し整数。
                SetByte(p.length, static_cast<const BYTE*>(p.value));
                break;
            case ET_Ascii: // ASCII文字列。
                SetAscii(static_cast<LPCSTR>(p.value));
                break;
            case ET_Short: // 16ビット符号無し整数。
                SetShort(p.length / sizeof(WORD), static_cast<const WORD*>(p.value));
                break;
            case ET_Long: // 32ビット符号無し整数。
                SetLong(p.length / sizeof(DWORD), static_cast<const DWORD*>(p.value));
                break;
            case ET_Rational: // 32ビット符号無し有理数（整数 2個。分子、分母）。
                SetRational(p.length / sizeof(TRational), static_cast<const TRational*>(p.value));
                break;
            case ET_Undefined: // 任意の 8bitデータ。
                SetUndefined(p.length, static_cast<const BYTE*>(p.value));
                break;
            case ET_SLong: // 32ビット符号付き整数。
                SetSLong(p.length / sizeof(long), static_cast<const long*>(p.value));
                break;
            case ET_SRational: // 32ビット符号付き有理数（整数 2個。分子、分母）。
                SetSRational(p.length / sizeof(TSRational), static_cast<const TSRational*>(p.value));
                break;
            default:
                return false;
            }
            return true;
        }
        CStr ToString(size_t mx = INVALID_SIZE) const
        {
            CStr s;
            size_t ln = min(mx, m_length);
            switch ( m_type )
            {
            case ET_Undefined: // 任意の 8bitデータ。
            case ET_Byte: // 8ビット符号無し整数。
                {
                    const BYTE* P = m_data.ReferBuffer();
                    loop ( i, ln )
                    {
                        s += CStr::Fmt(_T("%u "), P[i]);
                    }
                }
                break;
            case ET_Ascii: // ASCII文字列。
                s = reinterpret_cast<LPCSTR>(m_data.ReferBuffer());
                break;
            case ET_Short: // 16ビット符号無し整数。
                {
                    const WORD* P = reinterpret_cast<const WORD*>(m_data.ReferBuffer());
                    loop ( i, ln )
                    {
                        s += CStr::Fmt(_T("%u "), P[i]);
                    }
                }
                break;
            case ET_Long: // 32ビット符号無し整数。
                {
                    const DWORD* P = reinterpret_cast<const DWORD*>(m_data.ReferBuffer());
                    loop ( i, ln )
                    {
                        s += CStr::Fmt(_T("%u "), P[i]);
                    }
                }
                break;
            case ET_Rational: // 32ビット符号無し有理数（整数 2個。分子、分母）。
                {
                    const TRational* P = reinterpret_cast<const TRational*>(m_data.ReferBuffer());
                    loop ( i, ln )
                    {
                        s += CStr::Fmt(_T("%u/%u "), P[i].molecular, P[i].denominator);
                    }
                }
                break;
            case ET_SLong: // 32ビット符号付き整数。
                {
                    const long* P = reinterpret_cast<const long*>(m_data.ReferBuffer());
                    loop ( i, ln )
                    {
                        s += CStr::Fmt(_T("%d "), P[i]);
                    }
                }
                break;
            case ET_SRational: // 32ビット符号付き有理数（整数 2個。分子、分母）。
                {
                    const TSRational* P = reinterpret_cast<const TSRational*>(m_data.ReferBuffer());
                    loop ( i, ln )
                    {
                        s += CStr::Fmt(_T("%d/%d "), P[i].molecular, P[i].denominator);
                    }
                }
                break;
            default:
                break;
            }
            s += CStr::Fmt(_T("(l=%d)"), m_length);
            return s;
        }
    private:
        EType       m_type;     
        CByteVector m_data;     
        size_t      m_length;   
        // ゲッター
        template<typename T>
        CVectorT<T> m_Get(T dmy, EType t) const
        {
            CVectorT<T> r;
            if ( m_type == t )
            {
                ASSERT( m_data.GetSize() / sizeof(T) == m_length );
                r.SetElements(m_length, reinterpret_cast<const T*>(m_data.ReferBuffer()));
            }
            return r;
        }
        // セッター
        template<typename T>
        void m_Set(size_t len, T* P, EType t)
        {
            m_type = t;
            m_length = len;
            m_data.SetElements(len * sizeof(T), reinterpret_cast<const BYTE*>(P));
        }
    };
 
    typedef CMapT<PROPID, CTagInfo> CMapTagInfos;   
 
 
    //----
 
 
    CExifFile(void) : m_pBmp(NULL)
    {
    }
 
    ~CExifFile(void)
    {
        Empty();
    }
 
    void Empty(void)
    {
        if ( m_pBmp != NULL )
        {
            delete m_pBmp;
            m_pBmp = NULL;
        }
        m_tags.RemoveAll();
    }
 
    bool Attach(LPCWSTR lpszFileName)
    {
        CGdiPlus::Startup();
        Empty();
        m_pBmp = Gdiplus::Bitmap::FromFile(lpszFileName);
        if ( m_pBmp !=NULL && m_pBmp->GetLastStatus() == Gdiplus::Ok )
        {
            UINT cnt = m_pBmp->GetPropertyCount();
            CWorkMemT<PROPID> propIDs(cnt);
            m_pBmp->GetPropertyIdList(cnt, propIDs);
            loop( i, cnt )
            {
                PROPID id = propIDs[i];
                UINT size = m_pBmp->GetPropertyItemSize(id);
                if ( size > 0 )
                {
                    CWorkMem mem(size);
                    Gdiplus::PropertyItem* P = reinterpret_cast<Gdiplus::PropertyItem*>(mem.Ref());
                    m_pBmp->GetPropertyItem(id, size, P);
                    m_tags[id].Set(*P);
                }
            }
            return true;
        }
        Empty();
        return false;
    }
 
    bool Load(LPCWSTR lpszFileName)
    {
        if ( Attach(lpszFileName) )
        {
            if ( m_pBmp != NULL )
            {
                delete m_pBmp;
                m_pBmp = NULL;
            }
            HPALETTE hPal = NULL;
            CBitmapHandle b = CGdiPlus::LoadBitmap(lpszFileName);
            m_pBmp = Gdiplus::Bitmap::FromHBITMAP(b, hPal);
            if ( m_pBmp != NULL && m_pBmp->GetLastStatus() == Gdiplus::Ok )
            {
                return true;
            }
        }
        Empty();
        return false;
    }
 
    bool Load(HBITMAP hBmp, HPALETTE hPal = NULL)
    {
        CGdiPlus::Startup();
        Empty();
        m_pBmp = Gdiplus::Bitmap::FromHBITMAP(hBmp, hPal);
        if ( m_pBmp !=NULL && m_pBmp->GetLastStatus() == Gdiplus::Ok )
        {
            return true;
        }
        Empty();
        return false;
    }
 
    bool SaveJpeg(LPCWSTR lpsz, LONG jpegQuality = 80)
    {
        return Save(lpsz, CGdiPlus::JPG, jpegQuality);
    }
 
    bool Save(LPCWSTR lpsz, CGdiPlus::EBitmapFormat fmt = CGdiPlus::JPG, LONG jpegQuality = 80)
    {
        bool r = m_Save(lpsz, m_pBmp, fmt, jpegQuality);
        if ( ! r && m_pBmp != NULL )
        {
            TRACE0("Exif；画像再構築\n");
            Gdiplus::Color c;
            c.SetFromCOLORREF(RGB(0, 0, 0));
            HBITMAP hBmp = NULL;
            if ( m_pBmp->GetHBITMAP(c, &hBmp) == Gdiplus::Ok && hBmp != NULL )
            {
                HPALETTE h = NULL;
                Gdiplus::Bitmap bm(hBmp, h);
                r = m_Save(lpsz, &bm, fmt, jpegQuality);
                _DeleteObject(hBmp);
            }
        }
        return r;
    }
 
    const Gdiplus::Bitmap* ReferBitmap(void) const
    {
        return m_pBmp;
    }
 
    CBitmapHandle GetBitmap(void) const
    {
        CBitmapHandle b;
        if ( m_pBmp != NULL )
        {
            Gdiplus::Color c;
            c.SetFromCOLORREF(RGB(0, 0, 0));
            HBITMAP hBmp = NULL;
            if ( m_pBmp->GetHBITMAP(c, &hBmp) == Gdiplus::Ok && hBmp != NULL )
            {
                b = hBmp;
            }
        }
        return b;
    }
 
    const CMapTagInfos& GetTagInfoMap(void) const
    {
        #ifdef _DEBUG
            loop ( i, m_tags.GetSize() )
            {
                TRACE2("tag [%04X] = %s\n", m_tags.Get(i).first, m_tags.Get(i).second.ToString(16));
            }
        #endif
        return m_tags;
    }
    
    const CTagInfo* GetTagInfo(PROPID id) const
    {
        return m_tags.GetValuePtr(id);
    }
 
    CStr GetUserCommentTag(void) const
    {
        CStr s;
        const CTagInfo* P = GetTagInfo(PropertyTagExifUserComment);
        if ( P != NULL )
        {
            CByteVector vb = P->GetUndefined();
            if ( vb.GetSize() >= 8 )
            {
                vb.Add(0); //NULL終端追加
                vb.Add(0); //NULL終端追加
                LPCSTR lpsz = reinterpret_cast<LPCSTR>(vb.ReferBuffer());
                bool isUnicode = (STRLIB::Compare(lpsz, "UNICODE") == 0);
                if ( lpsz[0] == 0 && sizeof(TCHAR) == 2 )
                {
                    isUnicode = true;
                }
                if ( isUnicode )
                {
                    s = reinterpret_cast<LPCWSTR>(&lpsz[8]);
                }
                else
                {
                    s = &lpsz[8];
                }
            }
        }
        return s;
    }
 
    void GetCopyrightTag(CStr& _s1, CStr& _s2) const
    {
        _s1.Empty();
        _s2.Empty();
        const CTagInfo* P = GetTagInfo(PropertyTagCopyright);
        if ( P != NULL )
        {
            size_t len = P->GetLength();
            LPCSTR lpsz = P->GetAscii();
            _s1 = lpsz;
            if ( _s1.GetLength() + 1 < len && lpsz != NULL )
            {
                _s2 = &lpsz[_s1.GetLength() + 1];
            }
        }
    }
 
    void RemoveTagInfo(PROPID id)
    {
        m_tags.RemoveKey(id);
    }
    
    void SetTagInfo(PROPID id, const CTagInfo& ti)
    {
        m_tags[id] = ti;
    }
 
    void SetTagInfo(PROPID id, LPCSTR lpsz, size_t len = INVALID_SIZE)
    {
        m_tags[id].SetAscii(lpsz, len);
    }
 
    void SetTagInfo(PROPID id, const SYSTEMTIME& st)
    {
        char buf[64];//おおめ
        STRLIB::PrintF(buf, 64, "%04d:%02d:%02d %02d:%02d:%02d"
            , st.wYear, st.wMonth, st.wDay
            ,st.wHour, st.wMinute, st.wSecond);
        SetTagInfo(id, buf);
    }
 
    void SetVersionTag(DWORD ver = 0x0210)
    {
        CTagInfo ti;
        CAscii s;
        s.Format("%04X", ver);
        LPCSTR lpsz = s;
        ti.SetUndefined(4, reinterpret_cast<const BYTE*>(lpsz));
        SetTagInfo(PropertyTagExifVer, ti);
    }
 
    void SetUserCommentTag(LPCSTR lpsz)
    {
        size_t len = STRLIB::GetLen(lpsz);
        CWorkMemT<BYTE> mm(8 + len);
        if ( STRLIB::IsAsciiOnly(lpsz) )
        {
            const BYTE bb[8] = { 'A', 'S', 'C', 'I', 'I', 0, 0, 0 };
            TNB::MemCopy(&mm[0], bb, 8);
        }
        else
        {
            const BYTE bb[8] = { 'J', 'I', 'S', 0, 0, 0, 0, 0 };
            TNB::MemCopy(&mm[0], bb, 8);
        }
        TNB::MemCopy(&mm[8], lpsz, len);
        CTagInfo ti;
        ti.SetUndefined(8 + len, mm);
        SetTagInfo(PropertyTagExifUserComment, ti);
    }
 
    void SetUserCommentTag(LPCWSTR lpsz)
    {
        size_t len = STRLIB::GetLen(lpsz) * sizeof(WCHAR);
        CWorkMemT<BYTE> mm(8 + len);
        const BYTE bb[8] = { 'U', 'N', 'I', 'C', 'O', 'D', 'E', 0 };
        TNB::MemCopy(&mm[0], bb, 8);
        TNB::MemCopy(&mm[8], lpsz, len);
        CTagInfo ti;
        ti.SetUndefined(8 + len, mm);
        SetTagInfo(PropertyTagExifUserComment, ti);
    }
 
    void SetCopyrightTag(LPCSTR lpsz1, LPCSTR lpsz2 = NULL)
    {
        CAscii s2 = lpsz2;
        if ( s2.IsEmpty() )
        {
            SetTagInfo(PropertyTagCopyright, lpsz1);
        }
        else
        {
            CAscii s1 = lpsz1;
            if ( s1.IsEmpty() )
            {
                s1 = " ";
            }
            CWorkMemT<char> mm(s1.GetLength() + s2.GetLength() + 2);
            STRLIB::Copy(&mm[0], s1);
            STRLIB::Copy(&mm[s1.GetLength() + 1], s2);
            SetTagInfo(PropertyTagCopyright, &mm[0], mm.GetSize());
        }
    }
 
    void SetGpsVersionTag(void)
    {
        const BYTE a[4] = {2, 0, 0, 0};
        CTagInfo ti;
        ti.SetByte(4, a);
        SetTagInfo(PropertyTagGpsVer, ti);
    }
 
    void SetGpsLatitudeTag(bool isNorth, DWORD dd, DWORD mm, double ss)
    {
        SetGpsVersionTag();
        SetTagInfo(PropertyTagGpsLatitudeRef, isNorth ? "N" : "S");
        TRational r[3] = { dd, 1, mm, 1, static_cast<DWORD>(ss * 1000), 1000 };
        CTagInfo ti;
        ti.SetRational(3, r);
        SetTagInfo(PropertyTagGpsLatitude, ti);
    }
 
    void SetGpsLongitudeTag(bool isEast, DWORD dd, DWORD mm, double ss)
    {
        SetGpsVersionTag();
        SetTagInfo(PropertyTagGpsLongitudeRef, isEast ? "E" : "W");
        TRational r[3] = { dd, 1,  mm, 1,  static_cast<DWORD>(ss * 1000), 1000 };
        CTagInfo ti;
        ti.SetRational(3, r);
        SetTagInfo(PropertyTagGpsLongitude, ti);
    }
 
    void SetGpsAltitudeTag(DWORD d1, DWORD d2 = 1)
    {
        SetGpsVersionTag();
        CTagInfo ti;
        ti.SetByte(0);
        SetTagInfo(PropertyTagGpsAltitudeRef, ti);
        ti.SetRational(d1, d2);
        SetTagInfo(PropertyTagGpsAltitude, ti);
    }
 
private:
    // 画像ファイル作成.
    bool m_Save(LPCWSTR lpsz, Gdiplus::Bitmap* B, CGdiPlus::EBitmapFormat fmt = CGdiPlus::JPG, LONG jpegQuality = 80)
    {
        CGdiPlus::Startup();
        if ( B != NULL )
        {
            UINT cnt = B->GetPropertyCount();
            CWorkMemT<PROPID> propIDs(cnt);
            B->GetPropertyIdList(cnt, propIDs);
            loop( i, cnt )
            {
                PROPID id = propIDs[i];
                B->RemovePropertyItem(id);
            }
            Gdiplus::PropertyItem pi;
            loop ( i, m_tags.GetSize() )
            {
                pi.id = m_tags.Ref(i).first;
                if ( m_tags.Ref(i).second.Get(pi) )
                {
                    if ( B->SetPropertyItem(&pi) != Gdiplus::Ok )
                    {
                        return false;
                    }
                }
            }
            return CGdiPlus::SaveBitmap(lpsz, *B, fmt, jpegQuality);
        }
        return false;
    }
 
    Gdiplus::Bitmap*        m_pBmp; 
    CMapTagInfos            m_tags; 
};
 
 
 
}; // TNB