pulse audio 에서 device list 보기.

출처 :https://gist.github.com/andrewrk/6470f3786d05999fcb48

//gcc ./pa-device.c -lpulse
#include <stdio.h>
#include <string.h>
#include <pulse/pulseaudio.h>

// Field list is here: http://0pointer.de/lennart/projects/pulseaudio/doxygen/structpa__sink__info.html
typedef struct pa_devicelist {
    uint8_t        initialized;
    char        name[512];
    uint32_t    index;
    char        description[256];
} pa_devicelist_t;

void pa_state_cb(pa_context *c, void *userdata);
void pa_sinklist_cb(pa_context *c, const pa_sink_info *l, int eol, void *userdata);
void pa_sourcelist_cb(pa_context *c, const pa_source_info *l, int eol, void *userdata);
int pa_get_devicelist(pa_devicelist_t *input, pa_devicelist_t *output);

// This callback gets called when our context changes state.  We really only
// care about when it's ready or if it has failed
void pa_state_cb(pa_context *c, void *userdata)
{
    pa_context_state_t state;
    int *pa_ready = userdata;

    state = pa_context_get_state(c);
    switch (state) {
    // There are just here for reference
    case PA_CONTEXT_UNCONNECTED:
    case PA_CONTEXT_CONNECTING:
    case PA_CONTEXT_AUTHORIZING:
    case PA_CONTEXT_SETTING_NAME:
    default:
        break;
    case PA_CONTEXT_FAILED:
    case PA_CONTEXT_TERMINATED:
        *pa_ready = 2;
        break;
    case PA_CONTEXT_READY:
        *pa_ready = 1;
        break;
    }
}

// pa_mainloop will call this function when it's ready to tell us about a sink.
// Since we're not threading, there's no need for mutexes on the devicelist
// structure
void pa_sinklist_cb(pa_context *c, const pa_sink_info *l, int eol, void *userdata)
{
    pa_devicelist_t *pa_devicelist = userdata;
    int ctr = 0;

    // If eol is set to a positive number, you're at the end of the list
    if (eol > 0)
        return;

    // We know we've allocated 16 slots to hold devices.  Loop through our
    // structure and find the first one that's "uninitialized."  Copy the
    // contents into it and we're done.  If we receive more than 16 devices,
    // they're going to get dropped.  You could make this dynamically allocate
    // space for the device list, but this is a simple example.
    for (ctr = 0; ctr < 16; ctr++) {
        if (!pa_devicelist[ctr].initialized) {
            strncpy(pa_devicelist[ctr].name, l->name, 511);
            strncpy(pa_devicelist[ctr].description, l->description, 255);
            pa_devicelist[ctr].index = l->index;
            pa_devicelist[ctr].initialized = 1;
            break;
        }
    }
}

// See above.  This callback is pretty much identical to the previous
void pa_sourcelist_cb(pa_context *c, const pa_source_info *l, int eol, void *userdata)
{
    pa_devicelist_t *pa_devicelist = userdata;
    int ctr = 0;

    if (eol > 0)
        return;

    for (ctr = 0; ctr < 16; ctr++) {
        if (!pa_devicelist[ctr].initialized) {
            strncpy(pa_devicelist[ctr].name, l->name, 511);
            strncpy(pa_devicelist[ctr].description, l->description, 255);
            pa_devicelist[ctr].index = l->index;
            pa_devicelist[ctr].initialized = 1;
            break;
        }
    }
}

