_i_ak_stream_mgr_8h

Wwise SDK 2022.1.18

 /*******************************************************************************
 The content of this file includes portions of the AUDIOKINETIC Wwise Technology
 released in source code form as part of the SDK installer package.
  
 Commercial License Usage
  
 Licensees holding valid commercial licenses to the AUDIOKINETIC Wwise Technology
 may use this file in accordance with the end user license agreement provided 
 with the software or, alternatively, in accordance with the terms contained in a
 written agreement between you and Audiokinetic Inc.
  
 Apache License Usage
  
 Alternatively, this file may be used under the Apache License, Version 2.0 (the 
 "Apache License"); you may not use this file except in compliance with the 
 Apache License. You may obtain a copy of the Apache License at 
 http://www.apache.org/licenses/LICENSE-2.0.
  
 Unless required by applicable law or agreed to in writing, software distributed
 under the Apache License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES
 OR CONDITIONS OF ANY KIND, either express or implied. See the Apache License for
 the specific language governing permissions and limitations under the License.
  
   Copyright (c) 2024 Audiokinetic Inc.
 *******************************************************************************/
  
 /// \file 
 /// Defines the API of Audiokinetic's I/O streaming solution.
  
 #ifndef _IAK_STREAM_MGR_H_
 #define _IAK_STREAM_MGR_H_
  
 #include <AK/SoundEngine/Common/AkMemoryMgr.h>
  
 //-----------------------------------------------------------------------------
 // Defines. 
 //-----------------------------------------------------------------------------
  
 /// \name Profiling string lengths.
 //@{
 #define AK_MONITOR_STREAMNAME_MAXLENGTH    (64)
 #define AK_MONITOR_DEVICENAME_MAXLENGTH    (16)
 //@}
  
 //-----------------------------------------------------------------------------
 // Enums.
 //-----------------------------------------------------------------------------
  
 /// Stream status.
 enum AkStmStatus
 {
     AK_StmStatusIdle            = 0,        ///< The stream is idle
     AK_StmStatusCompleted       = 1,        ///< Operation completed / Automatic stream reached end
     AK_StmStatusPending         = 2,        ///< Operation pending / The stream is waiting for I/O
     AK_StmStatusCancelled       = 3,        ///< Operation cancelled
     AK_StmStatusError           = 4         ///< The low-level I/O reported an error
 };
  
 /// Move method for position change. 
 /// \sa
 /// - AK::IAkStdStream::SetPosition()
 /// - AK::IAkAutoStream::SetPosition()
 enum AkMoveMethod
 {
     AK_MoveBegin                = 0,        ///< Move offset from the start of the stream
     AK_MoveCurrent              = 1,        ///< Move offset from the current stream position
     AK_MoveEnd                  = 2         ///< Move offset from the end of the stream
 };
  
 /// File open mode.
 enum AkOpenMode
 {
     AK_OpenModeRead             = 0,        ///< Read-only access
     AK_OpenModeWrite            = 1,        ///< Write-only access (opens the file if it already exists)
     AK_OpenModeWriteOvrwr       = 2,        ///< Write-only access (deletes the file if it already exists)
     AK_OpenModeReadWrite        = 3         ///< Read and write access
 };
  
 /// File system flags for file descriptors mapping.
 struct AkFileSystemFlags
 {
     AkFileSystemFlags()
         : uCacheID( AK_INVALID_FILE_ID ), uDirectoryHash( AK_INVALID_UNIQUE_ID ) {}
  
     AkFileSystemFlags( AkUInt32 in_uCompanyID, AkUInt32 in_uCodecID, AkUInt32 in_uCustomParamSize, void * in_pCustomParam, bool in_bIsLanguageSpecific, AkFileID in_uCacheID )
         : uCompanyID( in_uCompanyID )
         , uCodecID( in_uCodecID )
         , uCustomParamSize( in_uCustomParamSize )
         , pCustomParam( in_pCustomParam )
         , bIsLanguageSpecific( in_bIsLanguageSpecific )
         , uCacheID( in_uCacheID )
         , uNumBytesPrefetch( 0 )
         , uDirectoryHash( AK_INVALID_UNIQUE_ID ) {}
  
     AkUInt32            uCompanyID;         ///< Company ID (Wwise uses AKCOMPANYID_AUDIOKINETIC, defined in AkTypes.h, for soundbanks and standard streaming files, and AKCOMPANYID_AUDIOKINETIC_EXTERNAL for streaming external sources).
     AkUInt32            uCodecID;           ///< File/codec type ID (defined in AkTypes.h)
     AkUInt32            uCustomParamSize;   ///< Size of the custom parameter
     void *              pCustomParam;       ///< Custom parameter
     bool                bIsLanguageSpecific;///< True when the file location depends on language
     bool                bIsAutomaticStream; ///< True when the file is opened to be used as an automatic stream. Note that you don't need to set it. 
                                             ///< If you pass an AkFileSystemFlags to IAkStreamMgr CreateStd|Auto(), it will be set internally to the correct value.
     AkFileID            uCacheID;           ///< Cache ID for caching system used by automatic streams. The user is responsible for guaranteeing unicity of IDs. 
                                             ///< When set, it supersedes the file ID passed to AK::IAkStreamMgr::CreateAuto() (ID version). Caching is optional and depends on the implementation.
     AkUInt32            uNumBytesPrefetch;  ///< Indicates the number of bytes from the beginning of the file that should be streamed into cache via a caching stream. This field is only relevant when opening caching streams via 
                                             ///< AK::IAkStreamMgr::PinFileInCache() and AK::SoundEngine::PinEventInStreamCache().  When using AK::SoundEngine::PinEventInStreamCache(), 
                                             ///< it is initialized to the prefetch size stored in the sound bank, but may be changed by the file location resolver, or set to 0 to cancel caching.
     AkUInt32            uDirectoryHash;     ///< If the implementation uses a hashed directory structure, this is the hash value that should be employed for determining the directory structure
 };
  
 /// Stream information.
 /// \sa
 /// - AK::IAkStdStream::GetInfo()
 /// - AK::IAkAutoStream::GetInfo()
 struct AkStreamInfo
 {
     AkDeviceID          deviceID;           ///< Device ID
     const AkOSChar *    pszName;            ///< User-defined stream name (specified through AK::IAkStdStream::SetStreamName() or AK::IAkAutoStream::SetStreamName())
     AkUInt64            uSize;              ///< Total stream/file size in bytes
     bool                bIsOpen;            ///< True when the file is open (implementations may defer file opening)
 };
  
 /// Automatic streams heuristics.
 struct AkAutoStmHeuristics
 {
     AkReal32            fThroughput;        ///< Average throughput in bytes/ms
     AkUInt32            uLoopStart;         ///< Set to the start of loop (byte offset from the beginning of the stream) for streams that loop, 0 otherwise
     AkUInt32            uLoopEnd;           ///< Set to the end of loop (byte offset from the beginning of the stream) for streams that loop, 0 otherwise
     AkUInt8             uMinNumBuffers;     ///< Minimum number of buffers if you plan to own more than one buffer at a time, 0 or 1 otherwise
                                             ///< \remarks You should always release buffers as fast as possible, therefore this heuristic should be used only when 
                                             ///< dealing with special contraints, like drivers or hardware that require more than one buffer at a time.\n
                                             ///< Also, this is only a heuristic: it does not guarantee that data will be ready when calling AK::IAkAutoStream::GetBuffer().
     AkPriority          priority;           ///< The stream priority. it should be between AK_MIN_PRIORITY and AK_MAX_PRIORITY (included).
 };
  
 /// Automatic streams buffer settings/constraints.
 struct AkAutoStmBufSettings
 {
     AkUInt32            uBufferSize;        ///< Hard user constraint: When non-zero, forces the I/O buffer to be of size uBufferSize
                                             ///< (overriding the device's granularity).
                                             ///< Otherwise, the size is determined by the device's granularity.
     AkUInt32            uMinBufferSize;     ///< Soft user constraint: When non-zero, specifies a minimum buffer size
                                             ///< \remarks Ignored if uBufferSize is specified.
     AkUInt32            uBlockSize;         ///< Hard user constraint: When non-zero, buffer size will be a multiple of that number, and returned addresses will always be aligned on multiples of this value.
 };
  
 /// \name Profiling structures.
 //@{
  
 #pragma pack(push, 4)
  
 /// Device descriptor.
 struct AkDeviceDesc
 {
     AkDeviceID          deviceID;           ///< Device ID
     bool                bCanWrite;          ///< Specifies whether or not the device is writable
     bool                bCanRead;           ///< Specifies whether or not the device is readable
     AkUtf16             szDeviceName[AK_MONITOR_DEVICENAME_MAXLENGTH];      ///< Device name
     AkUInt32            uStringSize;        ///< Device name string's size (number of characters)
 };
  
 /// Device descriptor.
 struct AkDeviceData
 {
     AkDeviceID          deviceID;           ///< Device ID
     AkUInt32            uMemSize;           ///< IO memory pool size
     AkUInt32            uMemUsed;           ///< IO memory pool used    
     AkUInt32            uAllocs;            ///< Cumulative number of allocations
     AkUInt32            uFrees;             ///< Cumulative number of deallocations
     AkUInt32            uPeakRefdMemUsed;           ///< Memory peak since monitoring started
     AkUInt32            uUnreferencedCachedBytes;   ///< IO memory that is cached but is not currently used for active streams.
     AkUInt32            uGranularity;       ///< IO memory pool block size
     AkUInt32            uNumActiveStreams;  ///< Number of streams that have been active in the previous frame
     AkUInt32            uTotalBytesTransferred;         ///< Number of bytes transferred, including cached transfers
     AkUInt32            uLowLevelBytesTransferred;      ///< Number of bytes transferred exclusively via low-level
     AkReal32            fAvgCacheEfficiency;            ///< Total bytes from cache as a percentage of total bytes. 
     AkUInt32            uNumLowLevelRequestsCompleted;  ///< Number of low-level transfers that have completed in the previous monitoring frame
     AkUInt32            uNumLowLevelRequestsCancelled;  ///< Number of low-level transfers that were cancelled in the previous monitoring frame
     AkUInt32            uNumLowLevelRequestsPending;    ///< Number of low-level transfers that are currently pending
     AkUInt32            uCustomParam;       ///< Custom number queried from low-level IO.
     AkUInt32            uCachePinnedBytes;  ///< Number of bytes that can be pinned into cache.
 };
  
 /// Stream general information.
 struct AkStreamRecord
 {
     AkUInt32            uStreamID;          ///< Unique stream identifier
     AkDeviceID          deviceID;           ///< Device ID
     AkUtf16             szStreamName[AK_MONITOR_STREAMNAME_MAXLENGTH];       ///< Stream name
     AkUInt32            uStringSize;        ///< Stream name string's size (number of characters)
     AkUInt64            uFileSize;          ///< File size
     AkUInt32            uCustomParamSize;   ///< File descriptor's uCustomParamSize
     AkUInt32            uCustomParam;       ///< File descriptor's pCustomParam (on 32 bits)
     bool                bIsAutoStream;      ///< True for auto streams
     bool                bIsCachingStream;   ///< True for caching streams
 };
  
 /// Stream statistics.
 struct AkStreamData
 {
     AkUInt32            uStreamID;          ///< Unique stream identifier
     // Status (replace)
     AkUInt32            uPriority;          ///< Stream priority
     AkUInt64            uFilePosition;      ///< Current position
     AkUInt32            uTargetBufferingSize;       ///< Total stream buffer size (specific to IAkAutoStream)
     AkUInt32            uVirtualBufferingSize;      ///< Size of available data including requested data (specific to IAkAutoStream)
     AkUInt32            uBufferedSize;              ///< Size of available data (specific to IAkAutoStream)
     AkUInt32            uNumBytesTransfered;        ///< Transfered amount since last query (Accumulate/Reset)
     AkUInt32            uNumBytesTransferedLowLevel;///< Transfered amount (from low-level IO only) since last query (Accumulate/Reset)
     AkUInt32            uMemoryReferenced;          ///< Amount of streaming memory referenced by this stream
     AkReal32            fEstimatedThroughput;       ///< Estimated throughput heuristic
     bool                bActive;            ///< True if this stream has been active (that is, was ready for I/O or had at least one pending I/O transfer, uncached or not) in the previous frame
 };
  
 #pragma pack(pop)
  
 //@}
  
 namespace AK
 {
     /// \name Profiling interfaces.
     //@{
     
     /// Profiling interface of streams.
     /// \akwarning
     /// The functions in this interface are not thread-safe, unless stated otherwise.
     /// \endakwarning
     class IAkStreamProfile
     {
     protected:
         /// Virtual destructor on interface to avoid warnings.
         virtual ~IAkStreamProfile(){}
  
     public:
         /// Returns the stream's record (once).
         /// \sa
         /// - \ref streamingdevicemanager
         virtual void    GetStreamRecord( 
             AkStreamRecord & out_streamRecord   ///< Returned stream record interface
             ) = 0;
  
         /// Returns the stream's statistics (every profile frame).
         /// \sa
         /// - \ref streamingdevicemanager
         virtual void    GetStreamData(
             AkStreamData &   out_streamData     ///< Returned periodic stream data interface
             ) = 0;
  
         /// Query the stream's "new" flag.
         /// \return True, until AK::IAkStreamProfile::ClearNew() is called.
         /// \sa
         /// - \ref streamingdevicemanager
         virtual bool    IsNew() = 0;
  
         /// Resets the stream's "new" flag.
         /// \sa
         /// - \ref streamingdevicemanager
         virtual void    ClearNew() = 0;
     };
  
  
     /// Profiling interface of high-level I/O devices.
     /// \akwarning
     /// The functions in this interface are not thread-safe, unless stated otherwise.
     /// \endakwarning
     class IAkDeviceProfile
     {
     protected:
         /// Virtual destructor on interface to avoid warnings.
         virtual ~IAkDeviceProfile(){}
  
     public:
  
         /// Notify device when monitor sampling starts.
         virtual void    OnProfileStart() = 0;
  
         /// Notify device when monitor sampling ends.
         virtual void    OnProfileEnd() = 0;
  
         /// Query the device's description (once).
         /// \sa
         /// - \ref streamingdevicemanager
         virtual void    GetDesc(
             AkDeviceDesc &  out_deviceDesc      ///< Device descriptor.
             ) = 0;
  
         /// Query the device's statistics (at every profiling frame).
         /// \sa
         /// - \ref streamingdevicemanager
         virtual void    GetData(
             AkDeviceData &  out_deviceData      ///< Device data.
             ) = 0;
  
         /// Query the device's "new" flag.
         /// \return True, until ClearNew() is called.
         /// \sa
         /// - \ref streamingdevicemanager
         virtual bool    IsNew() = 0;
  
         /// Resets the device's "new" flag.
         /// \sa
         /// - \ref streamingdevicemanager
         virtual void    ClearNew() = 0;
  
         /// Get the number of streams currently associated with that device.
         /// \return The number of streams
         /// \sa
         /// - \ref streamingdevicemanager
         virtual AkUInt32 GetNumStreams() = 0;
  
         /// Get a stream profile, for a specified stream index.
         /// \remarks GetStreamProfile() refers to streams by index, which must honor the call to AK::IAkDeviceProfile::GetNumStreams().
         /// \sa
         /// - \ref streamingdevicemanager
         virtual IAkStreamProfile * GetStreamProfile( 
             AkUInt32    in_uStreamIndex     ///< Stream index: [0,numStreams[
             ) = 0;
     };
  
     /// Profiling interface of the Stream Manager.
     /// \akwarning
     /// The functions in this interface are not thread-safe, unless stated otherwise.
     /// \endakwarning
     class IAkStreamMgrProfile
     {
     protected:
         /// Virtual destructor on interface to avoid warnings.
         virtual ~IAkStreamMgrProfile(){}
         
     public:
         /// Start profile monitoring.
         /// \return AK_Success if successful, AK_Fail otherwise.
         /// \sa
         /// - \ref streamingdevicemanager
         virtual AKRESULT StartMonitoring() = 0;
  
         /// Stop profile monitoring.
         /// \sa
         /// - \ref streamingdevicemanager
         virtual void     StopMonitoring() = 0;
         
         /// Device enumeration.
         /// \return The number of devices.
         /// \sa
         /// - \ref streamingdevicemanager
         virtual AkUInt32 GetNumDevices() = 0;
  
         /// Get a device profile for a specified device index.
         /// \remarks GetDeviceProfile() refers to devices by index, which must honor the call to AK::IAkStreamMgrProfile::GetNumDevices().
         /// \remarks The device index is not the same as the device ID (AkDeviceID).
         /// \sa
         /// - \ref streamingdevicemanager
         virtual IAkDeviceProfile * GetDeviceProfile( 
             AkUInt32    in_uDeviceIndex     ///< Device index: [0,numDevices[
             ) = 0;
     };
     //@}
  
     /// \name High-level streams API.
     //@{
  
     /// Interface of standard streams. Used as a handle to a standard stream. Has methods for 
     /// stream control. Obtained through the Stream Manager's AK::IAkStreamMgr::CreateStd() method.
     /// \akwarning
     /// The functions in this interface are not thread-safe, unless stated otherwise.
     /// \endakwarning
     class IAkStdStream
     {
     protected:
         /// Virtual destructor on interface to avoid warnings.
         virtual ~IAkStdStream(){}
  
     public:
         /// \name Stream management and settings.
         //@{
         /// Close the stream. The object is destroyed and the interface becomes invalid.
         /// \sa
         /// - \ref streamingdevicemanager
         virtual void      Destroy() = 0;
  
         /// Get information about a stream.
         /// \sa
         /// - \ref streamingdevicemanager
         virtual void      GetInfo(
             AkStreamInfo &  out_info            ///< Returned stream info
             ) = 0;
  
         /// Returns a unique cookie for a given stream.
         /// The default implementation of the Stream Manager returns its file descriptor (see AkStreamMgrModule.h).
         virtual void * GetFileDescriptor() = 0;
  
         /// Give the stream a name (appears in the Wwise Profiler).
         /// \sa
         /// - \ref streamingdevicemanager
         virtual AKRESULT  SetStreamName(
             const AkOSChar *    in_pszStreamName    ///< Stream name
             ) = 0;
  
         /// Get the I/O block size.
         /// \remark Queries the low-level I/O, by calling AK::StreamMgr::IAkLowLevelIOHook::GetBlockSize() with the
         /// stream's file descriptor.
         /// \return The block size, in bytes.
         /// \sa
         /// - \ref streamingdevicemanager
         virtual AkUInt32  GetBlockSize() = 0;   
         //@}
  
         /// \name I/O operations.
         //@{
         
         /// Schedule a read request.
         /// \warning Use only with a multiple of the block size, queried via AK::IAkStdStream::GetBlockSize().
         /// \remarks If the call is asynchronous (in_bWait = false), wait until AK::IAkStdStream::GetStatus() stops returning AK_StmStatusPending.
         /// \return AK_Success if the operation was successfully scheduled (but not necessarily completed)
         /// \sa
         /// - \ref streamingdevicemanager
         virtual AKRESULT Read(
             void *          in_pBuffer,         ///< User buffer address 
             AkUInt32        in_uReqSize,        ///< Requested read size
             bool            in_bWait,           ///< Block until the operation is complete
             AkPriority      in_priority,        ///< Heuristic: operation priority
             AkReal32        in_fDeadline,       ///< Heuristic: operation deadline (ms)
             AkUInt32 &      out_uSize           ///< The size that was actually read
             ) = 0;
  
         /// Schedule a write request.
         /// \warning Use only with a multiple of the block size, queried via AK::IAkStdStream::GetBlockSize().
         /// \remarks If the call is asynchronous (in_bWait = false), wait until GetStatus() stops returning AK_StmStatusPending.
         /// \return AK_Success if the operation was successfully scheduled
         /// \sa
         /// - \ref streamingdevicemanager
         virtual AKRESULT Write(
             void *          in_pBuffer,         ///< User buffer address
             AkUInt32        in_uReqSize,        ///< Requested write size
             bool            in_bWait,           ///< Block until the operation is complete
             AkPriority      in_priority,        ///< Heuristic: operation priority
             AkReal32        in_fDeadline,       ///< Heuristic: operation deadline (ms)
             AkUInt32 &      out_uSize           ///< The size that was actually written
             ) = 0;
  
         /// Get the current stream position.
         /// \remarks If an operation is pending, there is no guarantee that the position was queried before (or after) the operation was completed.
         /// \return The current stream position
         /// \sa
         /// - \ref streamingdevicemanager
         virtual AkUInt64 GetPosition( 
             bool *          out_pbEndOfStream   ///< Returned end-of-stream flag, only for streams opened with AK_OpenModeRead (can pass NULL)
             ) = 0;
  
         /// Set the stream position. Modifies the position for the next read/write operation.
         /// \warning No operation should be pending.
         /// \remarks The new position will snap to the lowest block boundary.
         /// \return AK_Success if the stream position was changed
         /// \sa
         /// - \ref streamingdevicemanager
         virtual AKRESULT SetPosition(
             AkInt64         in_iMoveOffset,     ///< Seek offset
             AkMoveMethod    in_eMoveMethod,     ///< Seek method, from the beginning, end, or current file position
             AkInt64 *       out_piRealOffset    ///< The actual seek offset may differ from the expected value when the block size is bigger than 1.
                                                 ///< In that case, the seek offset floors to the sector boundary. Can pass NULL.
             ) = 0;
  
         /// Cancel the current operation.
         /// \remarks When it returns, the caller is guaranteed that no operation is pending.
         /// \remarks This method can block the caller for the whole duration of the I/O operation, if the request was already posted.
         /// \sa
         /// - \ref streamingdevicemanager
         virtual void Cancel() = 0;
  
         //@}
  
         /// \name Access to data and status.
         //@{
         /// Get user data (and accessed size).
         /// \return The address of data provided by user
         /// \sa
         /// - \ref streamingdevicemanager
         virtual void *   GetData( 
             AkUInt32 &      out_uSize           ///< Size actually read or written
             ) = 0;
  
         /// Get the stream's status.
         /// \return The stream status.
         /// \sa
         /// - \ref streamingdevicemanager
         virtual AkStmStatus GetStatus() = 0;  
  
         /// Block and wait for a pending read to finish, and return the current status of the stream.
         /// This will return immediately if the status is not pending.
         /// \return The stream status.
         /// \sa
         /// - \ref streamingdevicemanager
         virtual AkStmStatus WaitForPendingOperation() = 0;
  
         //@}
     };
  
  
     /// Interface of automatic streams. It is used as a handle to a stream, 
     /// I/O operations are triggered from here. 
     /// Obtained through the Stream Manager's AK::IAkStreamMgr::CreateAuto() method.
     /// \akwarning
     /// The functions in this interface are not thread-safe, unless stated otherwise.
     /// \endakwarning
     /// \sa
     /// - \ref streamingdevicemanager
     class IAkAutoStream 
     {
     protected:
         /// Virtual destructor on interface to avoid warnings.
         virtual ~IAkAutoStream(){}
  
     public:
         /// \name Stream management, settings access, and run-time change.
         //@{
         /// Close the stream. The object is destroyed and the interface becomes invalid.
         /// \sa
         /// - \ref streamingdevicemanager
         virtual void      Destroy() = 0;
  
         /// Get information about the stream.
         /// \sa
         /// - \ref streamingdevicemanager
         virtual void      GetInfo(
             AkStreamInfo &      out_info        ///< Returned stream info
             ) = 0;
  
         /// Returns a unique cookie for a given stream.
         /// The default implementation of the Stream Manager returns its file descriptor (see AkStreamMgrModule.h).
         virtual void * GetFileDescriptor() = 0;
  
         /// Get the stream's heuristics.
         /// \sa
         /// - \ref streamingdevicemanager
         virtual void      GetHeuristics(
             AkAutoStmHeuristics & out_heuristics///< Returned stream heuristics
             ) = 0;
  
         /// Run-time change of the stream's heuristics.
         /// \sa
         /// - \ref streamingdevicemanager
         virtual AKRESULT  SetHeuristics(
             const AkAutoStmHeuristics & in_heuristics   ///< New stream heuristics
             ) = 0;
  
         /// Run-time change of the stream's minimum buffer size that can be handed out to client
         /// in GetBuffer() (except the last buffer at the end of file).
         /// Corresponds to the uMinBufferSize field of the AkAutoStmBufSettings passed to CreateAuto().
         /// \sa
         /// - AkAutoStmBufSettings
         /// - \ref streamingdevicemanager
         virtual AKRESULT  SetMinimalBufferSize(
             AkUInt32        in_uMinBufferSize   ///< Minimum buffer size that can be handed out to client.
             ) = 0;
  
         /// Set the minimum size to buffer ahead in an automated stream.
         ///
         /// This function was made available to allow systems that cannot only rely on AkAutoStmHeuristics::fThroughput to predict what will be the best target size of an automatic stream.
         /// The system will predict the minimum size to buffer and will consider this value as the minimal size to be the target.
         /// \sa
         /// - AkAutoStmBufSettings
         /// - \ref streamingdevicemanager
         /// - \ref AkAutoStmHeuristics
         virtual AKRESULT  SetMinTargetBufferSize(
             AkUInt32        in_uMinTargetBufferSize ///< Minimum size to buffer ahead in an automated stream. (in bytes)
         ) = 0;
  
         /// Give the stream a name (appears in the Wwise profiler).
         /// \sa
         /// - \ref streamingdevicemanager
         virtual AKRESULT  SetStreamName(
             const AkOSChar *    in_pszStreamName    ///< Stream name
             ) = 0;
  
         /// Get the I/O block size.
         /// \remark Queries the actual low-level I/O device, by calling AK::StreamMgr::IAkLowLevelIOHook::GetBlockSize() with the
         /// stream's file descriptor.
         /// \return The block size (in bytes)
         /// \sa
         /// - \ref streamingdevicemanager
         virtual AkUInt32  GetBlockSize() = 0;
  
         /// Get the amount of buffering that the stream has. 
         /// The buffering is defined as the number of bytes that the stream has buffered, excluding the number
         /// of bytes that is currently granted to the user (with GetBuffer()).
         /// \remark The returned value corresponds to the buffering status at that moment, and does not even 
         /// guarantee that it will not shrink.
         /// \return 
         /// - AK_DataReady: Some data has been buffered (out_uNumBytesAvailable is greater than 0).
         /// - AK_NoDataReady: No data is available, and the end of file has not been reached.
         /// - AK_NoMoreData: Some or no data is available, but the end of file has been reached. The stream will not buffer any more data.
         /// - AK_Fail: The stream is invalid due to an I/O error.
         virtual AKRESULT QueryBufferingStatus( 
             AkUInt32 & out_uNumBytesAvailable   ///< Number of bytes available in the stream's buffer(s).
             ) = 0;
  
         /// Returns the target buffering size based on the throughput heuristic.
         /// \return
         /// Target buffering length expressed in bytes. 
         virtual AkUInt32 GetNominalBuffering() = 0;
  
         //@}
  
         /// \name Stream operations.
         //@{
         
         /// Start the automatic scheduling.
         /// \return AK_Success if the automatic scheduling was started successfully
         /// \sa
         /// - \ref streamingdevicemanager
         virtual AKRESULT Start() = 0;
  
         /// Stop the automatic scheduling.
         /// \return AK_Success if the automatic scheduling was stopped successfully.
         /// \sa
         /// - \ref streamingdevicemanager
         virtual AKRESULT Stop() = 0;
  
         /// Get the stream's position.
         /// \remarks The stream position is the position seen by the user, not the position of the file
         /// already streamed into the Stream Manager's memory. The stream position is updated when buffers 
         /// are released, using AK::IAkAutoStream::ReleaseBuffer().
         /// \return The file position in bytes of the beginning of the first buffer owned by the user. 
         /// If the user does not own a buffer, it returns the position of the beginning of the buffer that 
         /// would be returned from a call to AK::IAkAutoStream::GetBuffer().
         /// \sa
         /// - \ref streamingdevicemanager
         virtual AkUInt64 GetPosition( 
             bool *          out_pbEndOfStream   ///< Returned end-of-stream flag (can pass NULL)
             ) = 0;  
  
         /// Set the stream's position. 
         /// The next call to AK::IAkAutoStream::GetBuffer() will grant data that corresponds to the position specified here.
         /// \remarks Data already streamed into the Stream Manager's memory might be flushed.
         /// \remarks The new position will round down to the low-level I/O block size.
         /// \return AK_Success if the resulting position is valid
         /// \sa
         /// - \ref streamingdevicemanager
         virtual AKRESULT SetPosition(
             AkInt64         in_iMoveOffset,     ///< Seek offset
             AkMoveMethod    in_eMoveMethod,     ///< Seek method, from the beginning, end or current file position
             AkInt64 *       out_piRealOffset    ///< The actual seek offset may differ from the expected value when the low-level's block size is greater than 1.
                                                 ///< In that case, the real absolute position rounds down to the block boundary. Can pass NULL.
             ) = 0;
  
         //@}
  
  
         /// \name Data/status access.
         //@{
  
         /// Get data from the Stream Manager buffers.
         /// \remarks Grants a buffer if data is available. Each successful call to this method returns a new 
         /// buffer of data, at the current stream position.
         /// Buffers should be released as soon as they are not needed, using AK::IAkAutoStream::ReleaseBuffer().
         /// \aknote AK::IAkAutoStream::ReleaseBuffer() does not take any argument, because it releases buffers in order. \endaknote
         /// \return
         ///     - AK_DataReady     : the buffer was granted
         ///     - AK_NoDataReady   : the buffer is not granted yet (never happens when called with in_bWait flag)
         ///     - AK_NoMoreData    : the buffer was granted but reached end of file (next call will return with size 0)
         ///     - AK_Fail          : there was an I/O error
         /// \sa
         /// - \ref streamingdevicemanager
         virtual AKRESULT GetBuffer(
             void *&         out_pBuffer,        ///< Returned address of granted data space
             AkUInt32 &      out_uSize,          ///< Returned size of granted data space
             bool            in_bWait            ///< Block until data is ready
             ) = 0;
  
         /// Release buffer granted through GetBuffer(). Buffers are released in order.
         /// \return AK_Success if a valid buffer was released, AK_Fail if the user did not own any buffer.
         /// \note To implementers: Clients like the sound engine may release buffers until this function returns AK_Fail.
         /// Failing to release a buffer should not be considered as a fatal error.
         /// \sa
         /// - \ref streamingdevicemanager
         virtual AKRESULT ReleaseBuffer() = 0;
         //@}
     };
  
     //@}
  
  
     /// Interface of the Stream Manager.
     /// \akwarning
     /// The functions in this interface are not thread-safe, unless stated otherwise.
     /// \endakwarning
     class IAkStreamMgr
     {
     protected:
         /// Virtual destructor on interface to avoid warnings.
         virtual ~IAkStreamMgr(){}
         
     public:
         /// Global access to singleton.
         /// \return The interface of the global Stream Manager
         /// \sa
         /// - \ref streamingdevicemanager
         inline static IAkStreamMgr * Get()
         {
             return m_pStreamMgr;
         }
  
         /// Destroy the Stream Manager.
         /// \sa
         /// - \ref streamingdevicemanager
         virtual void     Destroy() = 0;
  
  
         /// \name Profiling.
         //@{
         /// Get the profiling interface.
         /// \return The interface of the Stream Manager profiler
         virtual IAkStreamMgrProfile * GetStreamMgrProfile() = 0;
         //@}
  
  
         /// \name Stream creation interface.
         //@{
         
         // Standard stream creation methods.
  
         /// Create a standard stream (string overload).
         /// \return AK_Success if the stream was created successfully
         /// \remarks The string overload of AK::StreamMgr::IAkFileLocationResolver::Open() will be called.
         /// \sa
         /// - \ref streamingdevicemanager
         virtual AKRESULT CreateStd(
             const AkOSChar*     in_pszFileName,     ///< Application-defined string (title only, or full path, or code...)
             AkFileSystemFlags * in_pFSFlags,        ///< Special file system flags. Can pass NULL
             AkOpenMode          in_eOpenMode,       ///< Open mode (read, write, ...)
             IAkStdStream *&     out_pStream,        ///< Returned interface to a standard stream. If the function does not return AK_Success, this pointer is left untouched.
             bool                in_bSyncOpen        ///< If true, force the Stream Manager to open file synchronously. Otherwise, it is left to its discretion.
             ) = 0;
  
         /// Create a standard stream (ID overload).
         /// \return AK_Success if the stream was created successfully
         /// \remarks The ID overload of AK::StreamMgr::IAkFileLocationResolver::Open() will be called.
         /// \sa
         /// - \ref streamingdevicemanager
         virtual AKRESULT CreateStd(
             AkFileID            in_fileID,          ///< Application-defined ID
             AkFileSystemFlags * in_pFSFlags,        ///< Special file system flags (can pass NULL)
             AkOpenMode          in_eOpenMode,       ///< Open mode (read, write, ...)
             IAkStdStream *&     out_pStream,        ///< Returned interface to a standard stream. If the function does not return AK_Success, this pointer is left untouched.
             bool                in_bSyncOpen        ///< If true, force the Stream Manager to open file synchronously. Otherwise, it is left to its discretion.
             ) = 0;
  
         
         // Automatic stream create methods.
  
         /// Create an automatic stream (string overload).
         /// \return AK_Success if the stream was created successfully
         /// \remarks The stream needs to be started explicitly with AK::IAkAutoStream::Start().
         /// \remarks The string overload of AK::StreamMgr::IAkFileLocationResolver::Open() will be called.
         /// \sa
         /// - \ref streamingdevicemanager
         virtual AKRESULT CreateAuto(
             const AkOSChar*             in_pszFileName,     ///< Application-defined string (title only, or full path, or code...)
             AkFileSystemFlags *         in_pFSFlags,        ///< Special file system flags (can pass NULL)
             const AkAutoStmHeuristics & in_heuristics,      ///< Streaming heuristics
             AkAutoStmBufSettings *      in_pBufferSettings, ///< Stream buffer settings (it is recommended to pass NULL in order to use the default settings)
             IAkAutoStream *&            out_pStream,        ///< Returned interface to an automatic stream. If the function does not return AK_Success, this pointer is left untouched.
             bool                        in_bSyncOpen        ///< If true, force the Stream Manager to open file synchronously. Otherwise, it is left to its discretion.
             ) = 0;
  
         /// Create an automatic stream (ID overload).
         /// \return AK_Success if the stream was created successfully
         /// \remarks The stream needs to be started explicitly with IAkAutoStream::Start().
         /// \remarks The ID overload of AK::StreamMgr::IAkFileLocationResolver::Open() will be called.
         /// \sa
         /// - \ref streamingdevicemanager
         virtual AKRESULT CreateAuto(
             AkFileID                    in_fileID,          ///< Application-defined ID
             AkFileSystemFlags *         in_pFSFlags,        ///< Special file system flags (can pass NULL)
             const AkAutoStmHeuristics & in_heuristics,      ///< Streaming heuristics
             AkAutoStmBufSettings *      in_pBufferSettings, ///< Stream buffer settings (it is recommended to pass NULL to use the default settings)
             IAkAutoStream *&            out_pStream,        ///< Returned interface to an automatic stream. If the function does not return AK_Success, this pointer is left untouched.
             bool                        in_bSyncOpen        ///< If true, force the Stream Manager to open file synchronously. Otherwise, it is left to its discretion.
             ) = 0;
  
         /// Create an automatic stream (in-memory buffer overload).
         ///
         /// This overload differs largely from CreateAuto() implementations, which are file based.
         /// This version is provided with a memory space and the resulting automatic stream will simply 
         /// return the memory space in a similar fashion, but without the need to perform any actual file operations.
         ///
         /// If you are in the process of implementing your own IAkStreamMgr object, 
         /// consider using the initial implementation from `\\SDK\\source\\StreamManager\\Common\\AkStreamMgr.cpp`.
         ///
         /// \return AK_Success if the stream was created successfully
         /// \remarks The stream needs to be started explicitly with IAkAutoStream::Start().
         /// \sa
         /// - \ref streamingdevicemanager
         virtual AKRESULT CreateAuto(
             void *                      in_pBuffer,         ///< Pointer to the memory area containing stream data
             AkUInt64                    in_uSize,           ///< Size of the memory area containing stream data
             const AkAutoStmHeuristics & in_heuristics,      ///< Streaming heuristics
             IAkAutoStream *&            out_pStream         ///< Returned interface to an automatic stream. If the function does not return AK_Success, this pointer is left untouched.
             ) = 0;
  
         /// Start streaming the first "in_pFSFlags->uNumBytesPrefetch" bytes of the file with id "in_fileID" into cache.  The stream will be scheduled only after
         /// all regular streams (not file caching streams) are serviced.  The file will stay cached until either the UnpinFileInCache is called,
         /// or the limit as set by uMaxCachePinnedBytes is reached and another higher priority file (in_uPriority) needs the space.  
         /// \remarks PinFileInCache()/UnpinFileInCache()/UpdateCachingPriority() are typically not used directly, but instead used via the AK::SoundEngine::PinEventInStreamCache() API. 
         ///     Using PinFileInCache() directly does not allow users to take advantage of sound bank data.  The file and the number of bytes they wish to cache must be explicitly specified.
         /// 
         /// \sa
         /// - \ref streamingdevicemanager
         /// - AK::SoundEngine::PinEventInStreamCache
         /// - AK::SoundEngine::UnpinEventInStreamCache
         /// - AkFileSystemFlags
         virtual AKRESULT PinFileInCache(
             AkFileID                    in_fileID,          ///< Application-defined ID
             AkFileSystemFlags *         in_pFSFlags,        ///< Special file system flags (can NOT pass NULL)
             AkPriority                  in_uPriority        ///< Stream caching priority.  Note: Caching requests only get serviced after all regular streaming requests.
             ) = 0;
  
         /// Un-pin a file that has been previouly pinned into cache.  This function must be called once for every call to PinFileInCache() with the same file id.
         /// The file may still remain in stream cache after this is called, until the memory is reused by the streaming memory manager in accordance with to its 
         /// cache management algorithm.
         /// \remarks PinFileInCache()/UnpinFileInCache()/UpdateCachingPriority() are typically not used directly, but instead used via the AK::SoundEngine::PinEventInStreamCache() API. 
         ///     Using UnpinFileInCache() directly does not allow users to take advantage of sound bank data.  The file must be explicitly specified.
         /// \sa
         /// - \ref streamingdevicemanager
         /// - AK::SoundEngine::PinEventInStreamCache
         /// - AK::SoundEngine::UnpinEventInStreamCache
         virtual AKRESULT UnpinFileInCache(
             AkFileID                    in_fileID,              ///< Application-defined ID
             AkPriority                  in_uPriority        ///< Priority of stream that you are unpinning
             ) = 0;
         
         /// Update the priority of the caching stream.  Higher priority streams will be serviced before lower priority caching streams, and will be more likely to stay in 
         /// memory if the cache pin limit as set by "uMaxCachePinnedBytes" is reached.
         /// \remarks PinFileInCache()/UnpinFileInCache()/UpdateCachingPriority() are typically not used directly, but instead used via the AK::SoundEngine::PinEventInStreamCache() API. 
         ///     Using UpdateCachingPriority() directly does not allow users to take advantage of sound bank data.  The file must be explicitly specified.
         /// \sa
         /// - \ref streamingdevicemanager
         /// - AK::SoundEngine::PinEventInStreamCache
         /// - AK::SoundEngine::UnpinEventInStreamCache
         virtual AKRESULT UpdateCachingPriority(
             AkFileID                    in_fileID,          ///< Application-defined ID
             AkPriority                  in_uPriority,       ///< Priority
             AkPriority                  in_uOldPriority         ///< Old priority
             ) = 0;
         
         /// Return information about a file that has been pinned into cache.
         /// Retrieves the percentage of the requested buffer size that has been streamed in and stored into stream cache, and whether 
         /// the cache pinned memory limit is preventing this buffer from filling.
         virtual AKRESULT GetBufferStatusForPinnedFile( 
             AkFileID in_fileID,                             ///< Application-defined ID
             AkReal32& out_fPercentBuffered,                 ///< Percentage of buffer full (out of 100)
             bool& out_bCacheFull                            ///< Set to true if the rest of the buffer can not fit into the cache-pinned memory limit.
             ) = 0;
  
         /// Make a memory stream point to a new area in memory, otherwise keeping the exact same state.
         virtual AKRESULT RelocateMemoryStream(
             IAkAutoStream * in_pStream,                     ///< The stream to relocate. Must be a stream created with the memory overload of CreateAutoStm.
             AkUInt8 * in_pNewStart                          ///< The new area in memory to point to
         ) = 0;
  
         //@}
  
     protected:
         /// Definition of the global pointer to the interface of the Stream Manager singleton.
         /// \sa
         /// - \ref streamingdevicemanager
         static AKSOUNDENGINE_API IAkStreamMgr * m_pStreamMgr;
     };
  
 }
 #endif //_IAK_STREAM_MGR_H_

