Wwise SDK 2022.1.8
_ak_stream_mgr_module_8h_source
Version
menu_open
link
Wwise SDK 2022.1.8
|
AkStreamMgrModule.h
Go to the documentation of this file.
30 /// Contains the default Stream Manager's implementation-specific interfaces that altogether constitute
31 /// the Low-Level I/O submodule. This submodule needs to be implemented by the game. All I/O requests
65 AkUInt32 uIOMemorySize; ///< Size of memory for I/O (for automatic streams). It is passed directly to AK::MemoryMgr::Malign(), after having been rounded down to a multiple of uGranularity.
66 AkUInt32 uIOMemoryAlignment; ///< I/O memory alignment. It is passed directly to AK::MemoryMgr::Malign().
67 AkUInt32 ePoolAttributes; ///< Attributes for I/O memory. Here, specify the allocation type (AkMemType_Device, and so on). It is passed directly to AK::MemoryMgr::Malign().
71 AkReal32 fTargetAutoStmBufferLength; ///< Targetted automatic stream buffer length (ms). When a stream reaches that buffering, it stops being scheduled for I/O except if the scheduler is idle.
72 AkUInt32 uMaxConcurrentIO; ///< Maximum number of transfers that can be sent simultaneously to the Low-Level I/O.
73 bool bUseStreamCache; ///< If true, the device attempts to reuse I/O buffers that have already been streamed from disk. This is particularly useful when streaming small looping sounds. However, there is a small increase in CPU usage when allocating memory, and a slightly larger memory footprint in the StreamManager pool.
74 AkUInt32 uMaxCachePinnedBytes; ///< Maximum number of bytes that can be "pinned" using AK::SoundEngine::PinEventInStreamCache() or AK::IAkStreamMgr::PinFileInCache()
79 /// Requests to Low-Level IO are synchronous. The streaming device expects a blocking I/O hook at creation time (IAkIOHookBlocking interface, see CreateDevice()).
82 /// Requests to Low-Level IO are asynchronous, but posted one after the other, starting with streams that need data the most.
83 /// The streaming device expects a deferred I/O hook at creation time (IAkIOHookDeferredBatch interface, see CreateDevice()).
84 /// Up to AkDeviceSettings::uMaxConcurrentIO requests can be sent to the Low-Level I/O at the same time.
100 AkDeviceID deviceID; ///< Device ID, obtained from CreateDevice() \sa AK::IAkStreamMgr::CreateDevice()
104 /// Structure for synchronous transfers handshaking with the Low-Level I/O. Used with blocking I/O hooks.
110 AkUInt32 uRequestedSize; ///< Exact number of requested bytes for this transfer. Always equal to or smaller than uBufferSize.
115 /// Callback function prototype definition used for asynchronous I/O transfers between the Stream Manager
118 /// - If you pass in_eResult of AK_Fail, all streams awaiting for this transfer are marked as invalid and will stop. An "IO error" notification is posted to the capture log.
119 /// - If the transfer was cancelled by the Stream Manager while it was in the Low-Level IO, you must return AK_Success, whether
120 /// you performed the operation or not. The Stream Manager knows that it was cancelled, so it will not try to use it after you call it back.
125 AkAsyncIOTransferInfo * in_pTransferInfo, ///< Pointer to the AkAsyncIOTransferInfo structure that was passed to corresponding Read() or Write() call.
126 AKRESULT in_eResult ///< Result of transfer: AK_Success or AK_Fail (streams waiting for this transfer become invalid).
129 /// Callback function prototype definition used for asynchronous I/O transfers between the Stream Manager
133 /// - For each in_peResult with a value of AK_Fail, all streams awaiting for the corresponding transfer are marked as invalid and will stop. An "IO error" notification is posted to the capture log.
134 /// - If a given transfer was cancelled by the Stream Manager while it was in the Low-Level IO, you must return AK_Success for that result, whether
135 /// you performed the operation or not. The Stream Manager knows that it was cancelled, so it will not try to use it after you call it back.
136 /// - Note that one call to BatchRead, BatchWrite or BatchCancel does not have to result in one execution of the callback. The only requirement is that
143 AkAsyncIOTransferInfo** in_ppTransferInfo, ///< List of pointers to AkAsyncIOTransferInfo structures that were previously passed in to BatchRead() or BatchWrite()
144 AKRESULT* in_peResult ///< Array of results of each transfer: AK_Success or AK_Fail (streams waiting for this transfer become invalid).
147 /// Structure for asynchronous transfers handshaking with the Low-Level I/O. Extends AkIOTransferInfo.
155 AkIOCallback pCallback; ///< Callback function used to notify the high-level device when the transfer is complete.
156 void * pCookie; ///< Reserved. The I/O device uses this cookie to retrieve the owner of the transfer.
170 AkPriority priority; ///< Operation priority (at the time it was scheduled and sent to the Low-Level I/O). Range is [AK_MIN_PRIORITY,AK_MAX_PRIORITY], inclusively.
179 /// Audiokinetic Stream Manager's implementation-specific interfaces of the Low-Level IO submodule.
252 /// Read data from the file described by in_fileDesc, in address out_pBuffer and with size and position
253 /// passed within io_transferInfo. When transfer is complete, return with the proper return code.
257 /// device as "in_fileDesc.uSector * Block_Size + Stream_Position", where Block_Size is obtained
270 /// Write data to the file described by in_fileDesc, from address in_pData and with size and position
271 /// passed within io_transferInfo. When transfer is complete, return with the proper return code.
274 /// device as "in_fileDesc.uSector * Block_Size + Stream_Position", where Block_Size is obtained
300 /// AkAsyncIOTransferInfo::pCallback for an individual item, or AkBatchIOCallback for a collection
302 /// Cancel() is provided in order to inform you that the streaming device will flush this transfer
320 /// - Queue up multiple read requests at once, using the provided array of in_pTransferItems. There will
322 /// - io_pDispatchResults will contain an in_uNumTransfers number of items in the array. Each item in
323 /// io_pDispatchResults should be set to AK_Success if the corresponding Read was successfully dispatched,
324 /// and set to AK_Failure otherwise. As well, the return value should be a cumulative result of the
326 /// io_pDispatchResults will not be investigated, whereas AK_Fail indicates at least one failure.
327 /// - When a given Read, or some set of reads has completed - whether it was successful, cancelled,
329 /// AkAsyncIOTransferInfo objects to receive the callback, as well as a list of results for each transfer,
330 /// e.g. AK_Success or some other AKRESULT. Do not call in_pBatchIoCallback for transfers that were not
333 /// device is notified through the callback. The array of in_pTransferItems will not be valid, though.
334 /// - File position passed in each BatchIoTransferItem::pTransferInfo takes the offset of this file relative
347 AkBatchIOCallback in_pBatchIoCallback, ///< Callback to execute to handle completion of multiple items simultaneously
348 AKRESULT* io_pDispatchResults ///< Output result codes to indicate if a transfer was successfully dispatched
353 /// - Queue up multiple write requests at once, using the provided array of in_pTransferItems. There will
355 /// - io_pDispatchResults will contain an in_uNumTransfers number of items in the array. Each item in
356 /// io_pDispatchResults should be set to AK_Success if the corresponding write was successfully dispatched,
357 /// and set to AK_Failure otherwise. As well, the return value should be a cumulative result of the
359 /// io_pDispatchResults will not be investigated, whereas AK_Fail indicates at least one failure.
360 /// - When a given write, or some set of writes has completed - whether it was successful, cancelled,
362 /// AkAsyncIOTransferInfo objects to receive the callback, as well as a list of results for each transfer,
363 /// e.g. AK_Success or some other AKRESULT. Do not call in_pBatchIoCallback for transfers that were not
366 /// device is notified through the callback. The array of in_pTransferItems will not be valid, though.
367 /// - File position passed in each BatchIoTransferItem::pTransferInfo takes the offset of this file relative
380 AkBatchIOCallback in_pBatchIoCallback, ///< Callback to execute to handle completion of multiple items simultaneously
381 AKRESULT* io_pDispatchResults ///< Output result codes to indicate if a transfer was successfully dispatched
384 /// Notifies that a transfer request is cancelled. It will be flushed by the streaming device when completed.
385 /// Cancellation is normal and happens regularly; for example, whenever a sound stops before the end
386 /// or stops looping. It happens even more frequently when buffering (AkDeviceSettings::fTargetAutoStmBufferLength
387 /// and AkDeviceSettings::uGranularity) is large and when you low-level IO hook accepts many concurrent requests
390 /// - Cancel() simply informs the Low-Level I/O that a specific transfer will be flushed upon reception.
391 /// The Low-Level I/O may use this information to stop this transfer right away, or not (it is internally tagged
392 /// by the high-level device as cancelled). Nevertheless, the callback function MUST be called for cancelled
394 /// - When calling the callback function of a cancelled transfer, pass it *AK_Success*. Passing AK_Fail
395 /// to AkAsyncIOTransfer::pCallback has the effect of killing the stream once and for all. This is not
397 /// - If io_bCancelAllTransfersForThisFile is set, you may cancel all transfers for this file at once.
398 /// Leave io_bCancelAllTransfersForThisFile to true if you don't want to be called again. For example, if
399 /// you don't do anything special in Cancel(), leave it to true. This will reduce the amount of useless calls.
400 /// If you set it to false, Cancel() will be called again for each remaining pending transfer that need to be cancelled.
401 /// - If io_bCancelAllTransfersForThisFile is not set, Cancel() is only called for a subset of pending
402 /// transfers for this file. You must not set it to true, as Cancel() needs to be called explicitly for each transfer that should be cancelled.
404 /// - The calling thread holds the stream's lock. You may call the callback function directly from here
405 /// (if you can guarantee that the I/O buffer will not be accessed in the meantime), but you must not wait here
407 /// - Likewise, if you resolve transfers with your own thread and use a lock to protect your transfers queue,
408 /// be careful not to run into a deadlock. Cancel() can be executed by any thread. Thus, if you need to lock your queue
409 /// in Cancel(), you must never hold this lock when calling back transfers, either from within Cancel() or from your
410 /// worker thread's routine. Lock your list, dequeue the transfer if you can, unlock, and call pCallback if and only if
411 /// the transfer was found and dequeued. On the other hand, if you choose not to do anything in Cancel(), the lock only protects
412 /// your list between Read()/Write() and your worker thread's routine, and since the device I/O thread does not hold the
413 /// stream's lock while calling Read()/Write(), your worker thread may therefore hold it while calling back transfers.
414 /// - A race condition exists when cancelling all transfers (io_bCancelAllTransfersForThisFile is true) directly from within this hook.
415 /// If you handle the io_bCancelAllTransfersForThisFile == true case, you need to defer calling the completion callback to later
416 /// (from your usual I/O completion thread, for example). This will be fixed in a future version of Wwise.
420 bool** io_ppbCancelAllTransfersForThisFile ///< Flag for each transfer indicating whether all transfers should be cancelled for this file (see notes in function description).
431 /// I/O streaming technology. You will receive up to AkDeviceSettings::uMaxConcurrentIO requests
432 /// at the same time. You may queue them into your own system, and even use the heuristics passed
442 /// Cancel() is provided in order to inform you that the streaming device will flush this transfer
453 /// - Queue up your read request with address, size and file position specified in io_transferInfo.
463 /// device as "in_fileDesc.uSector * Block_Size + Stream_Position", where Block_Size is obtained
477 /// - Queue up your write request with address, size and file position specified in io_transferInfo.
479 /// AkAsyncIOTransferInfo::pCallback. However, if you return AK_Fail() from Write(), do not call
487 /// device as "in_fileDesc.uSector * Block_Size + Stream_Position", where Block_Size is obtained
499 /// Notifies that a transfer request is cancelled. It will be flushed by the streaming device when completed.
500 /// Cancellation is normal and happens regularly; for example, whenever a sound stops before the end
501 /// or stops looping. It happens even more frequently when buffering (AkDeviceSettings::fTargetAutoStmBufferLength
502 /// and AkDeviceSettings::uGranularity) is large and when you low-level IO hook accepts many concurrent requests
505 /// - Cancel() simply informs the Low-Level I/O that a specific transfer will be flushed upon reception.
506 /// The Low-Level I/O may use this information to stop this transfer right away, or not (it is internally tagged
507 /// by the high-level device as cancelled). Nevertheless, the callback function MUST be called for cancelled
509 /// - When calling the callback function of a cancelled transfer, pass it *AK_Success*. Passing AK_Fail
510 /// to AkAsyncIOTransfer::pCallback has the effect of killing the stream once and for all. This is not
512 /// - If io_bCancelAllTransfersForThisFile is set, you may cancel all transfers for this file at once.
513 /// Leave io_bCancelAllTransfersForThisFile to true if you don't want to be called again. For example, if
514 /// you don't do anything special in Cancel(), leave it to true. This will reduce the amount of useless calls.
515 /// If you set it to false, Cancel() will be called again for each remaining pending transfer that need to be cancelled.
516 /// - If io_bCancelAllTransfersForThisFile is not set, Cancel() is only called for a subset of pending
517 /// transfers for this file. You must not set it to true, as Cancel() needs to be called explicitly for each transfer that should be cancelled.
519 /// - The calling thread holds the stream's lock. You may call the callback function directly from here
520 /// (if you can guarantee that the I/O buffer will not be accessed in the meantime), but you must not wait here
522 /// - Likewise, if you resolve transfers with your own thread and use a lock to protect your transfers queue,
523 /// be careful not to run into a deadlock. Cancel() can be executed by any thread. Thus, if you need to lock your queue
524 /// in Cancel(), you must never hold this lock when calling back transfers, either from within Cancel() or from your
525 /// worker thread's routine. Lock your list, dequeue the transfer if you can, unlock, and call pCallback if and only if
526 /// the transfer was found and dequeued. On the other hand, if you choose not to do anything in Cancel(), the lock only protects
527 /// your list between Read()/Write() and your worker thread's routine, and since the device I/O thread does not hold the
528 /// stream's lock while calling Read()/Write(), your worker thread may therefore hold it while calling back transfers.
529 /// - A race condition exists when cancelling all transfers (io_bCancelAllTransfersForThisFile is true) directly from within this hook.
530 /// If you handle the io_bCancelAllTransfersForThisFile == true case, you need to defer calling the completion callback to later
531 /// (from your usual I/O completion thread, for example). This will be fixed in a future version of Wwise.
535 bool & io_bCancelAllTransfersForThisFile ///< Flag indicating whether all transfers should be cancelled for this file (see notes in function description).
538 /// The following functions each provide "stub" implementations of IAkHookDeferredIOBatch operations, so as to forward calls to
539 /// the existing single-transfer variants. The soundengine never calls IAkHookDeferred::Read et al, internally, and only
544 AkBatchIOCallback /*in_pBatchIoCallback*/,///< Callback to execute to handle completion of multiple items simultaneously
545 AKRESULT* io_pDispatchResults ///< Output result codes to indicate if a transfer was successfully dispatched
552 AKRESULT result = Read(*(ioTransferItem.pFileDesc), ioTransferItem.ioHeuristics, *(ioTransferItem.pTransferInfo));
562 AkBatchIOCallback /*in_pBatchIoCallback*/,///< Callback to execute to handle completion of multiple items simultaneously
563 AKRESULT* io_pDispatchResults ///< Output result codes to indicate if a transfer was successfully dispatched
570 AKRESULT result = Write(*(ioTransferItem.pFileDesc), ioTransferItem.ioHeuristics, *(ioTransferItem.pTransferInfo));
579 bool** io_ppbCancelAllTransfersForThisFile ///< Flag for each transfer indicating whether all transfers should be cancelled for this file (see notes in function description).
585 Cancel(*(ioTransferItem.pFileDesc), *(ioTransferItem.pTransferInfo), *(io_ppbCancelAllTransfersForThisFile[i]));
592 /// registered to the Stream Manager (using AK::StreamMgr::SetFileLocationResolver()). Its purpose
600 /// If you wish to create multiple devices, then you should have a separate object that implements
601 /// AK::StreamMgr::IAkFileLocationResolver and registers to the Stream Manager as such. This object
602 /// will be used to dispatch the file open request to the appropriate device. The strategy you will
659 bool & io_bSyncOpen, ///< If true, the file must be opened synchronously. Otherwise it is left at the File Location Resolver's discretion. Return false if Open needs to be deferred.
704 bool & io_bSyncOpen, ///< If true, the file must be opened synchronously. Otherwise it is left at the File Location Resolver's discretion. Return false if Open needs to be deferred.
709 /// This function is called to provide information when file related errors occur. The base paths known by this Resolver should be returned in out_searchedPath.
716 AkOSChar* out_searchedPath, ///< Pre-allocated string buffer to be filled with all searched paths searched for the file.
725 AkOSChar* out_searchedPath, ///< Pre-allocated string buffer to be filled with all searched paths searched for the file.
753 AkStreamMgrSettings & out_settings ///< Returned AkStreamMgrSettings structure with default values.
766 IAkFileLocationResolver * in_pFileLocationResolver ///< Interface to your File Location Resolver
776 /// \return The device ID. AK_INVALID_DEVICE_ID if there was an error and it could not be created.
780 /// deferred hook (IAkIOHookDeferredBatch) with SCHEDULER_DEFERRED_LINED_UP devices (these flags are
782 /// statically cast internally into one of these hooks. Implementing the wrong (or no) interface
787 /// - The returned device ID should be kept by the Low-Level IO, to assign it to file descriptors
795 IAkLowLevelIOHook * in_pLowLevelHook ///< Associated low-level I/O hook. Pass either a IAkIOHookBlocking or a IAkIOHookDeferredBatch interface, consistent with the type of the scheduler.
799 /// \warning This function is not thread-safe. No stream should exist for that device when it is destroyed.
805 /// This should only be called in single-threaded environments where an I/O device cannot spawn a thread.
824 /// Set the current language once and only once, here. The language name is stored in a static buffer
826 /// AK::StreamMgr::IAkFileLocationResolver implementations query this string. They may use it to
827 /// construct a file path (for e.g. SDK/samples/SoundEngine/Common/AkFileLocationBase.cpp), or to
828 /// find a language-specific file within a look-up table (for e.g. SDK/samples/SoundEngine/Common/AkFilePackageLUT.cpp).
829 /// Pass a valid null-terminated string, without a trailing slash or backslash. Empty strings are accepted.
832 /// \return AK_Success if successful (if language string has less than AK_MAX_LANGUAGE_NAME_SIZE characters). AK_Fail otherwise.
841 /// Get the current language. The language name is stored in a static buffer inside the Stream Manager,
842 /// with AK::StreamMgr::SetCurrentLanguage(). In order to resolve localized (language-specific) file location,
843 /// AK::StreamMgr::IAkFileLocationResolver implementations query this string. They may use it to
844 /// construct a file path (for e.g. SDK/samples/SoundEngine/Common/AkFileLocationBase.cpp), or to
845 /// find a language-specific file within a look-up table (for e.g. SDK/samples/SoundEngine/Common/AkFilePackageLUT.cpp).
void * pCookie
Reserved. The I/O device uses this cookie to retrieve the owner of the transfer.
Definition: AkStreamMgrModule.h:156
virtual ~IAkIOHookDeferred()
Virtual destructor on interface to avoid warnings.
Definition: AkStreamMgrModule.h:448
virtual AKRESULT BatchWrite(AkUInt32 in_uNumTransfers, BatchIoTransferItem *in_pTransferItems, AkBatchIOCallback in_pBatchIoCallback, AKRESULT *io_pDispatchResults)=0
AkUInt32 uIOMemoryAlignment
I/O memory alignment. It is passed directly to AK::MemoryMgr::Malign().
Definition: AkStreamMgrModule.h:66
Base interface for Low-Level I/O hooks. Defines common methods across both types of hooks.
Definition: AkStreamMgrModule.h:184
Definition: AkStreamMgrModule.h:153
Definition: AkPlatformFuncs.h:47
Definition: AkStreamMgrModule.h:91
AKSOUNDENGINE_API AKRESULT DestroyDevice(AkDeviceID in_deviceID)
AKSOUNDENGINE_API AKRESULT SetCurrentLanguage(const AkOSChar *in_pszLanguageName)
virtual AKRESULT Open(const AkOSChar *in_pszFileName, AkOpenMode in_eOpenMode, AkFileSystemFlags *in_pFlags, bool &io_bSyncOpen, AkFileDesc &io_fileDesc)=0
virtual AkUInt32 GetDeviceData()=0
void(* AkLanguageChangeHandler)(const AkOSChar *const in_pLanguageName, void *in_pCookie)
Definition: AkStreamMgrModule.h:857
AkUInt32 uMaxCachePinnedBytes
Maximum number of bytes that can be "pinned" using AK::SoundEngine::PinEventInStreamCache() or AK::IA...
Definition: AkStreamMgrModule.h:74
AkAsyncIOTransferInfo * pTransferInfo
Definition: AkStreamMgrModule.h:315
AkUInt32 uRequestedSize
Exact number of requested bytes for this transfer. Always equal to or smaller than uBufferSize.
Definition: AkStreamMgrModule.h:110
virtual void BatchCancel(AkUInt32 in_uNumTransfers, BatchIoTransferItem *in_pTransferItems, bool **io_ppbCancelAllTransfersForThisFile)=0
Definition: IAkStreamMgr.h:687
AkUInt32 uMaxConcurrentIO
Maximum number of transfers that can be sent simultaneously to the Low-Level I/O.
Definition: AkStreamMgrModule.h:72
AkReal32 fTargetAutoStmBufferLength
Targetted automatic stream buffer length (ms). When a stream reaches that buffering,...
Definition: AkStreamMgrModule.h:71
bool bUseStreamCache
If true, the device attempts to reuse I/O buffers that have already been streamed from disk....
Definition: AkStreamMgrModule.h:73
AKSOUNDENGINE_API void GetDefaultSettings(AkStreamMgrSettings &out_settings)
virtual AKRESULT OutputSearchedPaths(const AKRESULT &in_result, const AkFileID in_fileID, AkFileSystemFlags *in_pFlags, AkOpenMode in_eOpenMode, AkOSChar *out_searchedPath, AkInt32 in_pathSize)
Definition: AkStreamMgrModule.h:720
virtual ~IAkLowLevelIOHook()
Virtual destructor on interface to avoid warnings.
Definition: AkStreamMgrModule.h:187
virtual AKRESULT Open(AkFileID in_fileID, AkOpenMode in_eOpenMode, AkFileSystemFlags *in_pFlags, bool &io_bSyncOpen, AkFileDesc &io_fileDesc)=0
AkPriority priority
Operation priority (at the time it was scheduled and sent to the Low-Level I/O). Range is [AK_MIN_PRI...
Definition: AkStreamMgrModule.h:170
void(* AkIOCallback)(AkAsyncIOTransferInfo *in_pTransferInfo, AKRESULT in_eResult)
Definition: AkStreamMgrModule.h:124
AkUInt32 ePoolAttributes
Attributes for I/O memory. Here, specify the allocation type (AkMemType_Device, and so on)....
Definition: AkStreamMgrModule.h:67
Definition: AkStreamMgrModule.h:61
virtual ~IAkIOHookDeferredBatch()
Virtual destructor on interface to avoid warnings.
Definition: AkStreamMgrModule.h:308
AkUInt32 uBufferSize
Size of the buffer in which the I/O hook can write to.
Definition: AkStreamMgrModule.h:109
virtual void Cancel(AkFileDesc &in_fileDesc, AkAsyncIOTransferInfo &io_transferInfo, bool &io_bCancelAllTransfersForThisFile)=0
AKSOUNDENGINE_API AkDeviceID CreateDevice(const AkDeviceSettings &in_settings, IAkLowLevelIOHook *in_pLowLevelHook)
AkUInt32 uGranularity
I/O requests granularity (typical bytes/request).
Definition: AkStreamMgrModule.h:68
Definition: AkStreamMgrModule.h:168
virtual void BatchCancel(AkUInt32 in_uNumTransfers, BatchIoTransferItem *in_pTransferItems, bool **io_ppbCancelAllTransfersForThisFile)
Definition: AkStreamMgrModule.h:576
virtual AKRESULT BatchWrite(AkUInt32 in_uNumTransfers, BatchIoTransferItem *in_pTransferItems, AkBatchIOCallback, AKRESULT *io_pDispatchResults)
Definition: AkStreamMgrModule.h:559
virtual void GetDeviceDesc(AkDeviceDesc &out_deviceDesc)=0
AKSOUNDENGINE_API AKRESULT PerformIO()
AkFileDesc * pFileDesc
Definition: AkStreamMgrModule.h:313
CAkFilePackage * pPackage
If this file is in a File Package, this will be the.
Definition: AkStreamMgrModule.h:101
virtual AkUInt32 GetBlockSize(AkFileDesc &in_fileDesc)=0
Definition: AkStreamMgrModule.h:107
virtual AKRESULT Close(AkFileDesc &in_fileDesc)=0
AkIOCallback pCallback
Callback function used to notify the high-level device when the transfer is complete.
Definition: AkStreamMgrModule.h:155
virtual AKRESULT Read(AkFileDesc &in_fileDesc, const AkIoHeuristics &in_heuristics, AkAsyncIOTransferInfo &io_transferInfo)=0
AKSOUNDENGINE_API IAkFileLocationResolver * GetFileLocationResolver()
virtual AKRESULT BatchRead(AkUInt32 in_uNumTransfers, BatchIoTransferItem *in_pTransferItems, AkBatchIOCallback in_pBatchIoCallback, AKRESULT *io_pDispatchResults)=0
AKSOUNDENGINE_API IAkStreamMgr * Create(const AkStreamMgrSettings &in_settings)
AKSOUNDENGINE_API void FlushAllCaches()
virtual AKRESULT Write(AkFileDesc &in_fileDesc, const AkIoHeuristics &in_heuristics, void *in_pData, AkIOTransferInfo &io_transferInfo)=0
virtual AKRESULT OutputSearchedPaths(const AKRESULT &in_result, const AkOSChar *in_pszFileName, AkFileSystemFlags *in_pFlags, AkOpenMode in_eOpenMode, AkOSChar *out_searchedPath, AkInt32 in_pathSize)
This function is called to provide information when file related errors occur. The base paths known b...
Definition: AkStreamMgrModule.h:711
AKSOUNDENGINE_API void GetDefaultDeviceSettings(AkDeviceSettings &out_settings)
virtual AKRESULT Read(AkFileDesc &in_fileDesc, const AkIoHeuristics &in_heuristics, void *out_pBuffer, AkIOTransferInfo &in_transferInfo)=0
void(* AkBatchIOCallback)(AkUInt32 in_uNumTransfers, AkAsyncIOTransferInfo **in_ppTransferInfo, AKRESULT *in_peResult)
Definition: AkStreamMgrModule.h:141
AKSOUNDENGINE_API void SetFileLocationResolver(IAkFileLocationResolver *in_pFileLocationResolver)
AKSOUNDENGINE_API void RemoveLanguageChangeObserver(void *in_pCookie)
AKSOUNDENGINE_API AKRESULT AddLanguageChangeObserver(AkLanguageChangeHandler in_handler, void *in_pCookie)
virtual ~IAkFileLocationResolver()
Virtual destructor on interface to avoid warnings.
Definition: AkStreamMgrModule.h:610
virtual ~IAkIOHookBlocking()
Virtual destructor on interface to avoid warnings.
Definition: AkStreamMgrModule.h:247
AkUInt32 uIOMemorySize
Size of memory for I/O (for automatic streams). It is passed directly to AK::MemoryMgr::Malign(),...
Definition: AkStreamMgrModule.h:65
Definition: AkStreamMgrModule.h:52
virtual AKRESULT BatchRead(AkUInt32 in_uNumTransfers, BatchIoTransferItem *in_pTransferItems, AkBatchIOCallback, AKRESULT *io_pDispatchResults)
Definition: AkStreamMgrModule.h:541
virtual AKRESULT Write(AkFileDesc &in_fileDesc, const AkIoHeuristics &in_heuristics, AkAsyncIOTransferInfo &io_transferInfo)=0
AkIoHeuristics ioHeuristics
Definition: AkStreamMgrModule.h:314
AKSOUNDENGINE_API const AkOSChar * GetCurrentLanguage()
Was this page helpful?
Need Support?
Questions? Problems? Need more info? Contact us, and we can help!
Visit our Support pageTell us about your project. We're here to help.
Register your project and we'll help you get started with no strings attached!
Get started with Wwise