587 lines
17 KiB
C++
587 lines
17 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* This file is part of the LibreOffice project.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* This file incorporates work covered by the following license notice:
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed
|
|
* with this work for additional information regarding copyright
|
|
* ownership. The ASF licenses this file to you under the Apache
|
|
* License, Version 2.0 (the "License"); you may not use this file
|
|
* except in compliance with the License. You may obtain a copy of
|
|
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
|
|
*/
|
|
|
|
#include <avmedia/mediaitem.hxx>
|
|
|
|
#include <com/sun/star/uno/Sequence.hxx>
|
|
|
|
#include <com/sun/star/beans/XPropertySet.hpp>
|
|
#include <com/sun/star/embed/ElementModes.hpp>
|
|
#include <com/sun/star/embed/XTransactedObject.hpp>
|
|
#include <com/sun/star/frame/XModel.hpp>
|
|
#include <com/sun/star/document/XStorageBasedDocument.hpp>
|
|
#include <com/sun/star/ucb/XCommandEnvironment.hpp>
|
|
#include <com/sun/star/uri/UriReferenceFactory.hpp>
|
|
#include <com/sun/star/uri/XUriReference.hpp>
|
|
#include <com/sun/star/uri/XUriReferenceFactory.hpp>
|
|
#include <com/sun/star/text/GraphicCrop.hpp>
|
|
|
|
#include <sal/log.hxx>
|
|
|
|
#include <ucbhelper/content.hxx>
|
|
|
|
#include <comphelper/mediamimetype.hxx>
|
|
#include <comphelper/processfactory.hxx>
|
|
#include <comphelper/storagehelper.hxx>
|
|
#include <mediamisc.hxx>
|
|
#include <osl/file.hxx>
|
|
#include <comphelper/diagnose_ex.hxx>
|
|
#include <vcl/graph.hxx>
|
|
|
|
using namespace ::com::sun::star;
|
|
|
|
namespace avmedia
|
|
{
|
|
|
|
SfxPoolItem* MediaItem::CreateDefault() { return new MediaItem; }
|
|
|
|
struct MediaItem::Impl
|
|
{
|
|
OUString m_URL;
|
|
OUString m_TempFileURL;
|
|
OUString m_FallbackURL;
|
|
OUString m_Referer;
|
|
OUString m_sMimeType;
|
|
AVMediaSetMask m_nMaskSet;
|
|
MediaState m_eState;
|
|
double m_fTime;
|
|
double m_fDuration;
|
|
sal_Int16 m_nVolumeDB;
|
|
bool m_bLoop;
|
|
bool m_bMute;
|
|
css::media::ZoomLevel m_eZoom;
|
|
Graphic m_aGraphic;
|
|
text::GraphicCrop m_aCrop;
|
|
|
|
explicit Impl(AVMediaSetMask nMaskSet)
|
|
: m_nMaskSet( nMaskSet )
|
|
, m_eState( MediaState::Stop )
|
|
, m_fTime( 0.0 )
|
|
, m_fDuration( 0.0 )
|
|
, m_nVolumeDB( 0 )
|
|
, m_bLoop( false )
|
|
, m_bMute( false )
|
|
, m_eZoom( css::media::ZoomLevel_NOT_AVAILABLE )
|
|
{
|
|
}
|
|
};
|
|
|
|
|
|
MediaItem::MediaItem( sal_uInt16 i_nWhich, AVMediaSetMask nMaskSet )
|
|
: SfxPoolItem( i_nWhich )
|
|
, m_pImpl( new Impl(nMaskSet) )
|
|
{
|
|
}
|
|
|
|
|
|
MediaItem::MediaItem( const MediaItem& rItem )
|
|
: SfxPoolItem( rItem )
|
|
, m_pImpl( new Impl(*rItem.m_pImpl) )
|
|
{
|
|
}
|
|
|
|
|
|
MediaItem::~MediaItem()
|
|
{
|
|
}
|
|
|
|
|
|
bool MediaItem::operator==( const SfxPoolItem& rItem ) const
|
|
{
|
|
assert( SfxPoolItem::operator==(rItem));
|
|
MediaItem const& rOther(static_cast< const MediaItem& >(rItem));
|
|
return m_pImpl->m_nMaskSet == rOther.m_pImpl->m_nMaskSet
|
|
&& m_pImpl->m_URL == rOther.m_pImpl->m_URL
|
|
&& m_pImpl->m_FallbackURL == rOther.m_pImpl->m_FallbackURL
|
|
&& m_pImpl->m_Referer == rOther.m_pImpl->m_Referer
|
|
&& m_pImpl->m_sMimeType == rOther.m_pImpl->m_sMimeType
|
|
&& m_pImpl->m_aGraphic == rOther.m_pImpl->m_aGraphic
|
|
&& m_pImpl->m_aCrop == rOther.m_pImpl->m_aCrop
|
|
&& m_pImpl->m_eState == rOther.m_pImpl->m_eState
|
|
&& m_pImpl->m_fDuration == rOther.m_pImpl->m_fDuration
|
|
&& m_pImpl->m_fTime == rOther.m_pImpl->m_fTime
|
|
&& m_pImpl->m_nVolumeDB == rOther.m_pImpl->m_nVolumeDB
|
|
&& m_pImpl->m_bLoop == rOther.m_pImpl->m_bLoop
|
|
&& m_pImpl->m_bMute == rOther.m_pImpl->m_bMute
|
|
&& m_pImpl->m_eZoom == rOther.m_pImpl->m_eZoom;
|
|
}
|
|
|
|
MediaItem* MediaItem::Clone( SfxItemPool* ) const
|
|
{
|
|
return new MediaItem( *this );
|
|
}
|
|
|
|
bool MediaItem::GetPresentation( SfxItemPresentation,
|
|
MapUnit,
|
|
MapUnit,
|
|
OUString& rText,
|
|
const IntlWrapper& ) const
|
|
{
|
|
rText.clear();
|
|
return false;
|
|
}
|
|
|
|
bool MediaItem::QueryValue( css::uno::Any& rVal, sal_uInt8 ) const
|
|
{
|
|
uno::Sequence< uno::Any > aSeq{ uno::Any(m_pImpl->m_URL),
|
|
uno::Any(static_cast<sal_uInt32>(m_pImpl->m_nMaskSet)),
|
|
uno::Any(static_cast< sal_Int32 >( m_pImpl->m_eState )),
|
|
uno::Any(m_pImpl->m_fTime),
|
|
uno::Any(m_pImpl->m_fDuration),
|
|
uno::Any(m_pImpl->m_nVolumeDB),
|
|
uno::Any(m_pImpl->m_bLoop),
|
|
uno::Any(m_pImpl->m_bMute),
|
|
uno::Any(m_pImpl->m_eZoom),
|
|
uno::Any(m_pImpl->m_sMimeType) };
|
|
|
|
rVal <<= aSeq;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool MediaItem::PutValue( const css::uno::Any& rVal, sal_uInt8 )
|
|
{
|
|
uno::Sequence< uno::Any > aSeq;
|
|
bool bRet = false;
|
|
|
|
if( ( rVal >>= aSeq ) && ( aSeq.getLength() == 10 ) )
|
|
{
|
|
sal_Int32 nInt32 = 0;
|
|
|
|
aSeq[ 0 ] >>= m_pImpl->m_URL;
|
|
aSeq[ 1 ] >>= nInt32;
|
|
m_pImpl->m_nMaskSet = static_cast<AVMediaSetMask>(nInt32);
|
|
aSeq[ 2 ] >>= nInt32;
|
|
m_pImpl->m_eState = static_cast< MediaState >( nInt32 );
|
|
aSeq[ 3 ] >>= m_pImpl->m_fTime;
|
|
aSeq[ 4 ] >>= m_pImpl->m_fDuration;
|
|
aSeq[ 5 ] >>= m_pImpl->m_nVolumeDB;
|
|
aSeq[ 6 ] >>= m_pImpl->m_bLoop;
|
|
aSeq[ 7 ] >>= m_pImpl->m_bMute;
|
|
aSeq[ 8 ] >>= m_pImpl->m_eZoom;
|
|
aSeq[ 9 ] >>= m_pImpl->m_sMimeType;
|
|
|
|
bRet = true;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
bool MediaItem::merge(const MediaItem& rMediaItem)
|
|
{
|
|
bool bChanged = false;
|
|
|
|
const AVMediaSetMask nMaskSet = rMediaItem.getMaskSet();
|
|
|
|
if( AVMediaSetMask::URL & nMaskSet )
|
|
{
|
|
bChanged = m_pImpl->m_FallbackURL == rMediaItem.getFallbackURL();
|
|
m_pImpl->m_FallbackURL = rMediaItem.getFallbackURL();
|
|
bChanged |= setURL(rMediaItem.getURL(), rMediaItem.getTempURL(), rMediaItem.getReferer());
|
|
}
|
|
|
|
if( AVMediaSetMask::MIME_TYPE & nMaskSet )
|
|
bChanged |= setMimeType(rMediaItem.getMimeType());
|
|
|
|
if (nMaskSet & AVMediaSetMask::GRAPHIC)
|
|
bChanged |= setGraphic(rMediaItem.getGraphic());
|
|
|
|
if (nMaskSet & AVMediaSetMask::CROP)
|
|
bChanged |= setCrop(rMediaItem.getCrop());
|
|
|
|
if( AVMediaSetMask::STATE & nMaskSet )
|
|
bChanged |= setState( rMediaItem.getState() );
|
|
|
|
if( AVMediaSetMask::DURATION & nMaskSet )
|
|
bChanged |= setDuration(rMediaItem.getDuration());
|
|
|
|
if( AVMediaSetMask::TIME & nMaskSet )
|
|
bChanged |= setTime(rMediaItem.getTime());
|
|
|
|
if( AVMediaSetMask::LOOP & nMaskSet )
|
|
bChanged |= setLoop(rMediaItem.isLoop());
|
|
|
|
if( AVMediaSetMask::MUTE & nMaskSet )
|
|
bChanged |= setMute(rMediaItem.isMute());
|
|
|
|
if( AVMediaSetMask::VOLUMEDB & nMaskSet )
|
|
bChanged |= setVolumeDB(rMediaItem.getVolumeDB());
|
|
|
|
if( AVMediaSetMask::ZOOM & nMaskSet )
|
|
bChanged |= setZoom(rMediaItem.getZoom());
|
|
|
|
return bChanged;
|
|
}
|
|
|
|
AVMediaSetMask MediaItem::getMaskSet() const
|
|
{
|
|
return m_pImpl->m_nMaskSet;
|
|
}
|
|
|
|
bool MediaItem::setURL(const OUString& rURL, const OUString& rTempURL, const OUString& rReferer)
|
|
{
|
|
m_pImpl->m_nMaskSet |= AVMediaSetMask::URL;
|
|
bool bChanged = rURL != m_pImpl->m_URL || rTempURL != m_pImpl->m_TempFileURL || rReferer != m_pImpl->m_Referer;
|
|
if (bChanged)
|
|
{
|
|
m_pImpl->m_URL = rURL;
|
|
m_pImpl->m_TempFileURL = rTempURL;
|
|
m_pImpl->m_Referer = rReferer;
|
|
setMimeType(::comphelper::GuessMediaMimeType(GetFilename(rURL)));
|
|
}
|
|
return bChanged;
|
|
}
|
|
|
|
const OUString& MediaItem::getURL() const
|
|
{
|
|
return m_pImpl->m_URL;
|
|
}
|
|
|
|
bool MediaItem::setFallbackURL(const OUString& rURL)
|
|
{
|
|
bool bChanged = rURL != m_pImpl->m_FallbackURL;
|
|
if (bChanged)
|
|
m_pImpl->m_FallbackURL = rURL;
|
|
return bChanged;
|
|
}
|
|
const OUString& MediaItem::getFallbackURL() const
|
|
{
|
|
return m_pImpl->m_FallbackURL;
|
|
}
|
|
|
|
const OUString& MediaItem::getTempURL() const
|
|
{
|
|
return m_pImpl->m_TempFileURL;
|
|
}
|
|
|
|
const OUString& MediaItem::getReferer() const
|
|
{
|
|
return m_pImpl->m_Referer;
|
|
}
|
|
|
|
bool MediaItem::setMimeType(const OUString& rMimeType)
|
|
{
|
|
m_pImpl->m_nMaskSet |= AVMediaSetMask::MIME_TYPE;
|
|
bool bChanged = rMimeType != m_pImpl->m_sMimeType;
|
|
if (bChanged)
|
|
m_pImpl->m_sMimeType = rMimeType;
|
|
return bChanged;
|
|
}
|
|
|
|
const OUString & MediaItem::getMimeType() const
|
|
{
|
|
return !m_pImpl->m_sMimeType.isEmpty() ? m_pImpl->m_sMimeType : AVMEDIA_MIMETYPE_COMMON;
|
|
}
|
|
|
|
bool MediaItem::setGraphic(const Graphic& rGraphic)
|
|
{
|
|
m_pImpl->m_nMaskSet |= AVMediaSetMask::GRAPHIC;
|
|
bool bChanged = rGraphic != m_pImpl->m_aGraphic;
|
|
if (bChanged)
|
|
m_pImpl->m_aGraphic = rGraphic;
|
|
return bChanged;
|
|
}
|
|
|
|
const Graphic & MediaItem::getGraphic() const { return m_pImpl->m_aGraphic; }
|
|
|
|
bool MediaItem::setCrop(const text::GraphicCrop& rCrop)
|
|
{
|
|
m_pImpl->m_nMaskSet |= AVMediaSetMask::CROP;
|
|
bool bChanged = rCrop != m_pImpl->m_aCrop;
|
|
if (bChanged)
|
|
m_pImpl->m_aCrop = rCrop;
|
|
return bChanged;
|
|
}
|
|
|
|
const text::GraphicCrop& MediaItem::getCrop() const { return m_pImpl->m_aCrop; }
|
|
|
|
bool MediaItem::setState(MediaState eState)
|
|
{
|
|
m_pImpl->m_nMaskSet |= AVMediaSetMask::STATE;
|
|
bool bChanged = eState != m_pImpl->m_eState;
|
|
if (bChanged)
|
|
m_pImpl->m_eState = eState;
|
|
return bChanged;
|
|
}
|
|
|
|
MediaState MediaItem::getState() const
|
|
{
|
|
return m_pImpl->m_eState;
|
|
}
|
|
|
|
bool MediaItem::setDuration(double fDuration)
|
|
{
|
|
m_pImpl->m_nMaskSet |= AVMediaSetMask::DURATION;
|
|
bool bChanged = fDuration != m_pImpl->m_fDuration;
|
|
if (bChanged)
|
|
m_pImpl->m_fDuration = fDuration;
|
|
return bChanged;
|
|
}
|
|
|
|
double MediaItem::getDuration() const
|
|
{
|
|
return m_pImpl->m_fDuration;
|
|
}
|
|
|
|
bool MediaItem::setTime(double fTime)
|
|
{
|
|
m_pImpl->m_nMaskSet |= AVMediaSetMask::TIME;
|
|
bool bChanged = fTime != m_pImpl->m_fTime;
|
|
if (bChanged)
|
|
m_pImpl->m_fTime = fTime;
|
|
return bChanged;
|
|
}
|
|
|
|
double MediaItem::getTime() const
|
|
{
|
|
return m_pImpl->m_fTime;
|
|
}
|
|
|
|
bool MediaItem::setLoop(bool bLoop)
|
|
{
|
|
m_pImpl->m_nMaskSet |= AVMediaSetMask::LOOP;
|
|
bool bChanged = bLoop != m_pImpl->m_bLoop;
|
|
if (bChanged)
|
|
m_pImpl->m_bLoop = bLoop;
|
|
return bChanged;
|
|
}
|
|
|
|
bool MediaItem::isLoop() const
|
|
{
|
|
return m_pImpl->m_bLoop;
|
|
}
|
|
|
|
bool MediaItem::setMute(bool bMute)
|
|
{
|
|
m_pImpl->m_nMaskSet |= AVMediaSetMask::MUTE;
|
|
bool bChanged = bMute != m_pImpl->m_bMute;
|
|
if (bChanged)
|
|
m_pImpl->m_bMute = bMute;
|
|
return bChanged;
|
|
}
|
|
|
|
bool MediaItem::isMute() const
|
|
{
|
|
return m_pImpl->m_bMute;
|
|
}
|
|
|
|
bool MediaItem::setVolumeDB(sal_Int16 nDB)
|
|
{
|
|
m_pImpl->m_nMaskSet |= AVMediaSetMask::VOLUMEDB;
|
|
bool bChanged = nDB != m_pImpl->m_nVolumeDB;
|
|
if (bChanged)
|
|
m_pImpl->m_nVolumeDB = nDB;
|
|
return bChanged;
|
|
}
|
|
|
|
sal_Int16 MediaItem::getVolumeDB() const
|
|
{
|
|
return m_pImpl->m_nVolumeDB;
|
|
}
|
|
|
|
bool MediaItem::setZoom(css::media::ZoomLevel eZoom)
|
|
{
|
|
m_pImpl->m_nMaskSet |= AVMediaSetMask::ZOOM;
|
|
bool bChanged = eZoom != m_pImpl->m_eZoom;
|
|
if (bChanged)
|
|
m_pImpl->m_eZoom = eZoom;
|
|
return bChanged;
|
|
}
|
|
|
|
css::media::ZoomLevel MediaItem::getZoom() const
|
|
{
|
|
return m_pImpl->m_eZoom;
|
|
}
|
|
|
|
OUString GetFilename(OUString const& rSourceURL)
|
|
{
|
|
uno::Reference<uri::XUriReferenceFactory> const xUriFactory(
|
|
uri::UriReferenceFactory::create(
|
|
comphelper::getProcessComponentContext()));
|
|
uno::Reference<uri::XUriReference> const xSourceURI(
|
|
xUriFactory->parse(rSourceURL), uno::UNO_SET_THROW);
|
|
|
|
OUString filename;
|
|
{
|
|
sal_Int32 const nSegments(xSourceURI->getPathSegmentCount());
|
|
if (0 < nSegments)
|
|
{
|
|
filename = xSourceURI->getPathSegment(nSegments - 1);
|
|
}
|
|
}
|
|
if (!::comphelper::OStorageHelper::IsValidZipEntryFileName(
|
|
filename, false) || !filename.getLength())
|
|
{
|
|
filename = "media";
|
|
}
|
|
return filename;
|
|
}
|
|
|
|
|
|
uno::Reference<io::XStream>
|
|
CreateStream(uno::Reference<embed::XStorage> const& xStorage,
|
|
OUString const& rFilename)
|
|
{
|
|
OUString filename(rFilename);
|
|
|
|
if (xStorage->hasByName(filename))
|
|
{
|
|
std::u16string_view basename;
|
|
std::u16string_view suffix;
|
|
sal_Int32 const nIndex(rFilename.lastIndexOf('.'));
|
|
if (0 < nIndex)
|
|
{
|
|
basename = rFilename.subView(0, nIndex);
|
|
suffix = rFilename.subView(nIndex);
|
|
}
|
|
sal_Int32 count(0); // sigh... try to generate non-existent name
|
|
do
|
|
{
|
|
++count;
|
|
filename = basename + OUString::number(count) + suffix;
|
|
}
|
|
while (xStorage->hasByName(filename));
|
|
}
|
|
|
|
uno::Reference<io::XStream> const xStream(
|
|
xStorage->openStreamElement(filename,
|
|
embed::ElementModes::WRITE | embed::ElementModes::TRUNCATE),
|
|
uno::UNO_SET_THROW);
|
|
uno::Reference< beans::XPropertySet > const xStreamProps(xStream,
|
|
uno::UNO_QUERY);
|
|
if (xStreamProps.is()) { // this is NOT supported in FileSystemStorage
|
|
OUString const guessed(::comphelper::GuessMediaMimeType(filename));
|
|
xStreamProps->setPropertyValue(u"MediaType"_ustr,
|
|
uno::Any(guessed.isEmpty() ? AVMEDIA_MIMETYPE_COMMON : guessed));
|
|
xStreamProps->setPropertyValue( // turn off compression
|
|
u"Compressed"_ustr, uno::Any(false));
|
|
}
|
|
return xStream;
|
|
}
|
|
|
|
|
|
bool EmbedMedia(uno::Reference<frame::XModel> const& xModel,
|
|
OUString const& rSourceURL, OUString & o_rEmbeddedURL, uno::Reference<io::XInputStream> const& xInputStream)
|
|
{
|
|
try
|
|
{
|
|
uno::Reference<document::XStorageBasedDocument> const xSBD(xModel,
|
|
uno::UNO_QUERY_THROW);
|
|
uno::Reference<embed::XStorage> const xStorage(
|
|
xSBD->getDocumentStorage(), uno::UNO_SET_THROW);
|
|
|
|
static constexpr OUString media(u"Media"_ustr);
|
|
uno::Reference<embed::XStorage> const xSubStorage(
|
|
xStorage->openStorageElement(media, embed::ElementModes::WRITE));
|
|
|
|
OUString filename(GetFilename(rSourceURL));
|
|
|
|
uno::Reference<io::XStream> const xStream(
|
|
CreateStream(xSubStorage, filename), uno::UNO_SET_THROW);
|
|
uno::Reference<io::XOutputStream> const xOutStream(
|
|
xStream->getOutputStream(), uno::UNO_SET_THROW);
|
|
|
|
if (xInputStream.is())
|
|
{
|
|
// Throw Exception if failed.
|
|
::comphelper::OStorageHelper::CopyInputToOutput(xInputStream, xOutStream);
|
|
}
|
|
else
|
|
{
|
|
::ucbhelper::Content sourceContent(rSourceURL,
|
|
uno::Reference<ucb::XCommandEnvironment>(),
|
|
comphelper::getProcessComponentContext());
|
|
|
|
if (!sourceContent.openStream(xOutStream)) // copy file to storage
|
|
{
|
|
SAL_INFO("avmedia", "openStream to storage failed");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
uno::Reference<embed::XTransactedObject> const xSubTransaction(
|
|
xSubStorage, uno::UNO_QUERY);
|
|
if (xSubTransaction.is()) {
|
|
xSubTransaction->commit();
|
|
}
|
|
uno::Reference<embed::XTransactedObject> const xTransaction(
|
|
xStorage, uno::UNO_QUERY);
|
|
if (xTransaction.is()) {
|
|
xTransaction->commit();
|
|
}
|
|
|
|
o_rEmbeddedURL = "vnd.sun.star.Package:" + media + "/" + filename;
|
|
return true;
|
|
}
|
|
catch (uno::Exception const&)
|
|
{
|
|
SAL_WARN("avmedia",
|
|
"Exception while trying to embed media");
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CreateMediaTempFile(uno::Reference<io::XInputStream> const& xInStream,
|
|
OUString& o_rTempFileURL, std::u16string_view rDesiredExtension)
|
|
{
|
|
OUString tempFileURL;
|
|
::osl::FileBase::RC const err =
|
|
::osl::FileBase::createTempFile(nullptr, nullptr, & tempFileURL);
|
|
if (::osl::FileBase::E_None != err)
|
|
{
|
|
SAL_WARN("avmedia", "cannot create temp file");
|
|
return false;
|
|
}
|
|
|
|
if (!rDesiredExtension.empty())
|
|
{
|
|
OUString newTempFileURL = tempFileURL + rDesiredExtension;
|
|
if (osl::File::move(tempFileURL, newTempFileURL) != osl::FileBase::E_None)
|
|
{
|
|
SAL_WARN("avmedia", "Could not rename file '" << tempFileURL << "' to '" << newTempFileURL << "'");
|
|
return false;
|
|
}
|
|
tempFileURL = newTempFileURL;
|
|
}
|
|
|
|
try
|
|
{
|
|
::ucbhelper::Content tempContent(tempFileURL,
|
|
uno::Reference<ucb::XCommandEnvironment>(),
|
|
comphelper::getProcessComponentContext());
|
|
tempContent.writeStream(xInStream, true); // copy stream to file
|
|
}
|
|
catch (uno::Exception const&)
|
|
{
|
|
TOOLS_WARN_EXCEPTION("avmedia", "");
|
|
return false;
|
|
}
|
|
o_rTempFileURL = tempFileURL;
|
|
return true;
|
|
}
|
|
|
|
MediaTempFile::~MediaTempFile()
|
|
{
|
|
::osl::File::remove(m_TempFileURL);
|
|
}
|
|
|
|
} // namespace avmedia
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|