AkFileSystemFlags::uNumBytesPrefetch

AkUInt32 uNumBytesPrefetch

Definition: IAkStreamMgr.h:104

AkStreamInfo::bIsOpen

bool bIsOpen

True when the file is open (implementations may defer file opening)

Definition: IAkStreamMgr.h:119

AkFileSystemFlags::AkFileSystemFlags

AkFileSystemFlags()

Definition: IAkStreamMgr.h:82

AkDeviceData::uCachePinnedBytes

AkUInt32 uCachePinnedBytes

Number of bytes that can be pinned into cache.

Definition: IAkStreamMgr.h:180

AkAutoStmHeuristics::uLoopStart

AkUInt32 uLoopStart

Set to the start of loop (byte offset from the beginning of the stream) for streams that loop,...

Definition: IAkStreamMgr.h:126

AK::IAkStreamMgr::Get

static IAkStreamMgr * Get()

Definition: IAkStreamMgr.h:697

AkStreamData::uBufferedSize

AkUInt32 uBufferedSize

Size of available data (specific to IAkAutoStream)

Definition: IAkStreamMgr.h:206

AK::IAkStdStream::GetData

virtual void * GetData(AkUInt32 &out_uSize)=0

AkFileSystemFlags::uDirectoryHash

AkUInt32 uDirectoryHash

