public static FPClipRef RawOpen(FPPoolRef inPool, string inClipID, FPStreamRef inStream, FPLong inOptions)
{
FPClipRef retval = SDK.FPClip_RawOpen(inPool, inClipID, inStream, inOptions);
SDK.CheckAndThrowError();
return(retval);
}
public static FPStreamRef FPStream_CreateToStdio()
{
FPStreamRef retval = SDK.FPStream_CreateToStdio();
SDK.CheckAndThrowError();
return(retval);
}
public static FPStreamRef CreatePartialFileForOutput(string pFilePath, string pPerm, long pBuffSize, long pOffset, long pSize, long pMaxFileSize)
{
FPStreamRef retval = SDK.FPStream_CreatePartialFileForOutput8(pFilePath, pPerm, pBuffSize, pOffset, pSize, pMaxFileSize);
SDK.CheckAndThrowError();
return(retval);
}
public static FPStreamRef CreateBufferForOutput(IntPtr pBuffer, long pBuffLen)
{
FPStreamRef retval = SDK.FPStream_CreateBufferForOutput(pBuffer, pBuffLen);
SDK.CheckAndThrowError();
return(retval);
}
public static FPStreamRef CreateFileForOutput(string pFilePath, string pPerm)
{
FPStreamRef retval = SDK.FPStream_CreateFileForOutput8(pFilePath, pPerm);
SDK.CheckAndThrowError();
return(retval);
}
public static FPStreamRef CreateFileForInput(string pFilePath, string pPerm, long pBuffSize)
{
FPStreamRef retval = SDK.FPStream_CreateFileForInput8(pFilePath, pPerm, pBuffSize);
SDK.CheckAndThrowError();
return(retval);
}
public static FPStreamRef FPStream_CreateTemporaryFile(long pMemBuffSize)
{
FPStreamRef retval = SDK.FPStream_CreateTemporaryFile(pMemBuffSize);
SDK.CheckAndThrowError();
return(retval);
}
/// <summary>
///Create a Stream using a buffer to write to (StreamType.InputToCentera)
///or read from (StreamType.OutputFromCentera) the Centera.
///See API Guide: FPStream_CreateBufferForInput, FPStream_CreateBufferForOutput
///
///@param streamBuffer The buffer that the Stream will read from (for INPUT to the Centera)
/// or write to (for OUTPUT from the Centera).
///@param bufferSize The size of the buffer.
///@param streamDirection The StreamDirection enum indicating input or output.
/// </summary>
public FPStream(IntPtr streamBuffer, int bufferSize, StreamDirection streamDirection)
{
this.theStream = streamDirection == StreamDirection.InputToCentera
? Native.Stream.CreateBufferForInput(streamBuffer, bufferSize)
: Native.Stream.CreateBufferForOutput(streamBuffer, bufferSize);
this.AddObject(this.theStream, this);
}
/// <summary>
///Create a Stream that reads from the Centera and writes the content to stdio or
///a null stream.
///See API Guide: FPStream_CreateToStdio / FPStream_CreateToNull
///
///@param streamType StreamType enum - Stdio or Null.
/// </summary>
public FPStream(StreamType streamType)
{
this.theStream = streamType == StreamType.Stdio
? Native.Stream.FPStream_CreateToStdio()
: Native.Stream.FPStream_CreateToNull();
this.AddObject(this.theStream, this);
}
/// <summary>
///Explicitly close this Stream. See API Guide: FPStream_Close
/// </summary>
public override void Close()
{
if (theStream != 0)
{
RemoveObject(theStream);
Native.Stream.Close(theStream);
theStream = 0;
}
}
/// <summary>
///Create a Stream using a buffer to write to (StreamType.InputToCentera)
///or read from (StreamType.OutputFromCentera) the Centera.
///See API Guide: FPStream_CreateBufferForInput, FPStream_CreateBufferForOutput
///
///@param streamBuffer The buffer that the Stream will read from (for INPUT to the Centera)
/// or write to (for OUTPUT from the Centera).
///@param bufferSize The size of the buffer.
///@param streamDirection The StreamDirection enum indicating input or output.
/// </summary>
public FPStream(IntPtr streamBuffer, int bufferSize, StreamDirection streamDirection)
{
if (streamDirection == StreamDirection.InputToCentera)
{
theStream = Native.Stream.CreateBufferForInput(streamBuffer, (long)bufferSize);
}
else
{
theStream = Native.Stream.CreateBufferForOutput(streamBuffer, (long)bufferSize);
}
AddObject(theStream, this);
}
/// <summary>
///Create a Stream that reads from the Centera and writes the content to stdio or
///a null stream.
///See API Guide: FPStream_CreateToStdio / FPStream_CreateToNull
///
///@param streamType StreamType enum - Stdio or Null.
/// </summary>
public FPStream(StreamType streamType)
{
if (streamType == StreamType.Stdio)
{
theStream = Native.Stream.FPStream_CreateToStdio();
}
else
{
theStream = Native.Stream.FPStream_CreateToNull();
}
AddObject(theStream, this);
}
public static void BlobRead(FPTagRef inTag, FPStreamRef inStream, FPLong inOptions)
{
SDK.FPTag_BlobRead(inTag, inStream, inOptions);
SDK.CheckAndThrowError();
}
public static void Close(FPStreamRef pStream)
{
SDK.FPStream_Close(pStream);
SDK.CheckAndThrowError();
}
/// <summary>
///Creates a Stream for temporary storage. If the length of the stream is greater than
///pMemBuffSize the overflow is flushed to a temporary file.
///See API Guide: FPStream_CreateTemporaryFile
///
///@param pMemBuffSize The size of the in-memory buffer to use.
/// </summary>
public FPStream(long pMemBuffSize)
{
theStream = Native.Stream.FPStream_CreateTemporaryFile(pMemBuffSize);
AddObject(theStream, this);
}
/// <summary>
///Create a Stream that reads part of a file and writes the content to Centera.
///See API Guide: FPStream_CreatePartialFileForInput
///
///@param fileName The name of the file to read from.
///@param bufferSize The size of the buffer to use for writing.
///@param offset The position in the file to start reading from.
///@param length The length of the file segment to read from.
/// </summary>
public FPStream(string fileName, long bufferSize, long offset, long length)
{
theStream = Native.Stream.CreatePartialFileForInput(fileName, "rb", bufferSize, offset, length);
AddObject(theStream, this);
}
/// <summary>
///Create a Stream that reads from Centera and writes the content at an offset in a file.
///See API Guide: FPStream_CreatePartialFileForOutput
///
///@param fileName The name of the file to read from.
///@param permission The write mode that the file is opened in.
///@param bufferSize The size of the buffer to use for writing.
///@param offset The position in the file to start writing to.
///@param length The length of the file segment to write to.
///@param maxFileSize The maximum size that the output file max grow to.
/// </summary>
public FPStream(string fileName, string permission, long bufferSize, long offset, long length, long maxFileSize)
{
theStream = Native.Stream.CreatePartialFileForOutput(fileName, permission, bufferSize, offset, length, maxFileSize);
AddObject(theStream, this);
}
public static FPEventCallbackRef RegisterForAllEvents(FPMonitorRef inMonitor, FPStreamRef inStream)
{
var retval = SDK.FPEventCallback_RegisterForAllEvents(inMonitor, inStream);
SDK.CheckAndThrowError();
return(retval);
}
/// <summary>
///Create a Stream that reads a file and writes the content to Centera.
///See API Guide: FPStream_CreateFileForInput
///
///@param fileName The name of the file to read from.
///@param bufferSize The size of the buffer to use for writing.
/// </summary>
public FPStream(string fileName, long bufferSize)
{
theStream = Native.Stream.CreateFileForInput(fileName, "rb", bufferSize);
AddObject(theStream, this);
}
public static void GetDiscoveryStream(FPMonitorRef inMonitor, FPStreamRef inStream)
{
SDK.FPMonitor_GetDiscoveryStream(inMonitor, inStream);
SDK.CheckAndThrowError();
}
public static extern IntPtr FPStream_Complete(FPStreamRef pStream);
public static extern unsafe FPStreamInfo *FPStream_GetInfo(FPStreamRef pStream);
/// <summary>
///Create a Stream that reads from the Centera and writes the content to a file.
///See API Guide: FPStream_CreateFileForOutput
///
///@param fileName The name of the file to write to.
///@param permissions The permissions to create the file with.
/// </summary>
public FPStream(string fileName, string permissions)
{
theStream = Native.Stream.CreateFileForOutput(fileName, permissions);
AddObject(theStream, this);
}
public static void GetAllStatisticsStream(FPMonitorRef inMonitor, FPStreamRef inStream)
{
SDK.FPMonitor_GetAllStatisticsStream(inMonitor, inStream);
SDK.CheckAndThrowError();
}
public static extern void FPStream_Close(FPStreamRef pStream);
public static void BlobReadPartial(FPTagRef inTag, FPStreamRef inStream, FPLong inOffset, FPLong inReadLength, FPLong inOptions)
{
SDK.FPTag_BlobReadPartial(inTag, inStream, inOffset, inReadLength, inOptions);
SDK.CheckAndThrowError();
}
public static extern IntPtr FPStream_PrepareBuffer(FPStreamRef pStream);
public static void BlobWritePartial(FPTagRef inTag, FPStreamRef inStream, FPLong inOptions, FPLong inSequenceID)
{
SDK.FPTag_BlobWritePartial(inTag, inStream, inOptions, inSequenceID);
SDK.CheckAndThrowError();
}
public static extern void FPStream_ResetMark(FPStreamRef pStream);
public static void RawRead(FPClipRef inClip, FPStreamRef inStream)
{
SDK.FPClip_RawRead(inClip, inStream);
SDK.CheckAndThrowError();
}
