_i_ak_stream_mgr_8h

Wwise SDK 2024.1.1

 /*******************************************************************************
 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>
 #include <AK/SoundEngine/Common/AkFileSystemFlags.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
 };
  
 /// 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)
     bool                bIsLanguageSpecific;///< True when the file was found in a language specific location
 };
  
 /// Automatic streams heuristics.
 struct AkAutoStmHeuristics
 {
     AkReal32            fThroughput;        ///< Average throughput in bytes/ms
     AkUInt64            uLoopStart;         ///< Set to the start of loop (byte offset from the beginning of the stream) for streams that loop, 0 otherwise
     AkUInt64            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
     AkFileID            idFile;
     AkUInt32            uStringSize;        ///< Stream name string's size (number of characters)
     AkUInt64            uFileSize;          ///< File size  
     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
 };
  
  
 /// Contains parameters for the IAkFileLocationResolver::Open() call and related functions.
 /// Files can be designated with a file name or a file ID. Only one of the two members should be valid.
 /// \note pszFileName is stored on the stack and will be valid only through the function call.
 struct AkFileOpenData
 {
     AkFileOpenData()
         : pszFileName(NULL)
         , fileID(AK_INVALID_FILE_ID)
         , pFlags(NULL)
         , eOpenMode(AK_OpenModeRead) {}
  
     AkFileOpenData(const AkOSChar* in_pszFileName, AkOpenMode in_eOpenMode = AK_OpenModeRead, AkFileSystemFlags* in_pFlags = NULL)
         : pszFileName(in_pszFileName)
         , fileID(AK_INVALID_FILE_ID)
         , pFlags(in_pFlags)
         , eOpenMode(in_eOpenMode) {}
  
     AkFileOpenData(AkFileID in_idFile, AkOpenMode in_eOpenMode = AK_OpenModeRead, AkFileSystemFlags* in_pFlags = NULL)
         : pszFileName(NULL)
         , fileID(in_idFile)
         , pFlags(in_pFlags)
         , eOpenMode(in_eOpenMode) {}
  
     AkFileOpenData(const AkOSChar* in_pszFileName, AkFileSystemFlags* in_pFlags)
         : pszFileName(in_pszFileName)
         , fileID(AK_INVALID_FILE_ID)
         , pFlags(in_pFlags)
         , eOpenMode(AK_OpenModeRead) {}
  
     AkFileOpenData(AkFileID in_idFile, AkFileSystemFlags* in_pFlags)
         : pszFileName(NULL)
         , fileID(in_idFile)
         , pFlags(in_pFlags)
         , eOpenMode(AK_OpenModeRead) {}
  
     bool IsValid() const
     {
         return (pszFileName != NULL) || (fileID != AK_INVALID_FILE_ID);
     }
  
     const AkOSChar*     pszFileName;    ///< File name. Only one of pszFileName or fileID should be valid (pszFileName null while fileID is not AK_INVALID_FILE_ID, or vice versa)
     AkFileID            fileID;         ///< File ID. Only one of pszFileName or fileID should be valid (pszFileName null while fileID is not AK_INVALID_FILE_ID, or vice versa)
     AkFileSystemFlags*  pFlags;         ///< Flags for opening, null when unused
     AkOpenMode          eOpenMode;      ///< Open mode.
 };
  
 #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
             ) = 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;
  
         /// 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|
             ) = 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 AkFileOpenData& in_FileOpen,      ///< File name or file ID (only one should be valid), open flags, open mode
             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.
         /// \return AK_Success if the stream was created successfully
         /// \remarks Automatic streams can only be in Read mode.
         /// \remarks The stream needs to be started explicitly with AK::IAkAutoStream::Start().
         /// \remarks This call will eventually delegate the operation to AK::StreamMgr::IAkFileLocationResolver::Open().
         /// \sa
         /// - \ref streamingdevicemanager
         virtual AKRESULT CreateAuto(
             const AkFileOpenData&       in_FileOpen,        ///< File name or file ID (only one should be valid), open flags, open mode
             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.
             bool                        in_bCaching = false ///< Does this stream stay in cache
             ) = 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_

AkStreamInfo::bIsOpen

bool bIsOpen

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

Definition: IAkStreamMgr.h:89

AkFileOpenData::pszFileName

const AkOSChar * pszFileName

File name. Only one of pszFileName or fileID should be valid (pszFileName null while fileID is not AK...

Definition: IAkStreamMgr.h:225

AkFileSystemFlags.h

AkDeviceData::uCachePinnedBytes

AkUInt32 uCachePinnedBytes

Number of bytes that can be pinned into cache.

Definition: IAkStreamMgr.h:151

AK::IAkStreamMgr::Get

static IAkStreamMgr * Get()

Definition: IAkStreamMgr.h:698

AkStreamData::uBufferedSize

AkUInt32 uBufferedSize

Size of available data (specific to IAkAutoStream)

Definition: IAkStreamMgr.h:176

AK::IAkStdStream::GetData

virtual void * GetData(AkUInt32 &out_uSize)=0

AkAutoStmHeuristics::uLoopEnd

AkUInt64 uLoopEnd

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

Definition: IAkStreamMgr.h:98

AkFileOpenData::AkFileOpenData

AkFileOpenData()

Definition: IAkStreamMgr.h:190

AK::IAkStreamMgr::GetStreamMgrProfile

virtual IAkStreamMgrProfile * GetStreamMgrProfile()=0

Definition of data structures for AkAudioObject

Definition: AkWwiseSDKVersion.cs:31

AK_MONITOR_DEVICENAME_MAXLENGTH

#define AK_MONITOR_DEVICENAME_MAXLENGTH

Definition: IAkStreamMgr.h:43

AkStreamInfo::deviceID

AkDeviceID deviceID

Device ID

Definition: IAkStreamMgr.h:86

AK::IAkStreamProfile::IsNew

virtual bool IsNew()=0

AkStreamRecord::uFileSize

AkUInt64 uFileSize

File size

Definition: IAkStreamMgr.h:162

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:127

AkAutoStmBufSettings

Automatic streams buffer settings/constraints.

Definition: IAkStreamMgr.h:108

AkFileOpenData

Definition: IAkStreamMgr.h:189

AkStreamData::uPriority

AkUInt32 uPriority

Stream priority

Definition: IAkStreamMgr.h:172

AK::IAkStdStream::GetFileDescriptor

virtual void * GetFileDescriptor()=0

AK::IAkStreamMgr::CreateStd

virtual AKRESULT CreateStd(const AkFileOpenData &in_FileOpen, IAkStdStream *&out_pStream, bool in_bSyncOpen)=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:175

AK::IAkAutoStream::ReleaseBuffer

virtual AKRESULT ReleaseBuffer()=0

AkDeviceData::uPeakRefdMemUsed

AkUInt32 uPeakRefdMemUsed

Memory peak since monitoring started

Definition: IAkStreamMgr.h:140

AK::IAkStreamMgr

Definition: IAkStreamMgr.h:688

AK::IAkStreamMgr::~IAkStreamMgr

virtual ~IAkStreamMgr()

Virtual destructor on interface to avoid warnings.

Definition: IAkStreamMgr.h:691

AK_OpenModeWriteOvrwr

@ AK_OpenModeWriteOvrwr

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

Definition: IAkStreamMgr.h:76

AK::IAkAutoStream::GetInfo

virtual void GetInfo(AkStreamInfo &out_info)=0

AK::IAkStdStream::GetBlockSize

virtual AkUInt32 GetBlockSize()=0

AKRESULT

Standard function call result.

Definition: AkTypes.h:134

AkDeviceID

AkUInt32 AkDeviceID

I/O device ID

Definition: AkTypes.h:78

AK::IAkDeviceProfile::GetNumStreams

virtual AkUInt32 GetNumStreams()=0

AK_OpenModeReadWrite

@ AK_OpenModeReadWrite

Read and write access

Definition: IAkStreamMgr.h:77

AkStreamData::uNumBytesTransferedLowLevel

AkUInt32 uNumBytesTransferedLowLevel

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

Definition: IAkStreamMgr.h:178

AK::IAkStreamProfile::GetStreamData

virtual void GetStreamData(AkStreamData &out_streamData)=0

AK_OpenModeRead

@ AK_OpenModeRead

Read-only access

Definition: IAkStreamMgr.h:74

AkAutoStmBufSettings::uBlockSize

AkUInt32 uBlockSize

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

Definition: IAkStreamMgr.h:114

AK::IAkAutoStream::Stop

virtual AKRESULT Stop()=0

AkStreamRecord::bIsAutoStream

bool bIsAutoStream

True for auto streams

Definition: IAkStreamMgr.h:163

AkAutoStmBufSettings::uMinBufferSize

AkUInt32 uMinBufferSize

Definition: IAkStreamMgr.h:112

AkAutoStmBufSettings::uBufferSize

AkUInt32 uBufferSize

Definition: IAkStreamMgr.h:109

AkDeviceData::uLowLevelBytesTransferred

AkUInt32 uLowLevelBytesTransferred

Number of bytes transferred exclusively via low-level

Definition: IAkStreamMgr.h:145

AK::IAkDeviceProfile::OnProfileEnd

virtual void OnProfileEnd()=0

Notify device when monitor sampling ends.

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:68

AK::IAkAutoStream::GetBlockSize

virtual AkUInt32 GetBlockSize()=0

AkStreamInfo::bIsLanguageSpecific

bool bIsLanguageSpecific

True when the file was found in a language specific location

Definition: IAkStreamMgr.h:90

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:66

NULL

#define NULL

Definition: AkTypes.h:46

AkFileOpenData::IsValid

bool IsValid() const

Definition: IAkStreamMgr.h:220

AkReal32

float AkReal32

32-bit floating point

Definition: AkNumeralTypes.h:46

AkStreamData::uStreamID

AkUInt32 uStreamID

Unique stream identifier

Definition: IAkStreamMgr.h:170

AK::IAkDeviceProfile::OnProfileStart

virtual void OnProfileStart()=0

Notify device when monitor sampling starts.

AkStreamData

Stream statistics.

Definition: IAkStreamMgr.h:169

AkDeviceDesc::uStringSize

AkUInt32 uStringSize

Device name string's size (number of characters)

Definition: IAkStreamMgr.h:129

AkUtf16

AkUInt16 AkUtf16

Definition: AkTypes.h:61

AK_StmStatusIdle

@ AK_StmStatusIdle

The stream is idle

Definition: IAkStreamMgr.h:53

AkFileID

AkUInt32 AkFileID

Integer-type file identifier

Definition: AkTypes.h:77

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:134

AkFileOpenData::eOpenMode

AkOpenMode eOpenMode

Open mode.

Definition: IAkStreamMgr.h:228

AK::IAkStreamMgrProfile::~IAkStreamMgrProfile

virtual ~IAkStreamMgrProfile()

Virtual destructor on interface to avoid warnings.

Definition: IAkStreamMgr.h:344

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

AkAutoStmHeuristics::uLoopStart

AkUInt64 uLoopStart

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

Definition: IAkStreamMgr.h:97

AkStreamData::uTargetBufferingSize

AkUInt32 uTargetBufferingSize

Total stream buffer size (specific to IAkAutoStream)

Definition: IAkStreamMgr.h:174

AkAutoStmHeuristics::fThroughput

AkReal32 fThroughput

Average throughput in bytes/ms

Definition: IAkStreamMgr.h:96

AkStreamInfo

Definition: IAkStreamMgr.h:85

AK::IAkStdStream::SetStreamName

virtual AKRESULT SetStreamName(const AkOSChar *in_pszStreamName)=0

AkDeviceData::uGranularity

AkUInt32 uGranularity

IO memory pool block size

Definition: IAkStreamMgr.h:142

AkDeviceData::uFrees

AkUInt32 uFrees

Cumulative number of deallocations

Definition: IAkStreamMgr.h:139

AkStreamRecord::idFile

AkFileID idFile

Definition: IAkStreamMgr.h:160

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:148

AK::IAkStreamMgr::CreateAuto

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

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:181

AkFileOpenData::AkFileOpenData

AkFileOpenData(AkFileID in_idFile, AkFileSystemFlags *in_pFlags)

Definition: IAkStreamMgr.h:214

AkDeviceData::uMemUsed

AkUInt32 uMemUsed

IO memory pool used

Definition: IAkStreamMgr.h:137

AK_MoveCurrent

@ AK_MoveCurrent

Move offset from the current stream position

Definition: IAkStreamMgr.h:67

AK::IAkStreamMgr::Destroy

virtual void Destroy()=0

AkStreamRecord::uStreamID

AkUInt32 uStreamID

Unique stream identifier

Definition: IAkStreamMgr.h:157

AK_StmStatusPending

@ AK_StmStatusPending

Operation pending / The stream is waiting for I/O

Definition: IAkStreamMgr.h:55

AK::IAkDeviceProfile::~IAkDeviceProfile

virtual ~IAkDeviceProfile()

Virtual destructor on interface to avoid warnings.

Definition: IAkStreamMgr.h:286

AkStreamRecord

Stream general information.

Definition: IAkStreamMgr.h:156

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:67

AK::IAkStreamMgrProfile::StartMonitoring

virtual AKRESULT StartMonitoring()=0

AkDeviceDesc::deviceID

AkDeviceID deviceID

Device ID

Definition: IAkStreamMgr.h:125

AkDeviceData::uNumActiveStreams

AkUInt32 uNumActiveStreams

Number of streams that have been active in the previous frame

Definition: IAkStreamMgr.h:143

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:87

AkMemoryMgr.h

AkDeviceData::uCustomParam

AkUInt32 uCustomParam

Custom number queried from low-level IO.

Definition: IAkStreamMgr.h:150

AK::IAkStdStream::~IAkStdStream

virtual ~IAkStdStream()

Virtual destructor on interface to avoid warnings.

Definition: IAkStreamMgr.h:387

AkDeviceData::uTotalBytesTransferred

AkUInt32 uTotalBytesTransferred

Number of bytes transferred, including cached transfers

Definition: IAkStreamMgr.h:144

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:141

AkStreamRecord::deviceID

AkDeviceID deviceID

Device ID

Definition: IAkStreamMgr.h:158

AK::IAkStdStream::Destroy

virtual void Destroy()=0

AK::IAkDeviceProfile::GetStreamProfile

virtual IAkStreamProfile * GetStreamProfile(AkUInt32 in_uStreamIndex)=0

AK::IAkDeviceProfile

Definition: IAkStreamMgr.h:283

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:180

AK::IAkAutoStream::GetHeuristics

virtual void GetHeuristics(AkAutoStmHeuristics &out_heuristics)=0

AK::IAkStreamProfile

Definition: IAkStreamMgr.h:245

AkDeviceData::uAllocs

AkUInt32 uAllocs

Cumulative number of allocations

Definition: IAkStreamMgr.h:138

AkFileSystemFlags

File system flags for file descriptors mapping.

Definition: AkFileSystemFlags.h:35

AkMoveMethod

Definition: IAkStreamMgr.h:65

AkDeviceData::uMemSize

AkUInt32 uMemSize

IO memory pool size

Definition: IAkStreamMgr.h:136

AkDeviceData::uNumLowLevelRequestsPending

AkUInt32 uNumLowLevelRequestsPending

Number of low-level transfers that are currently pending

Definition: IAkStreamMgr.h:149

AkInt64

int64_t AkInt64

Signed 64-bit integer

Definition: AkNumeralTypes.h:44

AK_OpenModeWrite

@ AK_OpenModeWrite

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

Definition: IAkStreamMgr.h:75

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:54

AkStreamData::uNumBytesTransfered

AkUInt32 uNumBytesTransfered

Transfered amount since last query (Accumulate/Reset)

Definition: IAkStreamMgr.h:177

AK::IAkDeviceProfile::GetDesc

virtual void GetDesc(AkDeviceDesc &out_deviceDesc)=0

AkStmStatus

Stream status.

Definition: IAkStreamMgr.h:52

AK::IAkAutoStream

Definition: IAkStreamMgr.h:522

AkDeviceDesc::bCanWrite

bool bCanWrite

Specifies whether or not the device is writable

Definition: IAkStreamMgr.h:126

AkFileOpenData::pFlags

AkFileSystemFlags * pFlags

Flags for opening, null when unused

Definition: IAkStreamMgr.h:227

AkOpenMode

File open mode.

Definition: IAkStreamMgr.h:73

AkDeviceDesc

Device descriptor.

Definition: IAkStreamMgr.h:124

AkDeviceData::uNumLowLevelRequestsCompleted

AkUInt32 uNumLowLevelRequestsCompleted

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

Definition: IAkStreamMgr.h:147

AkStreamInfo::uSize

AkUInt64 uSize

Total stream/file size in bytes

Definition: IAkStreamMgr.h:88

AK::IAkAutoStream::~IAkAutoStream

virtual ~IAkAutoStream()

Virtual destructor on interface to avoid warnings.

Definition: IAkStreamMgr.h:525

AkFileOpenData::AkFileOpenData

AkFileOpenData(AkFileID in_idFile, AkOpenMode in_eOpenMode=AK_OpenModeRead, AkFileSystemFlags *in_pFlags=NULL)

Definition: IAkStreamMgr.h:202

AK::IAkAutoStream::Start

virtual AKRESULT Start()=0

AK::IAkStdStream::SetPosition

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

AkDeviceData::fAvgCacheEfficiency

AkReal32 fAvgCacheEfficiency

Total bytes from cache as a percentage of total bytes.

Definition: IAkStreamMgr.h:146

AK::IAkAutoStream::SetPosition

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

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:104

AkFileOpenData::AkFileOpenData

AkFileOpenData(const AkOSChar *in_pszFileName, AkOpenMode in_eOpenMode=AK_OpenModeRead, AkFileSystemFlags *in_pFlags=NULL)

Definition: IAkStreamMgr.h:196

AkDeviceData::deviceID

AkDeviceID deviceID

Device ID

Definition: IAkStreamMgr.h:135

AK::IAkStreamProfile::~IAkStreamProfile

virtual ~IAkStreamProfile()

Virtual destructor on interface to avoid warnings.

Definition: IAkStreamMgr.h:248

AK_StmStatusError

@ AK_StmStatusError

The low-level I/O reported an error

Definition: IAkStreamMgr.h:57

AK::IAkStreamMgr::CreateAuto

virtual AKRESULT CreateAuto(const AkFileOpenData &in_FileOpen, const AkAutoStmHeuristics &in_heuristics, AkAutoStmBufSettings *in_pBufferSettings, IAkAutoStream *&out_pStream, bool in_bSyncOpen, bool in_bCaching=false)=0

AkStreamRecord::szStreamName

AkUtf16 szStreamName[AK_MONITOR_STREAMNAME_MAXLENGTH]

Stream name

Definition: IAkStreamMgr.h:159

AK::IAkAutoStream::Destroy

virtual void Destroy()=0

AkFileOpenData::AkFileOpenData

AkFileOpenData(const AkOSChar *in_pszFileName, AkFileSystemFlags *in_pFlags)

Definition: IAkStreamMgr.h:208

AkStreamRecord::uStringSize

AkUInt32 uStringSize

Stream name string's size (number of characters)