If the implementation uses a hashed directory structure, this is the hash value that should be employ...

Definition: IAkStreamMgr.h:107

AK::IAkStreamMgr::GetStreamMgrProfile

virtual IAkStreamMgrProfile * GetStreamMgrProfile()=0

Audiokinetic namespace

Definition: AkWwiseSDKVersion.cs:31

AK_MONITOR_DEVICENAME_MAXLENGTH

#define AK_MONITOR_DEVICENAME_MAXLENGTH

Definition: IAkStreamMgr.h:42

AkStreamInfo::deviceID

AkDeviceID deviceID

Device ID

Definition: IAkStreamMgr.h:116

AK::IAkStreamProfile::IsNew

virtual bool IsNew()=0

AkStreamRecord::uFileSize

AkUInt64 uFileSize

File size

Definition: IAkStreamMgr.h:190

AK::IAkAutoStream::SetMinimalBufferSize

virtual AKRESULT SetMinimalBufferSize(AkUInt32 in_uMinBufferSize)=0

AK::IAkAutoStream::GetPosition

virtual AkUInt64 GetPosition(bool *out_pbEndOfStream)=0

AkDeviceDesc::bCanRead

bool bCanRead

Specifies whether or not the device is readable

Definition: IAkStreamMgr.h:156

AkAutoStmBufSettings

