| /* Copyright (c) 2012 The Chromium OS Authors. All rights reserved. |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| /* |
| * cras_iodev represents playback or capture devices on the system. Each iodev |
| * will attach to a thread to render or capture audio. For playback, this |
| * thread will gather audio from the streams that are attached to the device and |
| * render the samples it gets to the iodev. For capture the process is |
| * reversed, the samples are pulled from the device and passed on to the |
| * attached streams. |
| */ |
| #ifndef CRAS_IODEV_H_ |
| #define CRAS_IODEV_H_ |
| |
| #include "cras_dsp.h" |
| #include "cras_iodev_info.h" |
| #include "cras_messages.h" |
| |
| struct buffer_share; |
| struct cras_ramp; |
| struct cras_rstream; |
| struct cras_audio_area; |
| struct cras_audio_format; |
| struct audio_thread; |
| struct cras_iodev; |
| struct rate_estimator; |
| |
| /* Callback type for loopback listeners. When enabled, this is called from the |
| * playback path of an iodev with the samples that are being played back. |
| */ |
| typedef int (*loopback_hook_t)(const uint8_t *frames, unsigned int nframes, |
| const struct cras_audio_format *fmt, |
| void *cb_data); |
| |
| /* State of an iodev. |
| * no_stream state is only supported on output device. |
| * Open state is only supported for device supporting start ops. |
| */ |
| enum CRAS_IODEV_STATE { |
| CRAS_IODEV_STATE_CLOSE = 0, |
| CRAS_IODEV_STATE_OPEN = 1, |
| CRAS_IODEV_STATE_NORMAL_RUN = 2, |
| CRAS_IODEV_STATE_NO_STREAM_RUN = 3, |
| }; |
| |
| /* Holds an output/input node for this device. An ionode is a control that |
| * can be switched on and off such as headphones or speakers. |
| * Members: |
| * dev - iodev which this node belongs to. |
| * idx - ionode index. |
| * plugged - true if the device is plugged. |
| * plugged_time - If plugged is true, this is the time it was attached. |
| * volume - per-node volume (0-100) |
| * capture_gain - per-node capture gain/attenuation (in 100*dBFS) |
| * left_right_swapped - If left and right output channels are swapped. |
| * type - Type displayed to the user. |
| * position - Specify where on the system this node locates. |
| * mic_positions - Whitespace-separated microphone positions using Cartesian |
| * coordinates in meters with ordering x, y, z. The string is formatted as: |
| * "x1 y1 z1 ... xn yn zn" for an n-microphone array. |
| * name - Name displayed to the user. |
| * active_hotword_model - name of the currently selected hotword model. |
| * softvol_scalers - pointer to software volume scalers. |
| * software_volume_needed - For output: True if the volume range of the node |
| * is smaller than desired. For input: True if this node needs software |
| * gain. |
| * max_software_gain - The maximum software gain in dBm if needed. |
| * stable_id - id for node that doesn't change after unplug/plug. |
| * stable_id_new - New stable_id, it will be deprecated and be put on |
| * stable_id. |
| */ |
| struct cras_ionode { |
| struct cras_iodev *dev; |
| uint32_t idx; |
| int plugged; |
| struct timeval plugged_time; |
| unsigned int volume; |
| long capture_gain; |
| int left_right_swapped; |
| enum CRAS_NODE_TYPE type; |
| enum CRAS_NODE_POSITION position; |
| char mic_positions[CRAS_NODE_MIC_POS_BUFFER_SIZE]; |
| char name[CRAS_NODE_NAME_BUFFER_SIZE]; |
| char active_hotword_model[CRAS_NODE_HOTWORD_MODEL_BUFFER_SIZE]; |
| float *softvol_scalers; |
| int software_volume_needed; |
| long max_software_gain; |
| unsigned int stable_id; |
| unsigned int stable_id_new; |
| struct cras_ionode *prev, *next; |
| }; |
| |
| /* An input or output device, that can have audio routed to/from it. |
| * set_volume - Function to call if the system volume changes. |
| * set_mute - Function to call if the system mute state changes. |
| * set_capture_gain - Function to call if the system capture_gain changes. |
| * set_capture_mute - Function to call if the system capture mute state changes. |
| * set_swap_mode_for_node - Function to call to set swap mode for the node. |
| * open_dev - Opens the device. |
| * close_dev - Closes the device if it is open. |
| * update_supported_formats - Refresh supported frame rates and channel counts. |
| * frames_queued - The number of frames in the audio buffer, and fills tstamp |
| * with the associated timestamp. The timestamp is {0, 0} when |
| * the device hasn't started processing data (and on error). |
| * delay_frames - The delay of the next sample in frames. |
| * get_buffer - Returns a buffer to read/write to/from. |
| * put_buffer - Marks a buffer from get_buffer as read/written. |
| * flush_buffer - Flushes the buffer and return the number of frames flushed. |
| * start - Starts running device. This is optionally supported on output device. |
| * If device supports this ops, device can be in CRAS_IODEV_STATE_OPEN |
| * state after being opened. |
| * If device does not support this ops, then device will be in |
| * CRAS_IODEV_STATE_NO_STREAM_RUN. |
| * no_stream - (Optional) When there is no stream, we let device keep running |
| * for some time to save the time to open device for the next |
| * stream. This is the no stream state of an output device. |
| * The default action of no stream state is to fill zeros |
| * periodically. Device can implement this function to define |
| * its own optimization of entering/exiting no stream state. |
| * output_should_wake - (Optional) Checks if audio thread should schedule a |
| * wake for this output device. The default condition is |
| * whether the device is running. Device can implement this |
| * function to use its own condition. |
| * output_underrun - (Optional) Handle output device underrun. |
| * update_active_node - Update the active node when the selected device/node has |
| * changed. |
| * update_channel_layout - Update the channel layout base on set iodev->format, |
| * expect the best available layout be filled to iodev->format. |
| * set_hotword_model - Sets the hotword model to this iodev. |
| * get_hotword_models - Gets a comma separated string of the list of supported |
| * hotword models of this iodev. |
| * get_num_underruns - Gets number of underrun recorded so far. |
| * get_num_severe_underruns - Gets number of severe underrun recorded since |
| * iodev was created. |
| * format - The audio format being rendered or captured to hardware. |
| * ext_format - The audio format that is visible to the rest of the system. |
| * This can be different than the hardware if the device dsp changes it. |
| * rate_est - Rate estimator to estimate the actual device rate. |
| * area - Information about how the samples are stored. |
| * info - Unique identifier for this device (index and name). |
| * nodes - The output or input nodes available for this device. |
| * active_node - The current node being used for playback or capture. |
| * direction - Input or Output. |
| * supported_rates - Array of sample rates supported by device 0-terminated. |
| * supported_channel_counts - List of number of channels supported by device. |
| * supported_formats - List of audio formats (s16le, s32le) supported by device. |
| * buffer_size - Size of the audio buffer in frames. |
| * min_buffer_level - Extra frames to keep queued in addition to requested. |
| * dsp_context - The context used for dsp processing on the audio data. |
| * dsp_name - The "dsp_name" dsp variable specified in the ucm config. |
| * is_enabled - True if this iodev is enabled, false otherwise. |
| * software_volume_needed - True if volume control is not supported by hardware. |
| * streams - List of audio streams serviced by dev. |
| * state - Device is in one of close, open, normal, or no_stream state defined |
| * in enum CRAS_IODEV_STATE. |
| * min_cb_level - min callback level of any stream attached. |
| * max_cb_level - max callback level of any stream attached. |
| * buf_state - If multiple streams are writing to this device, then this |
| * keeps track of how much each stream has written. |
| * idle_timeout - The timestamp when to close the dev after being idle. |
| * pre_dsp_hook - Hook called before applying DSP, but after mixing. Used for |
| * system loopback. |
| * post_dsp_hook - Hook called after applying DSP. Can be used for echo |
| * reference. |
| * pre_dsp_hook_cb_data - Callback data that will be passing to pre_dsp_hook. |
| * post_dsp_hook_cb_data - Callback data that will be passing to post_dsp_hook. |
| * reset_request_pending - The flag for pending reset request. |
| * ramp - The cras_ramp struct to control ramping up/down at mute/unmute and |
| * start of playback. |
| */ |
| struct cras_iodev { |
| void (*set_volume)(struct cras_iodev *iodev); |
| void (*set_mute)(struct cras_iodev *iodev); |
| void (*set_capture_gain)(struct cras_iodev *iodev); |
| void (*set_capture_mute)(struct cras_iodev *iodev); |
| int (*set_swap_mode_for_node)(struct cras_iodev *iodev, |
| struct cras_ionode *node, |
| int enable); |
| int (*open_dev)(struct cras_iodev *iodev); |
| int (*close_dev)(struct cras_iodev *iodev); |
| int (*update_supported_formats)(struct cras_iodev *iodev); |
| int (*frames_queued)(const struct cras_iodev *iodev, |
| struct timespec *tstamp); |
| int (*delay_frames)(const struct cras_iodev *iodev); |
| int (*get_buffer)(struct cras_iodev *iodev, |
| struct cras_audio_area **area, |
| unsigned *frames); |
| int (*put_buffer)(struct cras_iodev *iodev, unsigned nwritten); |
| int (*flush_buffer)(struct cras_iodev *iodev); |
| int (*start)(const struct cras_iodev *iodev); |
| int (*output_should_wake)(const struct cras_iodev *iodev); |
| int (*output_underrun)(struct cras_iodev *iodev); |
| int (*no_stream)(struct cras_iodev *iodev, int enable); |
| void (*update_active_node)(struct cras_iodev *iodev, |
| unsigned node_idx, unsigned dev_enabled); |
| int (*update_channel_layout)(struct cras_iodev *iodev); |
| int (*set_hotword_model)(struct cras_iodev *iodev, |
| const char *model_name); |
| char *(*get_hotword_models)(struct cras_iodev *iodev); |
| unsigned int (*get_num_underruns)(const struct cras_iodev *iodev); |
| unsigned int (*get_num_severe_underruns)(const struct cras_iodev *iodev); |
| struct cras_audio_format *format; |
| struct cras_audio_format *ext_format; |
| struct rate_estimator *rate_est; |
| struct cras_audio_area *area; |
| struct cras_iodev_info info; |
| struct cras_ionode *nodes; |
| struct cras_ionode *active_node; |
| enum CRAS_STREAM_DIRECTION direction; |
| size_t *supported_rates; |
| size_t *supported_channel_counts; |
| snd_pcm_format_t *supported_formats; |
| snd_pcm_uframes_t buffer_size; |
| unsigned int min_buffer_level; |
| struct cras_dsp_context *dsp_context; |
| const char *dsp_name; |
| int is_enabled; |
| int software_volume_needed; |
| struct dev_stream *streams; |
| enum CRAS_IODEV_STATE state; |
| unsigned int min_cb_level; |
| unsigned int max_cb_level; |
| struct buffer_share *buf_state; |
| struct timespec idle_timeout; |
| loopback_hook_t pre_dsp_hook; |
| loopback_hook_t post_dsp_hook; |
| void *pre_dsp_hook_cb_data; |
| void *post_dsp_hook_cb_data; |
| int reset_request_pending; |
| struct cras_ramp* ramp; |
| struct cras_iodev *prev, *next; |
| }; |
| |
| /* |
| * Ramp request used in cras_iodev_start_ramp. |
| * |
| * - CRAS_IODEV_RAMP_REQUEST_UP_UNMUTE: Mute->unmute. |
| * Change device to unmute state after ramping is stared, |
| * that is, (a) in the plot. |
| * |
| * ____ |
| * .... / |
| * _____/ |
| * (a) |
| * |
| * - CRAS_IODEV_RAMP_REQUEST_DOWN_MUTE: Unmute->mute. |
| * Change device to mute state after ramping is done, that is, |
| * (b) in the plot. |
| * |
| * _____ |
| * \.... |
| * \____ |
| * (b) |
| * |
| * - CRAS_IODEV_RAMP_REQUEST_UP_START_PLAYBACK: Ramping is requested because |
| * first sample of new stream is ready, there is no need to change mute/unmute |
| * state. |
| */ |
| |
| enum CRAS_IODEV_RAMP_REQUEST { |
| CRAS_IODEV_RAMP_REQUEST_UP_UNMUTE = 0, |
| CRAS_IODEV_RAMP_REQUEST_DOWN_MUTE = 1, |
| CRAS_IODEV_RAMP_REQUEST_UP_START_PLAYBACK = 2, |
| }; |
| |
| /* |
| * Utility functions to be used by iodev implementations. |
| */ |
| |
| /* Sets up the iodev for the given format if possible. If the iodev can't |
| * handle the requested format, format conversion will happen in dev_stream. |
| * It also allocates a dsp context for the iodev. |
| * Args: |
| * iodev - the iodev you want the format for. |
| * fmt - the desired format. |
| */ |
| int cras_iodev_set_format(struct cras_iodev *iodev, |
| const struct cras_audio_format *fmt); |
| |
| /* Clear the format previously set for this iodev. |
| * |
| * Args: |
| * iodev - the iodev you want to free the format. |
| */ |
| void cras_iodev_free_format(struct cras_iodev *iodev); |
| |
| /* Initializes the audio area for this iodev. |
| * Args: |
| * iodev - the iodev to init audio area |
| * num_channels - the total number of channels |
| */ |
| void cras_iodev_init_audio_area(struct cras_iodev *iodev, |
| int num_channels); |
| |
| /* Frees the audio area for this iodev. |
| * Args: |
| * iodev - the iodev to free audio area |
| */ |
| void cras_iodev_free_audio_area(struct cras_iodev *iodev); |
| |
| /* Free resources allocated for this iodev. |
| * |
| * Args: |
| * iodev - the iodev you want to free the resources for. |
| */ |
| void cras_iodev_free_resources(struct cras_iodev *iodev); |
| |
| /* Fill timespec ts with the time to sleep based on the number of frames and |
| * frame rate. |
| * Args: |
| * frames - Number of frames in buffer.. |
| * frame_rate - 44100, 48000, etc. |
| * ts - Filled with the time to sleep for. |
| */ |
| void cras_iodev_fill_time_from_frames(size_t frames, |
| size_t frame_rate, |
| struct timespec *ts); |
| |
| /* Sets the timestamp for when the next sample will be rendered. Determined by |
| * combining the current time with the playback latency specified in frames. |
| * Args: |
| * frame_rate - in Hz. |
| * frames - Delay specified in frames. |
| * ts - Filled with the time that the next sample will be played. |
| */ |
| void cras_iodev_set_playback_timestamp(size_t frame_rate, |
| size_t frames, |
| struct cras_timespec *ts); |
| |
| /* Sets the time that the first sample in the buffer was captured at the ADC. |
| * Args: |
| * frame_rate - in Hz. |
| * frames - Delay specified in frames. |
| * ts - Filled with the time that the next sample was captured. |
| */ |
| void cras_iodev_set_capture_timestamp(size_t frame_rate, |
| size_t frames, |
| struct cras_timespec *ts); |
| |
| /* Update the "dsp_name" dsp variable. This may cause the dsp pipeline to be |
| * reloaded. |
| * Args: |
| * iodev - device which the state changes. |
| */ |
| void cras_iodev_update_dsp(struct cras_iodev *iodev); |
| |
| |
| /* Sets swap mode on a node using dsp. This function can be called when |
| * dsp pipline is not created yet. It will take effect when dsp pipeline |
| * is created later. If there is dsp pipeline, this function causes the dsp |
| * pipeline to be reloaded and swap mode takes effect right away. |
| * Args: |
| * iodev - device to be changed for swap mode. |
| * node - the node to be changed for swap mode. |
| * enable - 1 to enable swap mode, 0 otherwise. |
| * Returns: |
| * 0 on success, error code on failure. |
| */ |
| int cras_iodev_dsp_set_swap_mode_for_node(struct cras_iodev *iodev, |
| struct cras_ionode *node, |
| int enable); |
| |
| /* Handles a plug event happening on this node. |
| * Args: |
| * node - ionode on which a plug event was detected. |
| * plugged - true if the device was plugged, false for unplugged. |
| */ |
| void cras_ionode_plug_event(struct cras_ionode *node, int plugged); |
| |
| /* Returns true if node a is preferred over node b. */ |
| int cras_ionode_better(struct cras_ionode *a, struct cras_ionode *b); |
| |
| /* Sets an attribute of an ionode on a device. |
| * Args: |
| * ionode - ionode whose attribute we want to change. |
| * attr - the attribute we want to change. |
| * value - the value we want to set. |
| */ |
| int cras_iodev_set_node_attr(struct cras_ionode *ionode, |
| enum ionode_attr attr, int value); |
| |
| /* Adds a node to the iodev's node list. */ |
| void cras_iodev_add_node(struct cras_iodev *iodev, struct cras_ionode *node); |
| |
| /* Removes a node from iodev's node list. */ |
| void cras_iodev_rm_node(struct cras_iodev *iodev, struct cras_ionode *node); |
| |
| /* Assign a node to be the active node of the device */ |
| void cras_iodev_set_active_node(struct cras_iodev *iodev, |
| struct cras_ionode *node); |
| |
| /* Adjust the system volume based on the volume of the given node. */ |
| static inline unsigned int cras_iodev_adjust_node_volume( |
| const struct cras_ionode *node, |
| unsigned int system_volume) |
| { |
| unsigned int node_vol_offset = 100 - node->volume; |
| |
| if (system_volume > node_vol_offset) |
| return system_volume - node_vol_offset; |
| else |
| return 0; |
| } |
| |
| /* Get the volume scaler for the active node. */ |
| static inline unsigned int cras_iodev_adjust_active_node_volume( |
| struct cras_iodev *iodev, unsigned int system_volume) |
| { |
| if (!iodev->active_node) |
| return system_volume; |
| |
| return cras_iodev_adjust_node_volume(iodev->active_node, system_volume); |
| } |
| |
| /* Get the gain adjusted based on system for the active node. */ |
| static inline long cras_iodev_adjust_active_node_gain( |
| const struct cras_iodev *iodev, long system_gain) |
| { |
| if (!iodev->active_node) |
| return system_gain; |
| |
| return iodev->active_node->capture_gain + system_gain; |
| } |
| |
| /* Returns true if the active node of the iodev needs software volume. */ |
| static inline int cras_iodev_software_volume_needed( |
| const struct cras_iodev *iodev) |
| { |
| if (iodev->software_volume_needed) |
| return 1; |
| |
| if (!iodev->active_node) |
| return 0; |
| |
| return iodev->active_node->software_volume_needed; |
| } |
| |
| /* Returns maximum software gain for the iodev. |
| * Args: |
| * iodev - The device. |
| * Returs: |
| * 0 if software gain is not needed, or if there is no active node. |
| * Returns max_software_gain on active node if there is one. */ |
| static inline long cras_iodev_maximum_software_gain( |
| const struct cras_iodev *iodev) |
| { |
| if (!cras_iodev_software_volume_needed(iodev)) |
| return 0; |
| if (!iodev->active_node) |
| return 0; |
| return iodev->active_node->max_software_gain; |
| } |
| |
| /* Gets the software gain scaler should be applied on the deivce. |
| * Args: |
| * iodev - The device. |
| * Returns: |
| * A scaler translated from system gain and active node gain dBm value. |
| * Returns 1.0 if software gain is not needed. */ |
| float cras_iodev_get_software_gain_scaler(const struct cras_iodev *iodev); |
| |
| /* Gets the software volume scaler of the iodev. The scaler should only be |
| * applied if the device needs software volume. */ |
| float cras_iodev_get_software_volume_scaler(struct cras_iodev *iodev); |
| |
| /* Indicate that a stream has been added from the device. */ |
| int cras_iodev_add_stream(struct cras_iodev *iodev, |
| struct dev_stream *stream); |
| |
| /* Indicate that a stream has been removed from the device. */ |
| struct dev_stream *cras_iodev_rm_stream(struct cras_iodev *iodev, |
| const struct cras_rstream *stream); |
| |
| /* Get the offset of this stream into the dev's buffer. */ |
| unsigned int cras_iodev_stream_offset(struct cras_iodev *iodev, |
| struct dev_stream *stream); |
| |
| /* Get the maximum offset of any stream into the dev's buffer. */ |
| unsigned int cras_iodev_max_stream_offset(const struct cras_iodev *iodev); |
| |
| /* Tell the device how many frames the given stream wrote. */ |
| void cras_iodev_stream_written(struct cras_iodev *iodev, |
| struct dev_stream *stream, |
| unsigned int nwritten); |
| |
| /* All streams have written what they can, update the write pointers and return |
| * the amount that has been filled by all streams and can be comitted to the |
| * device. |
| */ |
| unsigned int cras_iodev_all_streams_written(struct cras_iodev *iodev); |
| |
| /* Return the state of an iodev. */ |
| enum CRAS_IODEV_STATE cras_iodev_state(const struct cras_iodev *iodev); |
| |
| /* Open an iodev, does setup and invokes the open_dev callback. */ |
| int cras_iodev_open(struct cras_iodev *iodev, unsigned int cb_level); |
| |
| /* Open an iodev, does teardown and invokes the close_dev callback. */ |
| int cras_iodev_close(struct cras_iodev *iodev); |
| |
| /* Gets the available buffer to write/read audio.*/ |
| int cras_iodev_buffer_avail(struct cras_iodev *iodev, unsigned hw_level); |
| |
| /* Marks a buffer from get_buffer as read. */ |
| int cras_iodev_put_input_buffer(struct cras_iodev *iodev, unsigned int nframes); |
| |
| /* Marks a buffer from get_buffer as written. */ |
| int cras_iodev_put_output_buffer(struct cras_iodev *iodev, uint8_t *frames, |
| unsigned int nframes); |
| |
| /* Returns a buffer to read from. |
| * Args: |
| * iodev - The device. |
| * area - Filled with a pointer to the audio to read/write. |
| * frames - Filled with the number of frames that can be read/written. |
| */ |
| int cras_iodev_get_input_buffer(struct cras_iodev *iodev, |
| struct cras_audio_area **area, |
| unsigned *frames); |
| |
| /* Returns a buffer to read from. |
| * Args: |
| * iodev - The device. |
| * area - Filled with a pointer to the audio to read/write. |
| * frames - Filled with the number of frames that can be read/written. |
| */ |
| int cras_iodev_get_output_buffer(struct cras_iodev *iodev, |
| struct cras_audio_area **area, |
| unsigned *frames); |
| |
| /* Update the estimated sample rate of the device. */ |
| int cras_iodev_update_rate(struct cras_iodev *iodev, unsigned int level, |
| struct timespec *level_tstamp); |
| |
| /* Resets the rate estimator of the device. */ |
| int cras_iodev_reset_rate_estimator(const struct cras_iodev *iodev); |
| |
| /* Returns the rate of estimated frame rate and the claimed frame rate of |
| * the device. */ |
| double cras_iodev_get_est_rate_ratio(const struct cras_iodev *iodev); |
| |
| /* Get the delay from DSP processing in frames. */ |
| int cras_iodev_get_dsp_delay(const struct cras_iodev *iodev); |
| |
| /* Returns the number of frames in the hardware buffer. |
| * Args: |
| * iodev - The device. |
| * tstamp - The associated hardware time stamp. |
| * Returns: |
| * Number of frames in the hardware buffer. |
| * Returns -EPIPE if there is severe underrun. |
| */ |
| int cras_iodev_frames_queued(struct cras_iodev *iodev, |
| struct timespec *tstamp); |
| |
| /* Get the delay for input/output in frames. */ |
| static inline int cras_iodev_delay_frames(const struct cras_iodev *iodev) |
| { |
| return iodev->delay_frames(iodev) + cras_iodev_get_dsp_delay(iodev); |
| } |
| |
| /* Returns true if the device is open. */ |
| static inline int cras_iodev_is_open(const struct cras_iodev *iodev) |
| { |
| if (iodev && iodev->state != CRAS_IODEV_STATE_CLOSE) |
| return 1; |
| return 0; |
| } |
| |
| /* Register a pre-dsp loopback hook. Pass NULL to clear. */ |
| void cras_iodev_register_pre_dsp_hook(struct cras_iodev *iodev, |
| loopback_hook_t loop_cb, |
| void *cb_data); |
| |
| /* Register a post-dsp loopback hook. Pass NULL to clear. */ |
| void cras_iodev_register_post_dsp_hook(struct cras_iodev *iodev, |
| loopback_hook_t loop_cb, |
| void *cb_data); |
| |
| /* Put 'frames' worth of zero samples into odev. */ |
| int cras_iodev_fill_odev_zeros(struct cras_iodev *odev, unsigned int frames); |
| |
| /* Gets the number of frames to play when audio thread sleeps. |
| * Args: |
| * iodev[in] - The device. |
| * hw_level[out] - Pointer to number of frames in hardware. |
| * hw_tstamp[out] - Pointer to the timestamp for hw_level. |
| * Returns: |
| * Number of frames to play in sleep for this output device. |
| */ |
| unsigned int cras_iodev_frames_to_play_in_sleep(struct cras_iodev *odev, |
| unsigned int *hw_level, |
| struct timespec *hw_tstamp); |
| |
| /* Checks if audio thread should wake for this output device. |
| * Args: |
| * iodev[in] - The output device. |
| * Returns: |
| * 1 if audio thread should wake for this output device. 0 otherwise. |
| */ |
| int cras_iodev_odev_should_wake(const struct cras_iodev *odev); |
| |
| /* The default implementation of no_stream ops. |
| * The default behavior is to fill some zeros when entering no stream state. |
| * Note that when a device in no stream state enters into no stream state again, |
| * device needs to fill some zeros again. |
| * Do nothing to leave no stream state. |
| * Args: |
| * iodev[in] - The output device. |
| * enable[in] - 1 to enter no stream playback, 0 to leave. |
| * Returns: |
| * 0 on success. Negative error code on failure. |
| * */ |
| int cras_iodev_default_no_stream_playback(struct cras_iodev *odev, int enable); |
| |
| |
| /* Get current state of iodev. |
| * Args: |
| * iodev[in] - The device. |
| * Returns: |
| * One of states defined in CRAS_IODEV_STATE. |
| */ |
| enum CRAS_IODEV_STATE cras_iodev_state(const struct cras_iodev *iodev); |
| |
| /* Possibly transit state for output device. |
| * Check if this output device needs to transit from open state/no_stream state |
| * into normal run state. If device does not need transition and is still in |
| * no stream state, call no_stream ops to do its work for one cycle. |
| * Args: |
| * odev[in] - The output device. |
| * Returns: |
| * 0 on success. Negative error code on failure. |
| */ |
| int cras_iodev_prepare_output_before_write_samples(struct cras_iodev *odev); |
| |
| /* Get number of underruns recorded so far. |
| * Args: |
| * iodev[in] - The device. |
| * Returns: |
| * An unsigned int for number of underruns recorded. |
| */ |
| unsigned int cras_iodev_get_num_underruns(const struct cras_iodev *iodev); |
| |
| /* Get number of severe underruns recorded so far. |
| * Args: |
| * iodev[in] - The device. |
| * Returns: |
| * An unsigned int for number of severe underruns recorded since iodev |
| * was created. |
| */ |
| unsigned int cras_iodev_get_num_severe_underruns( |
| const struct cras_iodev *iodev); |
| |
| /* Request main thread to re-open device. This should be used in audio thread |
| * when it finds device is in a bad state. The request will be ignored if |
| * there is still a pending request. |
| * Args: |
| * iodev[in] - The device. |
| * Returns: |
| * 0 on success. Negative error code on failure. |
| */ |
| int cras_iodev_reset_request(struct cras_iodev* iodev); |
| |
| /* Handle output underrun. |
| * Args: |
| * odev[in] - The output device. |
| * Returns: |
| * 0 on success. Negative error code on failure. |
| */ |
| int cras_iodev_output_underrun(struct cras_iodev *odev); |
| |
| /* Start ramping samples up/down on a device. |
| * Args: |
| * iodev[in] - The device. |
| * request[in] - The request type. Check the docstrings of |
| * CRAS_IODEV_RAMP_REQUEST. |
| * Returns: |
| * 0 on success. Negative error code on failure. |
| */ |
| int cras_iodev_start_ramp(struct cras_iodev *odev, |
| enum CRAS_IODEV_RAMP_REQUEST request); |
| |
| /* Set iodev to mute/unmute state. |
| * Args: |
| * iodev[in] - The device. |
| * Returns: |
| * 0 on success. Negative error code on failure. |
| */ |
| int cras_iodev_set_mute(struct cras_iodev* iodev); |
| |
| /* |
| * Checks if an output iodev's volume is zero. |
| * If there is an active node, check the adjusted node volume. |
| * If there is no active node, check system volume. |
| * Args: |
| * odev[in] - The device. |
| * Returns: |
| * 1 if device's volume is 0. 0 otherwise. |
| */ |
| int cras_iodev_is_zero_volume(const struct cras_iodev *odev); |
| |
| #endif /* CRAS_IODEV_H_ */ |