Wwise SDK
_ak_stream_mgr_module_8h_source
版本
menu_open
link
Wwise SDK 2022.1.13
|
AkStreamMgrModule.h
浏览该文件的文档.
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()