int pa_get_devicelist(pa_devicelist_t *input, pa_devicelist_t *output)
{
    // Define our pulse audio loop and connection variables
    pa_mainloop *pa_ml;
    pa_mainloop_api *pa_mlapi;
    pa_operation *pa_op;
    pa_context *pa_ctx;


    // We'll need these state variables to keep track of our requests
    int state = 0;
    int pa_ready = 0;

    // Initialize our device lists
    memset(input, 0, sizeof(pa_devicelist_t) * 16);
    memset(output, 0, sizeof(pa_devicelist_t) * 16);

    // Create a mainloop API and connection to the default server
    pa_ml = pa_mainloop_new();
    pa_mlapi = pa_mainloop_get_api(pa_ml);
    pa_ctx = pa_context_new(pa_mlapi, "test");

    // This function connects to the pulse server
    pa_context_connect(pa_ctx, NULL, 0, NULL);


    // This function defines a callback so the server will tell us it's state.
    // Our callback will wait for the state to be ready.  The callback will
    // modify the variable to 1 so we know when we have a connection and it's
    // ready.
    // If there's an error, the callback will set pa_ready to 2
    pa_context_set_state_callback(pa_ctx, pa_state_cb, &pa_ready);

    // Now we'll enter into an infinite loop until we get the data we receive
    // or if there's an error
    for (;;) {
        // We can't do anything until PA is ready, so just iterate the mainloop
        // and continue
        if (pa_ready == 0) {
            pa_mainloop_iterate(pa_ml, 1, NULL);
            continue;
        }
        // We couldn't get a connection to the server, so exit out
        if (pa_ready == 2) {
            pa_context_disconnect(pa_ctx);
            pa_context_unref(pa_ctx);
            pa_mainloop_free(pa_ml);
            return -1;
        }
        // At this point, we're connected to the server and ready to make
        // requests
        switch (state) {
        // State 0: we haven't done anything yet
        case 0:
            // This sends an operation to the server.  pa_sinklist_info is
            // our callback function and a pointer to our devicelist will
            // be passed to the callback The operation ID is stored in the
            // pa_op variable
            pa_op = pa_context_get_sink_info_list(pa_ctx,
                                  pa_sinklist_cb,
                                  output
                                  );

            // Update state for next iteration through the loop
            state++;
            break;
        case 1:
            // Now we wait for our operation to complete.  When it's
            // complete our pa_output_devicelist is filled out, and we move
            // along to the next state
            if (pa_operation_get_state(pa_op) == PA_OPERATION_DONE) {
                pa_operation_unref(pa_op);

                // Now we perform another operation to get the source
                // (input device) list just like before.  This time we pass
                // a pointer to our input structure
                pa_op = pa_context_get_source_info_list(pa_ctx,
                                    pa_sourcelist_cb,
                                    input
                                    );
                // Update the state so we know what to do next
                state++;
            }
            break;
        case 2:
            if (pa_operation_get_state(pa_op) == PA_OPERATION_DONE) {
                // Now we're done, clean up and disconnect and return
                pa_operation_unref(pa_op);
                pa_context_disconnect(pa_ctx);
                pa_context_unref(pa_ctx);
                pa_mainloop_free(pa_ml);
                return 0;
            }
            break;
        default:
            // We should never see this state
            fprintf(stderr, "in state %d\n", state);
            return -1;
        }
        // Iterate the main loop and go again.  The second argument is whether
        // or not the iteration should block until something is ready to be
        // done.  Set it to zero for non-blocking.
        pa_mainloop_iterate(pa_ml, 1, NULL);
    }
}

int main(int argc, char *argv[])
{
    int ctr;

    // This is where we'll store the input device list
    pa_devicelist_t pa_input_devicelist[16];

    // This is where we'll store the output device list
    pa_devicelist_t pa_output_devicelist[16];

    if (pa_get_devicelist(pa_input_devicelist, pa_output_devicelist) < 0) {
        fprintf(stderr, "failed to get device list\n");
        return 1;
    }

    for (ctr = 0; ctr < 16; ctr++) {
        if (!pa_output_devicelist[ctr].initialized)
            break;
        printf("=======[ Output Device #%d ]=======\n", ctr + 1);
        printf("Description: %s\n", pa_output_devicelist[ctr].description);
        printf("Name: %s\n", pa_output_devicelist[ctr].name);
        printf("Index: %d\n", pa_output_devicelist[ctr].index);
        printf("\n");
    }

    for (ctr = 0; ctr < 16; ctr++) {
        if (!pa_input_devicelist[ctr].initialized)
            break;
        printf("=======[ Input Device #%d ]=======\n", ctr + 1);
        printf("Description: %s\n", pa_input_devicelist[ctr].description);
        printf("Name: %s\n", pa_input_devicelist[ctr].name);
        printf("Index: %d\n", pa_input_devicelist[ctr].index);
        printf("\n");
    }
    return 0;
}