Automatic streams buffer settings/constraints.

Definition: IAkStreamMgr.h:137

AkStreamData::uPriority

AkUInt32 uPriority

Stream priority

Definition: IAkStreamMgr.h:202

AK::IAkStdStream::GetFileDescriptor

virtual void * GetFileDescriptor()=0

AK::IAkStreamMgrProfile::GetDeviceProfile

virtual IAkDeviceProfile * GetDeviceProfile(AkUInt32 in_uDeviceIndex)=0

AkStreamData::uVirtualBufferingSize

AkUInt32 uVirtualBufferingSize

Size of available data including requested data (specific to IAkAutoStream)

Definition: IAkStreamMgr.h:205

AK::IAkAutoStream::ReleaseBuffer

virtual AKRESULT ReleaseBuffer()=0

AkAutoStmHeuristics::uLoopEnd

AkUInt32 uLoopEnd

Set to the end of loop (byte offset from the beginning of the stream) for streams that loop,...

Definition: IAkStreamMgr.h:127

AkDeviceData::uPeakRefdMemUsed

AkUInt32 uPeakRefdMemUsed

Memory peak since monitoring started

Definition: IAkStreamMgr.h:169

AK::IAkStreamMgr

Definition: IAkStreamMgr.h:687

AK::IAkStreamMgr::~IAkStreamMgr

