# Liquidsoap

## audio stream generation

### Customize metadata using liquidsoap

Liquidsoap has several mechanism for manipulating the metadata attached to your stream. In this page we quickly detail and compare the different operators, see the language reference for full details about them.

Warning. The protocol used by Shoutcast and Icecast before version 2 does not support many fields. It mainly support one: `song`. So, if you need to customize the metadata displayed by these servers, you should customize only the `song` metadata.

#### Rewrite metadata

`rewrite_metadata` rewrites metadata using a list of (target,rules). The semantic for the replacement rules is that of the `%` function. Namely, `(pattern % [...,(k,v),...])` changes in `pattern` occurences of:

- `'$(k)'` into `"v"`;
- `'$(if $(k2),"a","b")'` into `"a"` if `k2` is found in the list, `"b"` otherwise.

A sample code using this operator can be:

    # The 'display_artist' field is passed using annotate.
    pattern =
      '$(if $(display_artist),"$(display_artist)","$(artist)")'
    rewrite_metadata([("artist",pattern)],source)

#### Map_metadata

The `map_metadata` operator applies a specified function to transform each metadata chunk of a stream. It can be used to add or decorate metadata, but is also useful in more complex cases.

A simple example using it is:

    # A function applied to each metadata chunk
    def append_title(m) =
      # Grab the current title
      title = m["title"]

      # Return a new title metadata
      [("title","#{title} - www.station.com")]
    end

    # Apply map_metadata to s using append_title
    s = map_metadata(append_title, s)

The effect of `map_metadata` by default is to update the metadata with the returned values. Hence in the function `append_title` defined in the code above returns a new metadata for the label `title` and the other metadata remain untouched. You can change this by using the `update` option, and you can also remove any metadata (even empty one) using the `strip` option.

See the documentation on `map_metadata` for more details.

A more complex example is the `rewrite_metadata` operator, which is implemented using `map_metadata` as follows:

    # Rewrite metadata on the fly using a list of (target,rule).
    # @category Source / Track Processing
    # @param l  List of (target,value) rewriting rules
    # @param ~insert_missing \
    #           Treat track beginnings without metadata \
    #           as having empty ones.
    def rewrite_metadata(l,~insert_missing=true,s)
      def map(m)
        def apply(x)
          label = fst(x)
          meta = snd(x)
          if list.mem_assoc(label,l) then
            pattern = l[label]
            (label,pattern % m)
          else
            (label,meta)
          end
        end
        m = list.map(apply,m)
        def add(m,x)
          label = fst(x)
          pattern = snd(x)
          # If m does not have (label,_), then it was
          # not processed previously, we have to
          # add it now..
          if not list.mem_assoc(label,m) then
            list.append(m,[(label,pattern % m)])
          else
            m
          end
        end
        list.fold(add,m,l)
      end
      map_metadata(map,insert_missing=insert_missing,s)
    end

#### Insert_medatata

This operator is used for inserting metadata using a server command. If you have an `insert_metadata` node named `ID` in your configuration, you can connect to the server (either telnet or socket) and execute commands like:

    ID.insert key1="val1",key2="val2",...