이걸로 pacmd 로 할 수 있는 것들을 알 수 있다.

$ man pulse-cli-syntax

$ pacmd list-sources > list_sources.txt

이런식으로 하면 된다.

 

'''
pulse-cli-syntax(5)                                                                 File Formats Manual                                                                 pulse-cli-syntax(5)

NAME
       pulse-cli-syntax - PulseAudio Command Line Interface Syntax

SYNOPSIS
       ~/.config/pulse/default.pa

       /etc/pulse/default.pa

       /etc/pulse/system.pa

DESCRIPTION
       PulseAudio  provides a simple command line language used by configuration scripts, the pacmd interactive shell, and the modules module-cli and module-cli-protocol-{unix,tcp}. Empty
       lines and lines beginning with a hashmark (#) are silently ignored. Several commands are supported.

       Note that any boolean arguments can be given positively as '1', 't', 'y', 'true', 'yes' or 'on'. Likewise, negative values can be given as '0', 'f', 'n', 'false',  'no'  or  'off'.
       Case is ignored.

GENERAL COMMANDS
       help   Show a quick help on the commands available.

STATUS COMMANDS
       list-modules
              Show all currently loaded modules with their arguments.

       list-cards
              Show all currently registered cards

       list-sinks or list-sources
              Show all currently registered sinks (resp. sources).

       list-clients
              Show all currently active clients.

       list-sink-inputs or list-source-outputs
              Show all currently active inputs to sinks a.k.a. playback streams (resp. outputs of sources a.k.a. recording streams).

       stat   Show some simple statistics about the allocated memory blocks and the space used by them.

       info or ls or list
              A combination of all status commands described above (all three commands are synonyms).

MODULE MANAGEMENT
       load-module name [arguments...]
              Load a module specified by its name and arguments. For most modules it is OK to be loaded more than once.

       unload-module index|name
              Unload a module, specified either by its index in the module list or its name.

       describe-module name
              Give information about a module specified by its name.

VOLUME COMMANDS
       set-sink-volume|set-source-volume index|name volume
              Set the volume of the specified sink (resp. source). You may specify the sink (resp. source) either by its index in the sink/source list or by its name. The volume should be
              an integer value greater or equal than 0 (muted). Volume 65536 (0x10000) is 'normal' volume a.k.a. 100%. Values greater than this amplify the audio signal (with clipping).

       set-sink-mute|set-source-mute index|name boolean
              Mute or unmute the specified sink (resp. source). You may specify the sink (resp. source) either by its index or by its name. The mute value is either 0  (not  muted)  or  1
              (muted).

       set-sink-input-volume|set-source-output-volume index volume
              Set the volume of a sink input (resp. source output) specified by its index. The same volume rules apply as with set-sink-volume.

       set-sink-input-mute|set-source-output-mute index boolean
              Mute or unmute a sink input (resp. source output) specified by its index. The same mute rules apply as with set-sink-mute.

CONFIGURATION COMMANDS
       set-default-sink|set-default-source index|name
              Make a sink (resp. source) the default. You may specify the sink (resp. source) by its index in the sink (resp. source) list or by its name.

              Note that defaults may be overridden by various policy modules or by specific stream configurations.

       set-card-profile index|name profile-name
              Change the profile of a card.

       set-sink-port|set-source-port index|name port-name
              Change the profile of a sink (resp. source).

       set-port-latency-offset card-index|card-name port-name offset
              Change the latency offset of a port belonging to the specified card

       suspend-sink|suspend-source index|name boolean
              Suspend (i.e. disconnect from the underlying hardware) a sink (resp. source).

       suspend boolean
              Suspend all sinks and sources.

MOVING STREAMS
       move-sink-input|move-source-output index sink-index|sink-name
              Move sink input (resp. source output) to another sink (resp. source).

PROPERTY LISTS
       update-sink-proplist|update-source-proplist index|name properties
              Update the properties of a sink (resp. source) specified by name or index. The property is specified as e.g. device.description="My Preferred Name"

       update-sink-input-proplist|update-source-output-proplist index properties
              Update the properties of a sink input (resp. source output) specified by index. The properties are specified as above.

SAMPLE CACHE
       list-samples
              Lists the contents of the sample cache.

       play-sample name sink-index|sink-name
              Play a sample cache entry to a sink.

       remove-sample name
              Remove an entry from the sample cache.

       load-sample name filename
              Load an audio file to the sample cache.

       load-sample-lazy name filename
              Create a new entry in the sample cache, but don't load the sample immediately. The sample is loaded only when it is first used. After a certain idle time it is freed again.

       load-sample-dir-lazy path
              Load  all  entries in the specified directory into the sample cache as lazy entries. A shell globbing expression (e.g. *.wav) may be appended to the path of the directory to
              add.

KILLING CLIENTS/STREAMS
       kill-client index
              Remove a client forcibly from the server. There is no protection against the client reconnecting immediately.

       kill-sink-input|kill-source-output index
              Remove a sink input (resp. source output) forcibly from the server. This will not remove the owning client or any other streams opened by the same client from the server.

LOG COMMANDS
       set-log-level numeric-level
              Change the log level.

       set-log-meta boolean
              Show source code location in log messages.

       set-log-target target
              Change the log target (null, auto, journal, syslog, stderr, file:PATH, newfile:PATH).

       set-log-time boolean
              Show timestamps in log messages.

       set-log-backtrace num-frames
              Show backtrace in log messages.

MISCELLANEOUS COMMANDS
       play-file filename sink-index|sink-name
              Play an audio file to a sink.

       dump   Dump the daemon's current configuration in CLI commands.

       dump-volumes
              Debug: Shows the current state of all volumes.

       shared Debug: Show shared properties.

       exit   Terminate the daemon. If you want to terminate a CLI connection ("log out") you might want to use ctrl+d

META COMMANDS
       In addition to the commands described above there are a few meta directives supported by the command line interpreter.

       .include filename|folder
              Executes the commands from the specified script file or in all of the *.pa files within the folder.

       .fail and .nofail
              Enable (resp. disable) that following failing commands will cancel the execution of the current script file. This is ignored when used on the interactive command line.

       .ifexists filename
              Execute the subsequent block of commands only if the specified file exists. Typically filename indicates a module. Relative paths are resolved using the module directory  as
              the base. By using an absolute path, the existance of other files can be checked as well.

       .else and .endif
              A block of commands is delimited by an .else or .endif meta command. Nesting conditional commands is not supported.

AUTHORS
       The PulseAudio Developers <pulseaudio-discuss (at) lists (dot) freedesktop (dot) org>; PulseAudio is available from http://pulseaudio.org/

SEE ALSO
       default.pa(5), pacmd(1), pulseaudio(1)

Manuals                                                                                     User                                                                        pulse-cli-syntax(5)

'''

'Linux > Linux 일반' 카테고리의 다른 글

PulseAudio build  (0) 2019.11.26
pulseaudio device list  (0) 2019.09.17
ubuntu 18.04 에서 kvm 켜기  (0) 2019.08.27
Ubuntu 18.04 에서 libpng12 없을 때.  (0) 2019.08.21
Posted by Real_G

댓글을 달아 주세요