projects/activex/persiststreaminit.cpp

   1 /*****************************************************************************
   2  * persiststreaminit.cpp: ActiveX control for VLC
   3  *****************************************************************************
   4  * Copyright (C) 2005 the VideoLAN team
   5  *
   6  * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  21  *****************************************************************************/
  22
  23 #include "plugin.h"
  24 #include "persiststreaminit.h"
  25
  26 #include "utils.h"
  27 #include <map>
  28
  29 #include <malloc.h>
  30 #include <wchar.h>
  31
  32 using namespace std;
  33
  34 class AxVLCVariant
  35 {
  36
  37 public:
  38
  39     AxVLCVariant(void)
  40     {
  41         VariantInit(&_v);
  42     };
  43
  44     ~AxVLCVariant(void)
  45     {
  46         VariantClear(&_v);
  47     }
  48
  49     AxVLCVariant(VARIANTARG &v)
  50     {
  51         VariantInit(&_v);
  52         VariantCopy(&_v, &v);
  53     };
  54
  55     AxVLCVariant(VARIANTARG *v)
  56     {
  57         VariantInit(&_v);
  58         VariantCopy(&_v, v);
  59     };
  60
  61     AxVLCVariant(const AxVLCVariant &vv)
  62     {
  63         VariantInit(&_v);
  64         VariantCopy(&_v, const_cast<VARIANTARG *>(&(vv._v)));
  65     };
  66
  67     AxVLCVariant(int i)
  68     {
  69         V_VT(&_v) = VT_I4;
  70         V_I4(&_v) = i;
  71     };
  72
  73     AxVLCVariant(BSTR bstr)
  74     {
  75         VARIANT arg;
  76         V_VT(&arg) = VT_BSTR;
  77         V_BSTR(&arg) = bstr;
  78         VariantInit(&_v);
  79         VariantCopy(&_v, &arg);
  80     };
  81
  82     inline const VARIANTARG *variantArg(void) const {
  83         return &_v;
  84     }
  85
  86     inline void swap(AxVLCVariant &v1, AxVLCVariant &v2)
  87     {
  88         VARIANTARG tmp = v1._v;
  89         v1._v = v2._v;
  90         v2._v = tmp;
  91     };
  92
  93 private:
  94
  95     VARIANTARG _v;
  96 };
  97
  98 class AxVLCWSTR
  99 {
 100
 101 public:
 102
 103     AxVLCWSTR(void) : _data(NULL) {};
 104
 105     virtual ~AxVLCWSTR()
 106     {
 107         if( NULL != _data )
 108         {
 109             ULONG refcount = InterlockedDecrement(&(_data->refcount));
 110             if( 0 == refcount )
 111                 CoTaskMemFree(_data);
 112         }
 113     };
 114
 115     AxVLCWSTR(LPCWSTR s)
 116     {
 117         if( NULL != s )
 118         {
 119             size_t len = wcslen(s);
 120             if( len > 0 )
 121             {
 122                 size_t size = len*sizeof(WCHAR);
 123                 _data = (struct data *)CoTaskMemAlloc(sizeof(struct data)+size);
 124                 if( NULL != _data )
 125                 {
 126                     _data->len = len;
 127                     _data->refcount = 1;
 128                     memcpy(_data->wstr, s, size);
 129                     _data->wstr[len]=L'\0';
 130                     return;
 131                 }
 132             }
 133         }
 134         _data = NULL;
 135     };
 136
 137     AxVLCWSTR(const AxVLCWSTR &s)
 138     {
 139         _data = s._data;
 140         if( NULL != _data )
 141             InterlockedIncrement(&(_data->refcount));
 142     };
 143
 144     inline bool operator<(const AxVLCWSTR &s) const
 145     {
 146         return compareNoCase(s.wstr()) < 0;
 147     };
 148
 149     inline bool operator<(LPCWSTR s) const
 150     {
 151         return compareNoCase(s) < 0;
 152     };
 153
 154     inline bool operator==(const AxVLCWSTR &s) const
 155     {
 156         return size() == s.size() ?
 157                     (compareNoCase(s.wstr()) == 0) : false;
 158     };
 159
 160     inline bool operator==(LPCWSTR s) const
 161     {
 162         return compareNoCase(s) == 0;
 163     };
 164
 165     LPCWSTR wstr(void) const
 166     {
 167         return (NULL != _data) ? _data->wstr : NULL;
 168     };
 169
 170     size_t size(void) const
 171     {
 172         return (NULL != _data) ? _data->len : 0;
 173     };
 174
 175 private:
 176
 177     inline int compareNoCase(LPCWSTR s) const
 178     {
 179         if( NULL == _data )
 180         {
 181             return (NULL == s) ? 0 : -1;
 182         }
 183         if( NULL == s )
 184             return 1;
 185
 186         return _wcsicmp(_data->wstr, s);
 187     };
 188
 189     struct data {
 190         size_t  len;
 191         LONG    refcount;
 192         wchar_t wstr[1];
 193     } *_data;
 194 };
 195
 196 typedef pair<class AxVLCWSTR, class AxVLCVariant> AxVLCPropertyPair;
 197 typedef map<class AxVLCWSTR, class AxVLCVariant> AxVLCPropertyMap;
 198
 199 ///////////////////////////
 200
 201 class VLCPropertyBag : public IPropertyBag
 202 {
 203
 204 public:
 205
 206     VLCPropertyBag(void) : _i_ref(1) {};
 207     virtual ~VLCPropertyBag() {};
 208
 209     // IUnknown methods
 210     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 211     {
 212         if( NULL == ppv )
 213             return E_POINTER;
 214         if( (IID_IUnknown == riid)
 215          || (IID_IPropertyBag == riid) )
 216         {
 217             AddRef();
 218             *ppv = reinterpret_cast<LPVOID>(this);
 219             return NOERROR;
 220         }
 221         // standalone object
 222         return E_NOINTERFACE;
 223     };
 224
 225     STDMETHODIMP_(ULONG) AddRef(void)
 226         { return InterlockedIncrement(&_i_ref); };
 227
 228     STDMETHODIMP_(ULONG) Release(void)
 229     {
 230         ULONG refcount = InterlockedDecrement(&_i_ref);
 231         if( 0 == refcount )
 232         {
 233             delete this;
 234             return 0;
 235         }
 236         return refcount;
 237     };
 238
 239     // IPropertyBag methods
 240
 241     STDMETHODIMP Read(LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog)
 242     {
 243         if( (NULL == pszPropName) || (NULL == pVar) )
 244             return E_POINTER;
 245
 246         AxVLCPropertyMap::const_iterator notfound = _pm.end();
 247         AxVLCPropertyMap::const_iterator iter = _pm.find(pszPropName);
 248         if( notfound != iter )
 249         {
 250             VARTYPE vtype = V_VT(pVar);
 251             VARIANTARG v;
 252             VariantInit(&v);
 253             VariantCopy(&v, const_cast<VARIANTARG*>((*iter).second.variantArg()));
 254             if( (V_VT(&v) != vtype) && FAILED(VariantChangeType(&v, &v, 0, vtype)) )
 255             {
 256                 VariantClear(&v);
 257                 return E_FAIL;
 258             }
 259             *pVar = v;
 260             return S_OK;
 261         }
 262         else
 263             return E_INVALIDARG;
 264     };
 265
 266     STDMETHODIMP Write(LPCOLESTR pszPropName, VARIANT *pVar)
 267     {
 268         if( (NULL == pszPropName) || (NULL == pVar) )
 269             return E_POINTER;
 270
 271         AxVLCPropertyPair val(pszPropName, pVar);
 272         pair<AxVLCPropertyMap::iterator, bool> p = _pm.insert(val);
 273         if( false == p.second )
 274             // replace existing key value
 275             (*p.first).second = val.second;
 276         return S_OK;
 277     };
 278
 279     // custom methods
 280
 281     HRESULT Load(LPSTREAM pStm)
 282     {
 283         if( NULL == pStm )
 284             return E_INVALIDARG;
 285
 286         HRESULT result;
 287
 288         AxVLCPropertyPair *val;
 289         result = ReadProperty(pStm, &val);
 290         if( SUCCEEDED(result) )
 291         {
 292             if( (val->first == L"(Count)") && (VT_I4 == V_VT(val->second.variantArg())) )
 293             {
 294                 size_t count = V_I4(val->second.variantArg());
 295                 delete val;
 296                 while( count-- )
 297                 {
 298                     result = ReadProperty(pStm, &val);
 299                     if( FAILED(result) )
 300                         return result;
 301
 302                     pair<AxVLCPropertyMap::iterator, bool> p = _pm.insert(*val);
 303                     if( false == p.second )
 304                         // replace existing key value
 305                         (*p.first).second = val->second;
 306                     delete val;
 307                 }
 308             }
 309         }
 310         return result;
 311     };
 312
 313     HRESULT Save(LPSTREAM pStm)
 314     {
 315         if( NULL == pStm )
 316             return E_INVALIDARG;
 317
 318         HRESULT result;
 319
 320         AxVLCPropertyPair header(L"(Count)", _pm.size());
 321         result = WriteProperty(pStm, header);
 322         if( SUCCEEDED(result) )
 323         {
 324             AxVLCPropertyMap::const_iterator iter = _pm.begin();
 325             AxVLCPropertyMap::const_iterator end  = _pm.end();
 326
 327             while( iter != end )
 328             {
 329                 result = WriteProperty(pStm, *(iter++));
 330                 if( FAILED(result) )
 331                     return result;
 332             }
 333         }
 334         return result;
 335     };
 336
 337     BOOL IsEmpty()
 338     {
 339         return _pm.size() == 0;
 340     }
 341
 342 private:
 343
 344     HRESULT WriteProperty(LPSTREAM pStm, const AxVLCPropertyPair &prop)
 345     {
 346         HRESULT result;
 347
 348         const AxVLCWSTR propName = prop.first;
 349
 350         ULONG len = propName.size();
 351
 352         if( 0 == len )
 353             return E_INVALIDARG;
 354
 355         result = pStm->Write(&len, sizeof(len), NULL);
 356         if( FAILED(result) )
 357             return result;
 358
 359         result = pStm->Write(propName.wstr(), len*sizeof(WCHAR), NULL);
 360         if( FAILED(result) )
 361             return result;
 362
 363         const VARIANTARG *propValue = prop.second.variantArg();
 364         VARTYPE vtype = V_VT(propValue);
 365         switch( vtype )
 366         {
 367             case VT_BOOL:
 368                 result = pStm->Write(&vtype, sizeof(vtype), NULL);
 369                 if( FAILED(result) )
 370                     return result;
 371                 result = pStm->Write(&V_BOOL(propValue), sizeof(V_BOOL(propValue)), NULL);
 372                 if( FAILED(result) )
 373                     return result;
 374                 break;
 375             case VT_I4:
 376                 result = pStm->Write(&vtype, sizeof(vtype), NULL);
 377                 if( FAILED(result) )
 378                     return result;
 379                 result = pStm->Write(&V_I4(propValue), sizeof(V_I4(propValue)), NULL);
 380                 if( FAILED(result) )
 381                     return result;
 382                 break;
 383             case VT_BSTR:
 384                 result = pStm->Write(&vtype, sizeof(vtype), NULL);
 385                 if( FAILED(result) )
 386                     return result;
 387                 len = SysStringLen(V_BSTR(propValue));
 388                 result = pStm->Write(&len, sizeof(len), NULL);
 389                 if( FAILED(result) )
 390                     return result;
 391                 if( len > 0 )
 392                 {
 393                     result = pStm->Write(V_BSTR(propValue), len*sizeof(OLECHAR), NULL);
 394                     if( FAILED(result) )
 395                         return result;
 396                 }
 397                 break;
 398             default:
 399                 vtype = VT_EMPTY;
 400                 result = pStm->Write(&vtype, sizeof(vtype), NULL);
 401                 if( FAILED(result) )
 402                     return result;
 403         }
 404         return result;
 405     };
 406
 407     HRESULT ReadProperty(LPSTREAM pStm, AxVLCPropertyPair **prop)
 408     {
 409         HRESULT result;
 410
 411         ULONG len;
 412
 413         result = pStm->Read(&len, sizeof(len), NULL);
 414         if( FAILED(result) )
 415             return result;
 416
 417         if( 0 == len )
 418             return E_INVALIDARG;
 419
 420         LPWSTR propName = (LPOLESTR)::alloca((len+1)*sizeof(WCHAR));
 421         if( NULL == propName )
 422             return E_OUTOFMEMORY;
 423
 424         result = pStm->Read(propName, len*sizeof(WCHAR), NULL);
 425         if( FAILED(result) )
 426             return result;
 427
 428         propName[len] = L'\0';
 429
 430         VARIANTARG propValue;
 431
 432         VARTYPE vtype;
 433         result = pStm->Read(&vtype, sizeof(vtype), NULL);
 434         if( FAILED(result) )
 435             return result;
 436
 437         switch( vtype )
 438         {
 439             case VT_BOOL:
 440                 V_VT(&propValue) = vtype;
 441                 result = pStm->Read(&V_BOOL(&propValue), sizeof(V_BOOL(&propValue)), NULL);
 442                 if( FAILED(result) )
 443                     return result;
 444                 break;
 445             case VT_I4:
 446                 V_VT(&propValue) = vtype;
 447                 result = pStm->Read(&V_I4(&propValue), sizeof(V_I4(&propValue)), NULL);
 448                 if( FAILED(result) )
 449                     return result;
 450                 break;
 451             case VT_BSTR:
 452                 V_VT(&propValue) = vtype;
 453                 result = pStm->Read(&len, sizeof(len), NULL);
 454                 if( FAILED(result) )
 455                     return result;
 456
 457                 V_BSTR(&propValue) = NULL;
 458                 if( len > 0 )
 459                 {
 460                     V_BSTR(&propValue) = SysAllocStringLen(NULL, len);
 461                     if( NULL == V_BSTR(&propValue) )
 462                         return E_OUTOFMEMORY;
 463
 464                     result = pStm->Read(V_BSTR(&propValue), len*sizeof(OLECHAR), NULL);
 465                     if( FAILED(result) )
 466                     {
 467                         SysFreeString(V_BSTR(&propValue));
 468                         return result;
 469                     }
 470                 }
 471                 break;
 472             default:
 473                 VariantInit(&propValue);
 474         }
 475
 476         *prop = new AxVLCPropertyPair(propName, propValue);
 477
 478         return S_OK;
 479     };
 480
 481     AxVLCPropertyMap _pm;
 482     LONG _i_ref;
 483 };
 484
 485 ///////////////////////////
 486
 487 VLCPersistStreamInit::VLCPersistStreamInit(VLCPlugin *p_instance) : _p_instance(p_instance)
 488 {
 489     _p_props = new VLCPropertyBag();
 490 };
 491
 492 VLCPersistStreamInit::~VLCPersistStreamInit()
 493 {
 494     _p_props->Release();
 495 };
 496
 497 STDMETHODIMP VLCPersistStreamInit::GetClassID(LPCLSID pClsID)
 498 {
 499     if( NULL == pClsID )
 500         return E_POINTER;
 501
 502     *pClsID = _p_instance->getClassID();
 503
 504     return S_OK;
 505 };
 506
 507 STDMETHODIMP VLCPersistStreamInit::InitNew(void)
 508 {
 509     return _p_instance->onInit();
 510 };
 511
 512 STDMETHODIMP VLCPersistStreamInit::Load(LPSTREAM pStm)
 513 {
 514     HRESULT result = _p_props->Load(pStm);
 515     if( FAILED(result) )
 516         return result;
 517
 518     LPPERSISTPROPERTYBAG pPersistPropBag;
 519     if( FAILED(QueryInterface(IID_IPersistPropertyBag, (void**)&pPersistPropBag)) )
 520         return E_FAIL;
 521
 522     result = pPersistPropBag->Load(_p_props, NULL);
 523     pPersistPropBag->Release();
 524
 525     return result;
 526 };
 527
 528 STDMETHODIMP VLCPersistStreamInit::Save(LPSTREAM pStm, BOOL fClearDirty)
 529 {
 530     if( NULL == pStm )
 531         return E_INVALIDARG;
 532
 533     LPPERSISTPROPERTYBAG pPersistPropBag;
 534     if( FAILED(QueryInterface(IID_IPersistPropertyBag, (void**)&pPersistPropBag)) )
 535         return E_FAIL;
 536
 537     HRESULT result = pPersistPropBag->Save(_p_props, fClearDirty, _p_props->IsEmpty());
 538     pPersistPropBag->Release();
 539     if( FAILED(result) )
 540         return result;
 541
 542     return _p_props->Save(pStm);
 543 };
 544
 545 STDMETHODIMP VLCPersistStreamInit::IsDirty(void)
 546 {
 547     return _p_instance->isDirty() ? S_OK : S_FALSE;
 548 };
 549
 550 STDMETHODIMP VLCPersistStreamInit::GetSizeMax(ULARGE_INTEGER *pcbSize)
 551 {
 552     pcbSize->HighPart = 0UL;
 553     pcbSize->LowPart  = 16384UL; // just a guess
 554
 555     return S_OK;
 556 };
 557