virtual ~IAkStreamMgr()

Virtual destructor on interface to avoid warnings.

Definition: IAkStreamMgr.h:690

AK_OpenModeWriteOvrwr

@ AK_OpenModeWriteOvrwr

Write-only access (deletes the file if it already exists)

Definition: IAkStreamMgr.h:75

AK::IAkAutoStream::GetInfo

virtual void GetInfo(AkStreamInfo &out_info)=0

AK::IAkStdStream::GetBlockSize

virtual AkUInt32 GetBlockSize()=0

AK::IAkStdStream::SetPosition

virtual AKRESULT SetPosition(AkInt64 in_iMoveOffset, AkMoveMethod in_eMoveMethod, AkInt64 *out_piRealOffset)=0

AKRESULT

Standard function call result.

Definition: AkTypes.h:199

AkDeviceID

AkUInt32 AkDeviceID

I/O device ID

Definition: AkTypes.h:146

AK::IAkDeviceProfile::GetNumStreams

virtual AkUInt32 GetNumStreams()=0

AK_OpenModeReadWrite

@ AK_OpenModeReadWrite

Read and write access

Definition: IAkStreamMgr.h:76

AkStreamData::uNumBytesTransferedLowLevel

AkUInt32 uNumBytesTransferedLowLevel

Transfered amount (from low-level IO only) since last query (Accumulate/Reset)

