Wwise SDK 2019.2.15
_ak_stream_mgr_module_8h_source
版本
menu_open
link
Wwise SDK 2019.2.15
|
AkStreamMgrModule.h
浏览该文件的文档.
31 /// Contains the default Stream Manager's implementation-specific interfaces that altogether constitute
32 /// the Low-Level I/O submodule. This submodule needs to be implemented by the game. All I/O requests
66 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.
67 AkUInt32 uIOMemoryAlignment; ///< I/O memory alignment. It is passed directly to AK::MemoryMgr::Malign().
68 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().
72 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.
73 AkUInt32 uMaxConcurrentIO; ///< Maximum number of transfers that can be sent simultaneously to the Low-Level I/O (applies to AK_SCHEDULER_DEFERRED_LINED_UP device only).
74 bool bUseStreamCache; ///< If true the device attempts to reuse IO buffers that have already been streamed from disk. This is particularly useful when streaming small looping sounds. The drawback is a small CPU hit when allocating memory, and a slightly larger memory footprint in the StreamManager pool.
75 AkUInt32 uMaxCachePinnedBytes; ///< Maximum number of bytes that can be "pinned" using AK::SoundEngine::PinEventInStreamCache() or AK::IAkStreamMgr::PinFileInCache()
80 /// Requests to Low-Level IO are synchronous. The streaming device expects a blocking I/O hook at creation time (IAkIOHookBlocking interface, see CreateDevice()).
83 /// Requests to Low-Level IO are asynchronous, but posted one after the other, starting with streams that need data the most.
84 /// The streaming device expects a deferred I/O hook at creation time (IAkIOHookDeferredBatch interface, see CreateDevice()).
85 /// Up to AkDeviceSettings::uMaxConcurrentIO requests can be sent to the Low-Level I/O at the same time.
101 AkDeviceID deviceID; ///< Device ID, obtained from CreateDevice() \sa AK::IAkStreamMgr::CreateDevice()
105 /// Structure for synchronous transfers handshaking with the Low-Level I/O. Used with blocking I/O hooks.
111 AkUInt32 uRequestedSize; ///< Exact number of requested bytes for this transfer. Always equal to or smaller than uBufferSize.
116 /// Callback function prototype definition used for asynchronous I/O transfers between the Stream Manager
119 /// - 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.
120 /// - If the transfer was cancelled by the Stream Manager while it was in the Low-Level IO, you must return AK_Success, whether
121 /// 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.
126 AkAsyncIOTransferInfo * in_pTransferInfo, ///< Pointer to the AkAsyncIOTransferInfo structure that was passed to corresponding Read() or Write() call.
127 AKRESULT in_eResult ///< Result of transfer: AK_Success or AK_Fail (streams waiting for this transfer become invalid).
130 /// Callback function prototype definition used for asynchronous I/O transfers between the Stream Manager
134 /// - 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.
135 /// - 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
136 /// 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.
137 /// - 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
144 AkAsyncIOTransferInfo** in_ppTransferInfo, ///< List of pointers to AkAsyncIOTransferInfo structures that were previously passed in to BatchRead() or BatchWrite()
145 AKRESULT* in_peResult ///< Array of results of each transfer: AK_Success or AK_Fail (streams waiting for this transfer become invalid).
148 /// Structure for asynchronous transfers handshaking with the Low-Level I/O. Extends AkIOTransferInfo.
156 AkIOCallback pCallback; ///< Callback function used to notify the high-level device when the transfer is complete.
157 void * pCookie; ///< Reserved. The I/O device uses this cookie to retrieve the owner of the transfer.
171 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.
180 // Audiokinetic Stream Manager's implementation-specific interfaces of the Low-Level IO submodule.
253 /// Read data from the file described by in_fileDesc, in address out_pBuffer and with size and position
254 /// passed within io_transferInfo. When transfer is complete, return with the proper return code.
258 /// device as "in_fileDesc.uSector * Block_Size + Stream_Position", where Block_Size is obtained
271 /// Write data to the file described by in_fileDesc, from address in_pData and with size and position
272 /// passed within io_transferInfo. When transfer is complete, return with the proper return code.
275 /// device as "in_fileDesc.uSector * Block_Size + Stream_Position", where Block_Size is obtained
301 /// AkAsyncIOTransferInfo::pCallback for an individual item, or AkBatchIOCallback for a collection
303 /// Cancel() is provided in order to inform you that the streaming device will flush this transfer
321 /// - Queue up multiple read requests at once, using the provided array of in_pTransferItems. There will
323 /// - io_pDispatchResults will contain an in_uNumTransfers number of items in the array. Each item in
324 /// io_pDispatchResults should be set to AK_Success if the corresponding Read was successfully dispatched,
325 /// and set to AK_Failure otherwise. As well, the return value should be a cumulative result of the
327 /// io_pDispatchResults will not be investigated, whereas AK_Fail indicates at least one failure.
328 /// - When a given Read, or some set of reads has completed - whether it was successful, cancelled,
330 /// AkAsyncIOTransferInfo objects to receive the callback, as well as a list of results for each transfer,
331 /// e.g. AK_Success or some other AKRESULT. Do not call in_pBatchIoCallback for transfers that were not
334 /// device is notified through the callback. The array of in_pTransferItems will not be valid, though.
335 /// - File position passed in each BatchIoTransferItem::pTransferInfo takes the offset of this file relative
348 AkBatchIOCallback in_pBatchIoCallback, ///< Callback to execute to handle completion of multiple items simultaneously
349 AKRESULT* io_pDispatchResults ///< Output result codes to indicate if a transfer was successfully dispatched
354 /// - Queue up multiple write requests at once, using the provided array of in_pTransferItems. There will
356 /// - io_pDispatchResults will contain an in_uNumTransfers number of items in the array. Each item in
357 /// io_pDispatchResults should be set to AK_Success if the corresponding write was successfully dispatched,
358 /// and set to AK_Failure otherwise. As well, the return value should be a cumulative result of the
360 /// io_pDispatchResults will not be investigated, whereas AK_Fail indicates at least one failure.
361 /// - When a given write, or some set of writes has completed - whether it was successful, cancelled,
363 /// AkAsyncIOTransferInfo objects to receive the callback, as well as a list of results for each transfer,
364 /// e.g. AK_Success or some other AKRESULT. Do not call in_pBatchIoCallback for transfers that were not
367 /// device is notified through the callback. The array of in_pTransferItems will not be valid, though.
368 /// - File position passed in each BatchIoTransferItem::pTransferInfo takes the offset of this file relative
381 AkBatchIOCallback in_pBatchIoCallback, ///< Callback to execute to handle completion of multiple items simultaneously
382 AKRESULT* io_pDispatchResults ///< Output result codes to indicate if a transfer was successfully dispatched
385 /// Notifies that a transfer request is cancelled. It will be flushed by the streaming device when completed.
386 /// Cancellation is normal and happens regularly; for example, whenever a sound stops before the end
387 /// or stops looping. It happens even more frequently when buffering (AkDeviceSettings::fTargetAutoStmBufferLength
388 /// and AkDeviceSettings::uGranularity) is large and when you low-level IO hook accepts many concurrent requests
391 /// - Cancel() simply informs the Low-Level I/O that a specific transfer will be flushed upon reception.
392 /// The Low-Level I/O may use this information to stop this transfer right away, or not (it is internally tagged
393 /// by the high-level device as cancelled). Nevertheless, the callback function MUST be called for cancelled
395 /// - When calling the callback function of a cancelled transfer, pass it *AK_Success*. Passing AK_Fail
396 /// to AkAsyncIOTransfer::pCallback has the effect of killing the stream once and for all. This is not
398 /// - If io_bCancelAllTransfersForThisFile is set, you may cancel all transfers for this file at once.
399 /// Leave io_bCancelAllTransfersForThisFile to true if you don't want to be called again. For example, if
400 /// you don't do anything special in Cancel(), leave it to true. This will reduce the amount of useless calls.
401 /// If you set it to false, Cancel() will be called again for each remaining pending transfer that need to be cancelled.
402 /// - If io_bCancelAllTransfersForThisFile is not set, Cancel() is only called for a subset of pending
403 /// 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.
405 /// - The calling thread holds the stream's lock. You may call the callback function directly from here
406 /// (if you can guarantee that the I/O buffer will not be accessed in the meantime), but you must not wait here
408 /// - Likewise, if you resolve transfers with your own thread and use a lock to protect your transfers queue,
409 /// be careful not to run into a deadlock. Cancel() can be executed by any thread. Thus, if you need to lock your queue
410 /// in Cancel(), you must never hold this lock when calling back transfers, either from within Cancel() or from your
411 /// worker thread's routine. Lock your list, dequeue the transfer if you can, unlock, and call pCallback if and only if
412 /// the transfer was found and dequeued. On the other hand, if you choose not to do anything in Cancel(), the lock only protects
413 /// your list between Read()/Write() and your worker thread's routine, and since the device I/O thread does not hold the
414 /// stream's lock while calling Read()/Write(), your worker thread may therefore hold it while calling back transfers.
415 /// - A race condition exists when cancelling all transfers (io_bCancelAllTransfersForThisFile is true) directly from within this hook.
416 /// If you handle the io_bCancelAllTransfersForThisFile == true case, you need to defer calling the completion callback to later
417 /// (from your usual I/O completion thread, for example). This will be fixed in a future version of Wwise.
421 bool** io_ppbCancelAllTransfersForThisFile ///< Flag for each transfer indicating whether all transfers should be cancelled for this file (see notes in function description).
432 /// I/O streaming technology. You will receive up to AkDeviceSettings::uMaxConcurrentIO requests
433 /// at the same time. You may queue them into your own system, and even use the heuristics passed
443 /// Cancel() is provided in order to inform you that the streaming device will flush this transfer
454 /// - Queue up your read request with address, size and file position specified in io_transferInfo.
464 /// device as "in_fileDesc.uSector * Block_Size + Stream_Position", where Block_Size is obtained
478 /// - Queue up your write request with address, size and file position specified in io_transferInfo.
480 /// AkAsyncIOTransferInfo::pCallback. However, if you return AK_Fail() from Write(), do not call
488 /// device as "in_fileDesc.uSector * Block_Size + Stream_Position", where Block_Size is obtained
500 /// Notifies that a transfer request is cancelled. It will be flushed by the streaming device when completed.
501 /// Cancellation is normal and happens regularly; for example, whenever a sound stops before the end
502 /// or stops looping. It happens even more frequently when buffering (AkDeviceSettings::fTargetAutoStmBufferLength
503 /// and AkDeviceSettings::uGranularity) is large and when you low-level IO hook accepts many concurrent requests
506 /// - Cancel() simply informs the Low-Level I/O that a specific transfer will be flushed upon reception.
507 /// The Low-Level I/O may use this information to stop this transfer right away, or not (it is internally tagged
508 /// by the high-level device as cancelled). Nevertheless, the callback function MUST be called for cancelled
510 /// - When calling the callback function of a cancelled transfer, pass it *AK_Success*. Passing AK_Fail
511 /// to AkAsyncIOTransfer::pCallback has the effect of killing the stream once and for all. This is not
513 /// - If io_bCancelAllTransfersForThisFile is set, you may cancel all transfers for this file at once.
514 /// Leave io_bCancelAllTransfersForThisFile to true if you don't want to be called again. For example, if
515 /// you don't do anything special in Cancel(), leave it to true. This will reduce the amount of useless calls.
516 /// If you set it to false, Cancel() will be called again for each remaining pending transfer that need to be cancelled.
517 /// - If io_bCancelAllTransfersForThisFile is not set, Cancel() is only called for a subset of pending
518 /// 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.
520 /// - The calling thread holds the stream's lock. You may call the callback function directly from here
521 /// (if you can guarantee that the I/O buffer will not be accessed in the meantime), but you must not wait here
523 /// - Likewise, if you resolve transfers with your own thread and use a lock to protect your transfers queue,
524 /// be careful not to run into a deadlock. Cancel() can be executed by any thread. Thus, if you need to lock your queue
525 /// in Cancel(), you must never hold this lock when calling back transfers, either from within Cancel() or from your
526 /// worker thread's routine. Lock your list, dequeue the transfer if you can, unlock, and call pCallback if and only if
527 /// the transfer was found and dequeued. On the other hand, if you choose not to do anything in Cancel(), the lock only protects
528 /// your list between Read()/Write() and your worker thread's routine, and since the device I/O thread does not hold the
529 /// stream's lock while calling Read()/Write(), your worker thread may therefore hold it while calling back transfers.
530 /// - A race condition exists when cancelling all transfers (io_bCancelAllTransfersForThisFile is true) directly from within this hook.
531 /// If you handle the io_bCancelAllTransfersForThisFile == true case, you need to defer calling the completion callback to later
532 /// (from your usual I/O completion thread, for example). This will be fixed in a future version of Wwise.
536 bool & io_bCancelAllTransfersForThisFile ///< Flag indicating whether all transfers should be cancelled for this file (see notes in function description).
539 /// The following functions each provide "stub" implementations of IAkHookDeferredIOBatch operations, so as to forward calls to
540 /// the existing single-transfer variants. The soundengine never calls IAkHookDeferred::Read et al, internally, and only
545 AkBatchIOCallback /*in_pBatchIoCallback*/,///< Callback to execute to handle completion of multiple items simultaneously
546 AKRESULT* io_pDispatchResults ///< Output result codes to indicate if a transfer was successfully dispatched
553 AKRESULT result = Read(*(ioTransferItem.pFileDesc), ioTransferItem.ioHeuristics, *(ioTransferItem.pTransferInfo));
563 AkBatchIOCallback /*in_pBatchIoCallback*/,///< Callback to execute to handle completion of multiple items simultaneously
564 AKRESULT* io_pDispatchResults ///< Output result codes to indicate if a transfer was successfully dispatched
571 AKRESULT result = Write(*(ioTransferItem.pFileDesc), ioTransferItem.ioHeuristics, *(ioTransferItem.pTransferInfo));
580 bool** io_ppbCancelAllTransfersForThisFile ///< Flag for each transfer indicating whether all transfers should be cancelled for this file (see notes in function description).
586 Cancel(*(ioTransferItem.pFileDesc), *(ioTransferItem.pTransferInfo), *(io_ppbCancelAllTransfersForThisFile[i]));
593 /// registered to the Stream Manager (using AK::StreamMgr::SetFileLocationResolver()). Its purpose
601 /// If you wish to create multiple devices, then you should have a separate object that implements
602 /// AK::StreamMgr::IAkFileLocationResolver and registers to the Stream Manager as such. This object
603 /// will be used to dispatch the file open request to the appropriate device. The strategy you will
660 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.
711 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.
739 AkStreamMgrSettings & out_settings ///< Returned AkStreamMgrSettings structure with default values.
752 IAkFileLocationResolver * in_pFileLocationResolver ///< Interface to your File Location Resolver
762 /// \return The device ID. AK_INVALID_DEVICE_ID if there was an error and it could not be created.
766 /// deferred hook (IAkIOHookDeferredBatch) with SCHEDULER_DEFERRED_LINED_UP devices (these flags are
768 /// statically cast internally into one of these hooks. Implementing the wrong (or no) interface
773 /// - The returned device ID should be kept by the Low-Level IO, to assign it to file descriptors
781 IAkLowLevelIOHook * in_pLowLevelHook ///< Associated low-level I/O hook. Pass either a IAkIOHookBlocking or a IAkIOHookDeferredBatch interface, consistent with the type of the scheduler.
785 /// \warning This function is not thread-safe. No stream should exist for that device when it is destroyed.
803 /// Set the current language once and only once, here. The language name is stored in a static buffer
805 /// AK::StreamMgr::IAkFileLocationResolver implementations query this string. They may use it to
806 /// construct a file path (for e.g. SDK/samples/SoundEngine/Common/AkFileLocationBase.cpp), or to
807 /// find a language-specific file within a look-up table (for e.g. SDK/samples/SoundEngine/Common/AkFilePackageLUT.cpp).
808 /// Pass a valid null-terminated string, without a trailing slash or backslash. Empty strings are accepted.
811 /// \return AK_Success if successful (if language string has less than AK_MAX_LANGUAGE_NAME_SIZE characters). AK_Fail otherwise.
820 /// Get the current language. The language name is stored in a static buffer inside the Stream Manager,
821 /// with AK::StreamMgr::SetCurrentLanguage(). In order to resolve localized (language-specific) file location,
822 /// AK::StreamMgr::IAkFileLocationResolver implementations query this string. They may use it to
823 /// construct a file path (for e.g. SDK/samples/SoundEngine/Common/AkFileLocationBase.cpp), or to
824 /// 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:157
virtual ~IAkIOHookDeferred()
Virtual destructor on interface to avoid warnings.
Definition: AkStreamMgrModule.h:449
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:67
Base interface for Low-Level I/O hooks. Defines common methods across both types of hooks.
Definition: AkStreamMgrModule.h:185
Definition: AkStreamMgrModule.h:154
Definition: AkPlatformFuncs.h:48
Definition: AkStreamMgrModule.h:92
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:836
AkUInt32 uMaxCachePinnedBytes
Maximum number of bytes that can be "pinned" using AK::SoundEngine::PinEventInStreamCache() or AK::IA...
Definition: AkStreamMgrModule.h:75
AkAsyncIOTransferInfo * pTransferInfo
Definition: AkStreamMgrModule.h:316
AkUInt32 uRequestedSize
Exact number of requested bytes for this transfer. Always equal to or smaller than uBufferSize.
Definition: AkStreamMgrModule.h:111
virtual void BatchCancel(AkUInt32 in_uNumTransfers, BatchIoTransferItem *in_pTransferItems, bool **io_ppbCancelAllTransfersForThisFile)=0
Definition: IAkStreamMgr.h:686
AkUInt32 uMaxConcurrentIO
Maximum number of transfers that can be sent simultaneously to the Low-Level I/O (applies to AK_SCHED...
Definition: AkStreamMgrModule.h:73
AkReal32 fTargetAutoStmBufferLength
Targetted automatic stream buffer length (ms). When a stream reaches that buffering,...
Definition: AkStreamMgrModule.h:72
bool bUseStreamCache
If true the device attempts to reuse IO buffers that have already been streamed from disk....
Definition: AkStreamMgrModule.h:74
AKSOUNDENGINE_API void GetDefaultSettings(AkStreamMgrSettings &out_settings)
virtual ~IAkLowLevelIOHook()
Virtual destructor on interface to avoid warnings.
Definition: AkStreamMgrModule.h:188
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:171
void(* AkIOCallback)(AkAsyncIOTransferInfo *in_pTransferInfo, AKRESULT in_eResult)
Definition: AkStreamMgrModule.h:125
AkUInt32 ePoolAttributes
Attributes for I/O memory. Here, specify the allocation type (AkMemType_Device, and so on)....
Definition: AkStreamMgrModule.h:68
Definition: AkStreamMgrModule.h:62
virtual ~IAkIOHookDeferredBatch()
Virtual destructor on interface to avoid warnings.
Definition: AkStreamMgrModule.h:309
AkUInt32 uBufferSize
Size of the buffer in which the I/O hook can write to.
Definition: AkStreamMgrModule.h:110
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:69
Definition: AkStreamMgrModule.h:169
virtual void BatchCancel(AkUInt32 in_uNumTransfers, BatchIoTransferItem *in_pTransferItems, bool **io_ppbCancelAllTransfersForThisFile)
Definition: AkStreamMgrModule.h:577
virtual AKRESULT BatchWrite(AkUInt32 in_uNumTransfers, BatchIoTransferItem *in_pTransferItems, AkBatchIOCallback, AKRESULT *io_pDispatchResults)
Definition: AkStreamMgrModule.h:560
virtual void GetDeviceDesc(AkDeviceDesc &out_deviceDesc)=0
AkFileDesc * pFileDesc
Definition: AkStreamMgrModule.h:314
CAkFilePackage * pPackage
If this file is in a File Package, this will be the
Definition: AkStreamMgrModule.h:102
virtual AkUInt32 GetBlockSize(AkFileDesc &in_fileDesc)=0
Definition: AkStreamMgrModule.h:108
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:156
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
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:142
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:611
virtual ~IAkIOHookBlocking()
Virtual destructor on interface to avoid warnings.
Definition: AkStreamMgrModule.h:248
AkUInt32 uIOMemorySize
Size of memory for I/O (for automatic streams). It is passed directly to AK::MemoryMgr::Malign(),...
Definition: AkStreamMgrModule.h:66
Definition: AkStreamMgrModule.h:53
virtual AKRESULT BatchRead(AkUInt32 in_uNumTransfers, BatchIoTransferItem *in_pTransferItems, AkBatchIOCallback, AKRESULT *io_pDispatchResults)
Definition: AkStreamMgrModule.h:542
virtual AKRESULT Write(AkFileDesc &in_fileDesc, const AkIoHeuristics &in_heuristics, AkAsyncIOTransferInfo &io_transferInfo)=0
AkIoHeuristics ioHeuristics
Definition: AkStreamMgrModule.h:315
AKSOUNDENGINE_API const AkOSChar * GetCurrentLanguage()