/**
* @brief Function called to describe the plugin main features.
* @param[in, out] desc Effect descriptor
*/
void AVReaderPluginFactory::describe( OFX::ImageEffectDescriptor& desc )
{
avtranscoder::preloadCodecsAndFormats();
avtranscoder::Logger::setLogLevel( AV_LOG_QUIET );
desc.setLabels(
"TuttleAVReader",
"AVReader",
"Audio Video reader" );
desc.setPluginGrouping( "tuttle/image/io" );
std::vector<std::string> supportedExtensions( avtranscoder::getInputExtensions() );
// Hack: Add basic video container extensions
// as some versions of LibAV doesn't declare properly all extensions...
supportedExtensions.push_back("mov");
supportedExtensions.push_back("avi");
supportedExtensions.push_back("mpg");
supportedExtensions.push_back("mkv");
supportedExtensions.push_back("flv");
supportedExtensions.push_back("m2ts");
// sort / unique
std::sort(supportedExtensions.begin(), supportedExtensions.end());
supportedExtensions.erase(
std::unique(supportedExtensions.begin(), supportedExtensions.end()),
supportedExtensions.end() );
desc.setDescription( "Video reader based on AvTranscoder library\n\n"
"Supported extensions: \n" +
boost::algorithm::join( supportedExtensions, ", " )
);
// add the supported contexts
desc.addSupportedContext( OFX::eContextReader );
desc.addSupportedContext( OFX::eContextGeneral );
// add supported pixel depths
desc.addSupportedBitDepth( OFX::eBitDepthUByte );
desc.addSupportedBitDepth( OFX::eBitDepthUShort );
desc.addSupportedBitDepth( OFX::eBitDepthFloat );
// add supported extensions
desc.addSupportedExtensions( supportedExtensions );
desc.setPluginEvaluation( 30 );
// plugin flags
desc.setRenderThreadSafety( OFX::eRenderInstanceSafe );
desc.setHostFrameThreading( false );
desc.setSupportsMultiResolution( false );
desc.setSupportsMultipleClipDepths( true );
desc.setSupportsMultipleClipPARs( true );
desc.setSupportsTiles( kSupportTiles );
}
bool SFB::Audio::LibsndfileDecoder::HandlesFilesWithExtension(CFStringRef extension)
{
if(nullptr == extension)
return false;
SFB::CFArray supportedExtensions(CreateSupportedFileExtensions());
if(!supportedExtensions)
return false;
CFIndex numberOfSupportedExtensions = CFArrayGetCount(supportedExtensions);
for(CFIndex currentIndex = 0; currentIndex < numberOfSupportedExtensions; ++currentIndex) {
CFStringRef currentExtension = (CFStringRef)CFArrayGetValueAtIndex(supportedExtensions, currentIndex);
if(kCFCompareEqualTo == CFStringCompare(extension, currentExtension, kCFCompareCaseInsensitive))
return true;
}
return false;
}
/*!
\internal
*/
void QWebSocketServerPrivate::handshakeReceived()
{
if (Q_UNLIKELY(!currentSender)) {
return;
}
QTcpSocket *pTcpSocket = qobject_cast<QTcpSocket*>(currentSender->sender);
if (Q_UNLIKELY(!pTcpSocket)) {
return;
}
//When using Google Chrome the handshake in received in two parts.
//Therefore, the readyRead signal is emitted twice.
//This is a guard against the BEAST attack.
//See: https://www.imperialviolet.org/2012/01/15/beastfollowup.html
//For Safari, the handshake is delivered at once
//FIXME: For FireFox, the readyRead signal is never emitted
//This is a bug in FireFox (see https://bugzilla.mozilla.org/show_bug.cgi?id=594502)
if (!pTcpSocket->canReadLine()) {
return;
}
disconnect(pTcpSocket, &QTcpSocket::readyRead,
this, &QWebSocketServerPrivate::handshakeReceived);
Q_Q(QWebSocketServer);
bool success = false;
bool isSecure = false;
if (m_pendingConnections.length() >= maxPendingConnections()) {
pTcpSocket->close();
pTcpSocket->deleteLater();
setError(QWebSocketProtocol::CloseCodeAbnormalDisconnection,
QWebSocketServer::tr("Too many pending connections."));
return;
}
QWebSocketHandshakeRequest request(pTcpSocket->peerPort(), isSecure);
QTextStream textStream(pTcpSocket);
request.readHandshake(textStream, MAX_HEADERLINE_LENGTH, MAX_HEADERLINES);
if (request.isValid()) {
QWebSocketCorsAuthenticator corsAuthenticator(request.origin());
Q_EMIT q->originAuthenticationRequired(&corsAuthenticator);
QWebSocketHandshakeResponse response(request,
m_serverName,
corsAuthenticator.allowed(),
supportedVersions(),
supportedProtocols(),
supportedExtensions());
if (response.isValid()) {
QTextStream httpStream(pTcpSocket);
httpStream << response;
httpStream.flush();
if (response.canUpgrade()) {
QWebSocket *pWebSocket = QWebSocketPrivate::upgradeFrom(pTcpSocket,
request,
response);
if (pWebSocket) {
addPendingConnection(pWebSocket);
Q_EMIT q->newConnection();
success = true;
} else {
setError(QWebSocketProtocol::CloseCodeAbnormalDisconnection,
QWebSocketServer::tr("Upgrade to WebSocket failed."));
}
}
else {
setError(response.error(), response.errorString());
}
} else {
setError(QWebSocketProtocol::CloseCodeProtocolError,
QWebSocketServer::tr("Invalid response received."));
}
}
if (!success) {
pTcpSocket->close();
}
}
return new DeepImageReader( op, fn );
}
DD::Image::DeepReaderFormat *DeepImageReader::buildformat( DD::Image::DeepReaderOwner *op )
{
return new DeepImageReaderFormats();
}
const DD::Image::MetaData::Bundle &DeepImageReader::fetchMetaData( const char *key )
{
return m_meta;
}
const char *DeepImageReader::supportedExtensions()
{
// We have to hard code the supported deep image types here
// because we cannot call IECore::Reader::supportedExtensions
// as we are inside a static initializer.
// We have also omitted the IECoreDL dtex reader here as nuke
// already supports it out of the box.
#ifdef IECORE_WITH_DEEPEXR
return "shw\0dsm\0rat\0dexr\0";
#else
return "shw\0dsm\0rat\0";
#endif
}
const DD::Image::DeepReader::Description DeepImageReader::g_description( supportedExtensions(), "cortex", build, buildformat );
} // namespace IECoreNuke
void SieveTest::parse()
{
if ( identifier() == "address" ) {
findComparator();
findMatchType();
findAddressPart();
arguments()->numberRemainingArguments();
d->headers = takeHeaderFieldList( 1 );
d->keys = arguments()->takeStringList( 2 );
}
else if ( identifier() == "allof" ||
identifier() == "anyof" ) {
if ( !arguments()->arguments()->isEmpty() )
setError( "Test '" +
identifier() +
"' does not accept arguments, only a list of tests" );
bool any = false;
List<SieveTest>::Iterator i( arguments()->tests() );
while ( i ) {
any = true;
i->parse();
if ( i->ihaveFailed() )
setIhaveFailed();
addExtensions( i->addedExtensions() );
++i;
}
if ( !any )
setError( "Need at least one subsidiary test" );
}
else if ( identifier() == "envelope" ) {
require( "envelope" );
findComparator();
findMatchType();
findAddressPart();
arguments()->numberRemainingArguments();
d->envelopeParts = arguments()->takeStringList( 1 );
d->keys = arguments()->takeStringList( 2 );
UStringList::Iterator i( d->envelopeParts );
while ( i ) {
EString s = i->utf8().lower();
if ( s == "from" || s == "to" ) {
Utf8Codec c;
*i = c.toUnicode( s );
}
// else if and blah for extensions - extensions are only
// valid after the right require
else {
// better if we could setError on the right item, but it's gone
setError( "Unsupported envelope part: " + i->utf8() );
}
++i;
}
}
else if ( identifier() == "exists" ) {
arguments()->numberRemainingArguments();
d->headers = takeHeaderFieldList( 1 );
}
else if ( identifier() == "false" ) {
// I wish all the tests were this easy
}
else if ( identifier() == "header" ) {
findComparator();
findMatchType();
arguments()->numberRemainingArguments();
d->headers = takeHeaderFieldList( 1 );
d->keys = arguments()->takeStringList( 2 );
}
else if ( identifier() == "date" ||
identifier() == "currentdate" )
{
require( "date" );
findComparator();
findMatchType();
d->zone = arguments()->takeTaggedString( ":zone" );
if ( d->zone.isEmpty() &&
arguments()->findTag( ":originalzone" ) )
d->zone.append( "-0000" );
arguments()->numberRemainingArguments();
uint n = 1;
if ( identifier() == "date" ) {
d->headers = takeHeaderFieldList( n++ );
if ( d->headers && d->headers->count() != 1 )
setError( "Only one date field may be specified" );
}
d->datePart = arguments()->takeString( n++ );
d->keys = arguments()->takeStringList( n );
}
else if ( identifier() == "not" ) {
if ( !arguments()->arguments()->isEmpty() )
setError( "Test 'not' does not accept arguments, only a test" );
if ( !arguments()->tests() ||
arguments()->tests()->count() != 1 )
setError( "Test 'not' needs exactly one subsidiary test" );
else
arguments()->tests()->first()->parse();
}
else if ( identifier() == "size" ) {
arguments()->allowOneTag( ":over", ":under" );
if ( arguments()->findTag( ":over" ) ) {
d->sizeOver = true;
d->sizeLimit = arguments()->takeTaggedNumber( ":over" );
}
else if ( arguments()->findTag( ":under" ) ) {
d->sizeOver = false;
d->sizeLimit = arguments()->takeTaggedNumber( ":under" );
}
}
else if ( identifier() == "true" ) {
// much like false.
}
else if ( identifier() == "body" ) {
require( "body" );
findComparator();
findMatchType();
arguments()->allowOneTag( ":raw", ":text", ":content" );
if ( arguments()->findTag( ":raw" ) ) {
d->bodyMatchType = Rfc822;
}
else if ( arguments()->findTag( ":text" ) ) {
d->bodyMatchType = Text;
}
else if ( arguments()->findTag( ":content" ) ) {
d->bodyMatchType = SpecifiedTypes;
d->contentTypes = arguments()->takeTaggedStringList( ":content" );
}
arguments()->numberRemainingArguments();
d->keys = arguments()->takeStringList( 1 );
}
else if ( identifier() == "ihave" ) {
require( "ihave" );
arguments()->numberRemainingArguments();
arguments()->takeStringList( 1 );
}
else if ( identifier() == "valid_notify_method" ) {
require( "enotify" );
arguments()->numberRemainingArguments();
UStringList * urls = arguments()->takeStringList( 1 );
if ( !urls || urls->isEmpty() )
setError( "No URLs" );
}
else if ( identifier() == "notify_method_capability" ) {
require( "enotify" );
findComparator();
findMatchType();
arguments()->numberRemainingArguments();
(void)new SieveNotifyMethod( arguments()->takeString( 1 ),
arguments()->takeArgument( 1 ),
this );
(void)arguments()->takeString( 2 ).utf8().lower();
d->keys = arguments()->takeStringList( 3 );
}
else {
setError( "Unknown test: " + identifier() );
}
if ( arguments() )
arguments()->flagUnparsedAsBad();
// if the ihave was correctly parsed and names something we don't
// support, then we have to suppress some errors.
if ( identifier() == "ihave" && error().isEmpty() ) {
UStringList::Iterator i( arguments()->takeStringList( 1 ) );
EStringList x;
while ( i && supportedExtensions()->contains( i->ascii() ) ) {
x.append( i->ascii() );
++i;
}
if ( i )
setIhaveFailed();
else
addExtensions( &x );
}
}
void SieveCommand::parse( const EString & previous )
{
if ( identifier().isEmpty() )
setError( "Command name is empty" );
bool test = false;
bool blk = false;
EString i = identifier();
if ( i == "if" || i == "elsif" ) {
test = true;
blk = true;
if ( i == "elsif" && previous != "if" && previous != "elsif" )
setError( "elsif is only permitted after if/elsif" );
}
else if ( i == "else" ) {
blk = true;
if ( previous != "if" && previous != "elsif" )
setError( "else is only permitted after if/elsif" );
}
else if ( i == "require" ) {
arguments()->numberRemainingArguments();
UStringList::Iterator i( arguments()->takeStringList( 1 ) );
EStringList a;
EStringList e;
while ( i ) {
if ( supportedExtensions()->contains( i->ascii() ) )
a.append( i->ascii().quoted() );
else
e.append( i->ascii().quoted() );
++i;
}
if ( !e.isEmpty() )
setError( "Each string must be a supported "
"sieve extension. "
"These are not: " + e.join( ", " ) );
if ( !d->require )
setError( "require is only permitted as the first command." );
else if ( parent() )
parent()->addExtensions( &a );
}
else if ( i == "stop" ) {
// nothing needed
}
else if ( i == "reject" ) {
require( "reject" );
if ( arguments()->arguments()->isEmpty() ) {
// we accept reject without reason
}
else {
// if there is an argument, it must be a string
arguments()->numberRemainingArguments();
(void)arguments()->takeString( 1 );
}
}
else if ( i == "ereject" ) {
require( "reject" );
arguments()->numberRemainingArguments();
(void)arguments()->takeString( 1 );
}
else if ( i == "fileinto" ) {
require( "fileinto" );
if ( arguments()->findTag( ":copy" ) )
require( "copy" );
if ( arguments()->findTag( ":flags" ) ) {
require( "imap4flags" );
(void)arguments()->takeTaggedStringList( ":copy" );
}
arguments()->numberRemainingArguments();
UString mailbox = arguments()->takeString( 1 );
UString p;
p.append( "/" );
p.append( mailbox );
if ( !Mailbox::validName( mailbox ) && !Mailbox::validName( p ) ) {
setError( "Expected mailbox name, but got: " + mailbox.utf8() );
}
else if ( mailbox.startsWith( "INBOX." ) ) {
// a sieve script which wants to reference a
// mailbox called INBOX.X must use lower case
// (inbox.x).
UString aox =
UStringList::split( '.', mailbox.mid( 6 ) )->join( "/" );
setError( mailbox.utf8().quoted() +
" is Cyrus syntax. Archiveopteryx uses " +
aox.utf8().quoted() );
}
}
else if ( i == "redirect" ) {
(void)arguments()->findTag( ":copy" );
arguments()->numberRemainingArguments();
EString s = arguments()->takeString( 1 ).utf8();
AddressParser ap( s );
ap.assertSingleAddress();
if ( !ap.error().isEmpty() )
setError( "Expected one normal address (local@domain), but got: "
+ s );
}
else if ( i == "keep" ) {
// nothing needed
}
else if ( i == "discard" ) {
// nothing needed
}
else if ( i == "vacation" ) {
// vacation [":days" number] [":subject" string]
// [":from" string] [":addresses" string-list]
// [":mime"] [":handle" string] <reason: string>
require( "vacation" );
// :days
uint days = 7;
if ( arguments()->findTag( ":days" ) )
days = arguments()->takeTaggedNumber( ":days" );
if ( days < 1 || days > 365 )
arguments()->tagError( ":days", "Number must be 1..365" );
// :subject
(void)arguments()->takeTaggedString( ":subject" );
// anything is acceptable, right?
// :from
if ( arguments()->findTag( ":from" ) ) {
parseAsAddress( arguments()->takeTaggedString( ":from" ),
":from" );
// XXX we don't enforce its being a local address.
}
// :addresses
if ( arguments()->findTag( ":addresses" ) ) {
UStringList * addresses
= arguments()->takeTaggedStringList( ":addresses" );
UStringList::Iterator i( addresses );
while ( i ) {
parseAsAddress( *i, ":addresses" );
++i;
}
}
// :mime
bool mime = false;
if ( arguments()->findTag( ":mime" ) )
mime = true;
// :handle
(void)arguments()->takeTaggedString( ":handle" );
// reason
arguments()->numberRemainingArguments();
UString reason = arguments()->takeString( 1 );
if ( mime ) {
if ( !reason.isAscii() )
setError( ":mime bodies must be all-ASCII, "
"8-bit text is not permitted" ); // so says the RFC
EString x = reason.utf8();
uint i = 0;
Header * h = Message::parseHeader( i, x.length(),
x, Header::Mime );
Bodypart * bp = Bodypart::parseBodypart( i, x.length(),
x, h, 0 );
if ( !h->error().isEmpty() )
setError( "While parsing MIME header: " + h->error() );
else if ( !bp->error().isEmpty() )
setError( "While parsing MIME bodypart: " + bp->error() );
List<HeaderField>::Iterator f( h->fields() );
while ( f ) {
if ( !f->name().startsWith( "Content-" ) )
setError( "Header field not permitted: " + f->name() );
++f;
}
if ( bp->children()->isEmpty() && bp->text().isEmpty() )
setError( "Vacation reply does not contain any text" );
}
else {
if ( reason.isEmpty() )
setError( "Empty vacation text does not make sense" );
}
}
else if ( i == "setflag" ||
i == "addflags" ||
i == "removeflag" ) {
arguments()->numberRemainingArguments();
(void)arguments()->takeStringList( 1 );
}
else if ( i == "notify" ) {
require( "enotify" );
UString from;
if ( arguments()->findTag( ":from" ))
from = arguments()->takeTaggedString( ":from" );
UString importance;
importance.append( "2" );
if ( arguments()->findTag( ":importance" ) )
importance = arguments()->takeTaggedString( ":from" );
uint c = importance[0];
if ( c < '1' || c > '3' )
arguments()->tagError( ":importance",
"Importance must be 1, 2 or 3" );
UStringList * options;
if ( arguments()->findTag( ":options" ) )
options = arguments()->takeTaggedStringList( ":options" );
UString message;
if ( arguments()->findTag( ":message" ) )
message = arguments()->takeTaggedString( ":message" );
arguments()->numberRemainingArguments();
UString method = arguments()->takeString( 1 );
SieveNotifyMethod * m
= new SieveNotifyMethod( method,
arguments()->takeArgument( 1 ),
this );
if ( m->valid() ) {
if ( arguments()->findTag( ":from" ) )
m->setFrom( from, arguments()->findTag( ":from" ) );
if ( arguments()->findTag( ":message" ) )
m->setMessage( message, arguments()->findTag( ":message" ) );
}
}
else {
setError( "Command unknown: " + identifier() );
}
arguments()->flagUnparsedAsBad();
if ( test ) {
// we must have a test
if ( !arguments() || arguments()->tests()->count() != 1 )
setError( "Command " + identifier() + " requires one test" );
if ( arguments() ) {
List<SieveTest>::Iterator i( arguments()->tests() );
while ( i ) {
i->parse();
if ( blk && block() ) {
if ( i->ihaveFailed() )
block()->setIhaveFailed();
else
block()->addExtensions( i->addedExtensions() );
}
++i;
}
}
}
else {
// we cannot have a test
if ( arguments() && arguments()->tests()->isEmpty() ) {
List<SieveTest>::Iterator i( arguments()->tests() );
while ( i ) {
i->setError( "Command " + identifier() +
" does not use tests" );
++i;
}
}
}
if ( blk ) {
// we must have a subsidiary block
if ( !block() ) {
setError( "Command " + identifier() +
" requires a subsidiary {..} block" );
}
else {
EString prev;
List<SieveCommand>::Iterator i( block()->commands() );
while ( i ) {
i->parse( prev );
prev = i->identifier();
++i;
}
}
}
else {
// we cannot have a subsidiary block
if ( block() )
block()->setError( "Command " + identifier() +
" does not use a subsidiary command block" );
// in this case we don't even bother syntax-checking the test
// or block
}
}