Definition: IAkStreamMgr.h:208

AK::IAkStreamProfile::GetStreamData

virtual void GetStreamData(AkStreamData &out_streamData)=0

AK_OpenModeRead

@ AK_OpenModeRead

Read-only access

Definition: IAkStreamMgr.h:73

AkAutoStmBufSettings::uBlockSize

AkUInt32 uBlockSize

Hard user constraint: When non-zero, buffer size will be a multiple of that number,...

Definition: IAkStreamMgr.h:143

AK::IAkAutoStream::Stop

virtual AKRESULT Stop()=0

AkStreamRecord::bIsAutoStream

bool bIsAutoStream

True for auto streams

Definition: IAkStreamMgr.h:193

AkAutoStmBufSettings::uMinBufferSize

AkUInt32 uMinBufferSize

Definition: IAkStreamMgr.h:141

AkAutoStmBufSettings::uBufferSize

AkUInt32 uBufferSize

Definition: IAkStreamMgr.h:138

AkDeviceData::uLowLevelBytesTransferred

AkUInt32 uLowLevelBytesTransferred

Number of bytes transferred exclusively via low-level

Definition: IAkStreamMgr.h:174

AK::IAkDeviceProfile::OnProfileEnd

virtual void OnProfileEnd()=0

Notify device when monitor sampling ends.

AK::IAkAutoStream::SetMinTargetBufferSize

virtual AKRESULT SetMinTargetBufferSize(AkUInt32 in_uMinTargetBufferSize)=0

AkOSChar

char AkOSChar

Generic character string

Definition: AkTypes.h:60

AkUInt8

uint8_t AkUInt8

Unsigned 8-bit integer

Definition: AkNumeralTypes.h:36

AK::IAkAutoStream::GetNominalBuffering

virtual AkUInt32 GetNominalBuffering()=0

AK_MoveEnd

@ AK_MoveEnd

Move offset from the end of the stream

Definition: IAkStreamMgr.h:67

AK::IAkAutoStream::GetBlockSize

virtual AkUInt32 GetBlockSize()=0

AK::IAkStdStream::GetStatus

virtual AkStmStatus GetStatus()=0

AK::IAkStdStream::Read

virtual AKRESULT Read(void *in_pBuffer, AkUInt32 in_uReqSize, bool in_bWait, AkPriority in_priority, AkReal32 in_fDeadline, AkUInt32 &out_uSize)=0

AK_MoveBegin

@ AK_MoveBegin

Move offset from the start of the stream

Definition: IAkStreamMgr.h:65

AK::IAkStreamMgr::CreateAuto

virtual AKRESULT CreateAuto(AkFileID in_fileID, AkFileSystemFlags *in_pFSFlags, const AkAutoStmHeuristics &in_heuristics, AkAutoStmBufSettings *in_pBufferSettings, IAkAutoStream *&out_pStream, bool in_bSyncOpen)=0

AkReal32

float AkReal32

32-bit floating point

Definition: AkNumeralTypes.h:46

AkStreamData::uStreamID

AkUInt32 uStreamID

Unique stream identifier

Definition: IAkStreamMgr.h:200

AK::IAkDeviceProfile::OnProfileStart

virtual void OnProfileStart()=0

Notify device when monitor sampling starts.

AkStreamData

Stream statistics.

Definition: IAkStreamMgr.h:199

AkFileSystemFlags::uCompanyID

AkUInt32 uCompanyID

