Wwise SDK 2019.2.15
_ak_stream_mgr_module_8h_source
Version
menu_open
link
Wwise SDK 2019.2.15
|
AkStreamMgrModule.h
Go to the documentation of this file.
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()
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