Company ID (Wwise uses AKCOMPANYID_AUDIOKINETIC, defined in AkTypes.h, for soundbanks and standard st...

Definition: IAkStreamMgr.h:95

AkDeviceDesc::uStringSize

AkUInt32 uStringSize

Device name string's size (number of characters)

Definition: IAkStreamMgr.h:158

AkUtf16

AkUInt16 AkUtf16

Definition: AkTypes.h:61

AK_StmStatusIdle

@ AK_StmStatusIdle

The stream is idle

Definition: IAkStreamMgr.h:52

AkFileID

AkUInt32 AkFileID

Integer-type file identifier

Definition: AkTypes.h:145

AK::IAkAutoStream::SetStreamName

virtual AKRESULT SetStreamName(const AkOSChar *in_pszStreamName)=0

AK::IAkDeviceProfile::GetData

virtual void GetData(AkDeviceData &out_deviceData)=0

AK::IAkStreamProfile::ClearNew

virtual void ClearNew()=0

AkDeviceData

Device descriptor.

Definition: IAkStreamMgr.h:163

AK::IAkStreamMgrProfile::~IAkStreamMgrProfile

virtual ~IAkStreamMgrProfile()

Virtual destructor on interface to avoid warnings.

Definition: IAkStreamMgr.h:327

AK::IAkStreamMgrProfile::StopMonitoring

virtual void StopMonitoring()=0

AK::IAkAutoStream::SetHeuristics

virtual AKRESULT SetHeuristics(const AkAutoStmHeuristics &in_heuristics)=0

AKSOUNDENGINE_API

#define AKSOUNDENGINE_API

Definition: AkSoundEngineExport.h:58

AkFileSystemFlags::bIsAutomaticStream

bool bIsAutomaticStream

Definition: IAkStreamMgr.h:100

AkStreamData::uTargetBufferingSize

AkUInt32 uTargetBufferingSize

Total stream buffer size (specific to IAkAutoStream)

Definition: IAkStreamMgr.h:204

AkAutoStmHeuristics::fThroughput

AkReal32 fThroughput

Average throughput in bytes/ms

Definition: IAkStreamMgr.h:125

AkStreamInfo

Definition: IAkStreamMgr.h:115

AK::IAkAutoStream::SetPosition

virtual AKRESULT SetPosition(AkInt64 in_iMoveOffset, AkMoveMethod in_eMoveMethod, AkInt64 *out_piRealOffset)=0

AK::IAkStdStream::SetStreamName

virtual AKRESULT SetStreamName(const AkOSChar *in_pszStreamName)=0

AkDeviceData::uGranularity

AkUInt32 uGranularity

IO memory pool block size

Definition: IAkStreamMgr.h:171

AkDeviceData::uFrees

AkUInt32 uFrees

Cumulative number of deallocations

Definition: IAkStreamMgr.h:168

AK::IAkStdStream::WaitForPendingOperation

virtual AkStmStatus WaitForPendingOperation()=0

AkDeviceData::uNumLowLevelRequestsCancelled

AkUInt32 uNumLowLevelRequestsCancelled

Number of low-level transfers that were cancelled in the previous monitoring frame

Definition: IAkStreamMgr.h:177

AkFileSystemFlags::bIsLanguageSpecific

bool bIsLanguageSpecific

True when the file location depends on language

Definition: IAkStreamMgr.h:99

AK::IAkStreamMgr::CreateAuto

virtual AKRESULT CreateAuto(void *in_pBuffer, AkUInt64 in_uSize, const AkAutoStmHeuristics &in_heuristics, IAkAutoStream *&out_pStream)=0

AK::IAkStreamMgr::CreateAuto

virtual AKRESULT CreateAuto(const AkOSChar *in_pszFileName, AkFileSystemFlags *in_pFSFlags, const AkAutoStmHeuristics &in_heuristics, AkAutoStmBufSettings *in_pBufferSettings, IAkAutoStream *&out_pStream, bool in_bSyncOpen)=0

AkStreamRecord::uCustomParamSize

AkUInt32 uCustomParamSize

File descriptor's uCustomParamSize

Definition: IAkStreamMgr.h:191

AkStreamData::bActive

bool bActive

True if this stream has been active (that is, was ready for I/O or had at least one pending I/O trans...

Definition: IAkStreamMgr.h:211

AkDeviceData::uMemUsed

AkUInt32 uMemUsed

IO memory pool used

Definition: IAkStreamMgr.h:166

AK_MoveCurrent

@ AK_MoveCurrent

Move offset from the current stream position

Definition: IAkStreamMgr.h:66

AK::IAkStreamMgr::Destroy

virtual void Destroy()=0

AkStreamRecord::uStreamID

AkUInt32 uStreamID

Unique stream identifier

Definition: IAkStreamMgr.h:186

AK_StmStatusPending

@ AK_StmStatusPending

Operation pending / The stream is waiting for I/O

Definition: IAkStreamMgr.h:54

AK::IAkDeviceProfile::~IAkDeviceProfile

virtual ~IAkDeviceProfile()

Virtual destructor on interface to avoid warnings.

Definition: IAkStreamMgr.h:269

AkStreamRecord

Stream general information.

Definition: IAkStreamMgr.h:185

AK::IAkStreamMgr::RelocateMemoryStream

virtual AKRESULT RelocateMemoryStream(IAkAutoStream *in_pStream, AkUInt8 *in_pNewStart)=0

Make a memory stream point to a new area in memory, otherwise keeping the exact same state.

AkPriority

AkInt8 AkPriority

Priority

Definition: AkTypes.h:135

AK::IAkStreamMgrProfile::StartMonitoring

virtual AKRESULT StartMonitoring()=0

AkDeviceDesc::deviceID

AkDeviceID deviceID

Device ID

Definition: IAkStreamMgr.h:154

AkDeviceData::uNumActiveStreams

AkUInt32 uNumActiveStreams

Number of streams that have been active in the previous frame

Definition: IAkStreamMgr.h:172

AkStreamRecord::uCustomParam

AkUInt32 uCustomParam

File descriptor's pCustomParam (on 32 bits)

Definition: IAkStreamMgr.h:192

AK::IAkAutoStream::QueryBufferingStatus

virtual AKRESULT QueryBufferingStatus(AkUInt32 &out_uNumBytesAvailable)=0

AkStreamInfo::pszName

const AkOSChar * pszName

User-defined stream name (specified through AK::IAkStdStream::SetStreamName() or AK::IAkAutoStream::S...

Definition: IAkStreamMgr.h:117

AkMemoryMgr.h

AkDeviceData::uCustomParam

AkUInt32 uCustomParam

Custom number queried from low-level IO.

Definition: IAkStreamMgr.h:179

AK::IAkStdStream::~IAkStdStream

virtual ~IAkStdStream()

Virtual destructor on interface to avoid warnings.

Definition: IAkStreamMgr.h:370

AkDeviceData::uTotalBytesTransferred

AkUInt32 uTotalBytesTransferred

Number of bytes transferred, including cached transfers

Definition: IAkStreamMgr.h:173

AK::IAkStdStream::GetInfo

virtual void GetInfo(AkStreamInfo &out_info)=0

AK::IAkStreamMgr::PinFileInCache

virtual AKRESULT PinFileInCache(AkFileID in_fileID, AkFileSystemFlags *in_pFSFlags, AkPriority in_uPriority)=0

AkDeviceData::uUnreferencedCachedBytes

AkUInt32 uUnreferencedCachedBytes

IO memory that is cached but is not currently used for active streams.

Definition: IAkStreamMgr.h:170

AK::IAkStreamMgr::CreateStd

virtual AKRESULT CreateStd(const AkOSChar *in_pszFileName, AkFileSystemFlags *in_pFSFlags, AkOpenMode in_eOpenMode, IAkStdStream *&out_pStream, bool in_bSyncOpen)=0

AkFileSystemFlags::AkFileSystemFlags

AkFileSystemFlags(AkUInt32 in_uCompanyID, AkUInt32 in_uCodecID, AkUInt32 in_uCustomParamSize, void *in_pCustomParam, bool in_bIsLanguageSpecific, AkFileID in_uCacheID)

Definition: IAkStreamMgr.h:85

AkStreamRecord::deviceID

AkDeviceID deviceID

Device ID

Definition: IAkStreamMgr.h:187

AK::IAkStdStream::Destroy

virtual void Destroy()=0

AK::IAkDeviceProfile::GetStreamProfile

virtual IAkStreamProfile * GetStreamProfile(AkUInt32 in_uStreamIndex)=0

AK::IAkDeviceProfile

Definition: IAkStreamMgr.h:266

AK::IAkAutoStream::GetBuffer

virtual AKRESULT GetBuffer(void *&out_pBuffer, AkUInt32 &out_uSize, bool in_bWait)=0

AkStreamData::fEstimatedThroughput

AkReal32 fEstimatedThroughput

Estimated throughput heuristic

Definition: IAkStreamMgr.h:210

AK::IAkAutoStream::GetHeuristics

virtual void GetHeuristics(AkAutoStmHeuristics &out_heuristics)=0

AK::IAkStreamProfile

Definition: IAkStreamMgr.h:228

AkDeviceData::uAllocs

AkUInt32 uAllocs

Cumulative number of allocations

Definition: IAkStreamMgr.h:167

AK::IAkStreamMgr::CreateStd

virtual AKRESULT CreateStd(AkFileID in_fileID, AkFileSystemFlags *in_pFSFlags, AkOpenMode in_eOpenMode, IAkStdStream *&out_pStream, bool in_bSyncOpen)=0

AkFileSystemFlags

File system flags for file descriptors mapping.

Definition: IAkStreamMgr.h:81

AkMoveMethod

Definition: IAkStreamMgr.h:64

AK_INVALID_UNIQUE_ID

static const AkUniqueID AK_INVALID_UNIQUE_ID

Invalid unique 32-bit ID

Definition: AkTypes.h:163

AkDeviceData::uMemSize

AkUInt32 uMemSize

IO memory pool size

Definition: IAkStreamMgr.h:165

AkDeviceData::uNumLowLevelRequestsPending

AkUInt32 uNumLowLevelRequestsPending

Number of low-level transfers that are currently pending

Definition: IAkStreamMgr.h:178

AkInt64

int64_t AkInt64

Signed 64-bit integer

Definition: AkNumeralTypes.h:44

AkFileSystemFlags::uCacheID

AkFileID uCacheID

Definition: IAkStreamMgr.h:102

AK_OpenModeWrite

@ AK_OpenModeWrite

Write-only access (opens the file if it already exists)

Definition: IAkStreamMgr.h:74

AkUInt64

uint64_t AkUInt64

Unsigned 64-bit integer

Definition: AkNumeralTypes.h:39

AK_StmStatusCompleted

@ AK_StmStatusCompleted

Operation completed / Automatic stream reached end

Definition: IAkStreamMgr.h:53

AkStreamData::uNumBytesTransfered

AkUInt32 uNumBytesTransfered

Transfered amount since last query (Accumulate/Reset)

Definition: IAkStreamMgr.h:207

AK::IAkDeviceProfile::GetDesc

virtual void GetDesc(AkDeviceDesc &out_deviceDesc)=0

AkStmStatus

Stream status.

Definition: IAkStreamMgr.h:51

AK::IAkAutoStream

Definition: IAkStreamMgr.h:507

AkDeviceDesc::bCanWrite

bool bCanWrite

Specifies whether or not the device is writable

Definition: IAkStreamMgr.h:155

AkOpenMode

File open mode.

Definition: IAkStreamMgr.h:72

AkDeviceDesc

Device descriptor.

Definition: IAkStreamMgr.h:153

AkDeviceData::uNumLowLevelRequestsCompleted

AkUInt32 uNumLowLevelRequestsCompleted

Number of low-level transfers that have completed in the previous monitoring frame

Definition: IAkStreamMgr.h:176

AkStreamInfo::uSize

AkUInt64 uSize

Total stream/file size in bytes

Definition: IAkStreamMgr.h:118

AK::IAkAutoStream::~IAkAutoStream

virtual ~IAkAutoStream()

Virtual destructor on interface to avoid warnings.

Definition: IAkStreamMgr.h:510

AK::IAkAutoStream::Start

virtual AKRESULT Start()=0

AkDeviceData::fAvgCacheEfficiency

AkReal32 fAvgCacheEfficiency

Total bytes from cache as a percentage of total bytes.

Definition: IAkStreamMgr.h:175

AkUInt32

uint32_t AkUInt32

Unsigned 32-bit integer

Definition: AkNumeralTypes.h:38

AK_INVALID_FILE_ID

static const AkFileID AK_INVALID_FILE_ID

Invalid file ID

Definition: AkTypes.h:170

AkDeviceData::deviceID

AkDeviceID deviceID

Device ID

Definition: IAkStreamMgr.h:164

AK::IAkStreamProfile::~IAkStreamProfile

virtual ~IAkStreamProfile()

Virtual destructor on interface to avoid warnings.

Definition: IAkStreamMgr.h:231

AK_StmStatusError

@ AK_StmStatusError

The low-level I/O reported an error

Definition: IAkStreamMgr.h:56

AkStreamRecord::szStreamName

AkUtf16 szStreamName[AK_MONITOR_STREAMNAME_MAXLENGTH]

Stream name

Definition: IAkStreamMgr.h:188

AK::IAkAutoStream::Destroy

virtual void Destroy()=0

AkStreamRecord::uStringSize

AkUInt32 uStringSize

Stream name string's size (number of characters)

Definition: IAkStreamMgr.h:189

AK::IAkStreamMgrProfile::GetNumDevices

virtual AkUInt32 GetNumDevices()=0

AkFileSystemFlags::uCustomParamSize

AkUInt32 uCustomParamSize

Size of the custom parameter

Definition: IAkStreamMgr.h:97

AkAutoStmHeuristics::priority

AkPriority priority

The stream priority. it should be between AK_MIN_PRIORITY and AK_MAX_PRIORITY (included).

Definition: IAkStreamMgr.h:132

AK::IAkStdStream

Definition: IAkStreamMgr.h:367

AK::IAkStdStream::Cancel

virtual void Cancel()=0

AkStreamData::uMemoryReferenced

AkUInt32 uMemoryReferenced

Amount of streaming memory referenced by this stream

Definition: IAkStreamMgr.h:209

AK::IAkStdStream::Write

virtual AKRESULT Write(void *in_pBuffer, AkUInt32 in_uReqSize, bool in_bWait, AkPriority in_priority, AkReal32 in_fDeadline, AkUInt32 &out_uSize)=0

AkAutoStmHeuristics::uMinNumBuffers

AkUInt8 uMinNumBuffers

Definition: IAkStreamMgr.h:128

AkAutoStmHeuristics

Automatic streams heuristics.

Definition: IAkStreamMgr.h:124

AK::IAkStreamMgr::UnpinFileInCache

virtual AKRESULT UnpinFileInCache(AkFileID in_fileID, AkPriority in_uPriority)=0

AkStreamRecord::bIsCachingStream

bool bIsCachingStream

True for caching streams

Definition: IAkStreamMgr.h:194

AK::IAkStreamMgr::m_pStreamMgr

static IAkStreamMgr * m_pStreamMgr

Definition: IAkStreamMgr.h:866

AK::IAkStreamProfile::GetStreamRecord

virtual void GetStreamRecord(AkStreamRecord &out_streamRecord)=0

AkDeviceDesc::szDeviceName

AkUtf16 szDeviceName[AK_MONITOR_DEVICENAME_MAXLENGTH]

Device name

Definition: IAkStreamMgr.h:157

AK_MONITOR_STREAMNAME_MAXLENGTH

#define AK_MONITOR_STREAMNAME_MAXLENGTH

Definition: IAkStreamMgr.h:41

AK::IAkDeviceProfile::IsNew

virtual bool IsNew()=0

AK::IAkStreamMgr::GetBufferStatusForPinnedFile

virtual AKRESULT GetBufferStatusForPinnedFile(AkFileID in_fileID, AkReal32 &out_fPercentBuffered, bool &out_bCacheFull)=0

AK::IAkStreamMgr::UpdateCachingPriority

virtual AKRESULT UpdateCachingPriority(AkFileID in_fileID, AkPriority in_uPriority, AkPriority in_uOldPriority)=0

AK::IAkAutoStream::GetFileDescriptor

virtual void * GetFileDescriptor()=0

AkStreamData::uFilePosition

AkUInt64 uFilePosition

Current position

Definition: IAkStreamMgr.h:203

AK::IAkStdStream::GetPosition

virtual AkUInt64 GetPosition(bool *out_pbEndOfStream)=0

AK::IAkDeviceProfile::ClearNew

virtual void ClearNew()=0

AkFileSystemFlags::uCodecID

AkUInt32 uCodecID

File/codec type ID (defined in AkTypes.h)

Definition: IAkStreamMgr.h:96

AK::IAkStreamMgrProfile

Definition: IAkStreamMgr.h:324

AkFileSystemFlags::pCustomParam

void * pCustomParam

Custom parameter

Definition: IAkStreamMgr.h:98

AK_StmStatusCancelled

@ AK_StmStatusCancelled

Operation cancelled

Definition: IAkStreamMgr.h:55

이 페이지가 도움이 되었나요?

지원이 필요하신가요?

질문이 있으신가요? 문제를 겪고 계신가요? 더 많은 정보가 필요하신가요? 저희에게 문의해주시면 도와드리겠습니다!

지원 페이지를 방문해 주세요

작업하는 프로젝트에 대해 알려주세요. 언제든지 도와드릴 준비가 되어 있습니다.

프로젝트를 등록하세요. 아무런 조건이나 의무 사항 없이 빠른 시작을 도와드리겠습니다.

Wwise를 시작해 보세요

Wwise SDK

_i_ak_stream_mgr_8h_source

이 페이지가 도움이 되었나요?

지원이 필요하신가요?

작업하는 프로젝트에 대해 알려주세요. 언제든지 도와드릴 준비가 되어 있습니다.