Changeset 7110

Timestamp:

01/27/10 06:19:40 (7 weeks ago)

Author:

dbaelde

Message:

Major change to the decoding infrastructure, really integrating the
new content type system. The main differences are:

• decoding files and streams is unified
• as a result decoding and detecting whether a decoder fits a file or a stream are clearly separated
• the old architecture forced a kind upon a decoder, whereas a decoder should be able to adapt itself to a kind by changing its output type
• the base code in Decoder checks that file decoders respect the expected content kind, which was already needed with libmad, and should prove valuable when we start playing more complex games there
• the old coding style proved very error prone, no more records

By the way, I moved all decoding-related stuff to a new directory, and
we should remove the old stuff quickly as we finish this migration.
I have only adapted MP3 and OGG for now, and didn't enable OGG stream
decoding. I have adapted intput.http/harbor/lastfm to use the new
infrastructure -- although their (Lang) types don't reflect it --
but we need a thread-safe generator there for stable use.
Also changed the mime-related API in Configure.

Location:

trunk/liquidsoap

Files:

• configure.ac (modified) (2 diffs)
• src/Makefile (modified) (7 diffs)
• src/configure.mli (modified) (1 diff)
• src/decoder (added)
• src/decoder.ml (modified) (4 diffs)
• src/decoder.mli (modified) (2 diffs)
• src/decoder/Makefile (copied) (copied from trunk/liquidsoap/src/formats/Makefile) (1 diff)
• src/decoder/mp3.ml (moved) (moved from trunk/liquidsoap/src/formats/mp3.ml) (4 diffs)
• src/decoder/ogg_decoder.ml (moved) (moved from trunk/liquidsoap/src/formats/oggformat.ml) (3 diffs)
• src/lang/lang_builtins.ml (modified) (2 diffs)
• src/playlists/playlist_basic.ml (modified) (2 diffs)
• src/request.ml (modified) (5 diffs)
• src/request.mli (modified) (3 diffs)
• src/sources/generated.ml (modified) (2 diffs)
• src/sources/harbor_input.ml (modified) (10 diffs)
• src/sources/http_source.ml (modified) (12 diffs)
• src/sources/lastfm_input.ml (modified) (5 diffs)
• src/stream/generator.ml (modified) (2 diffs)
• src/stream/generator.mli (modified) (2 diffs)
• src/tools/file_decoder.ml (deleted)
• src/tools/harbor.ml (modified) (4 diffs)

trunk/liquidsoap/configure.ac

@@ -1175 +1175 @@
     w_MAGIC="no (requires ocaml-magic)"
     cat >> src/configure.ml <<EOCONF
-let file_mime s = None
-let data_mime ?len s = None
+let file_mime = None
+let data_mime = None
 EOCONF
 else
@@ -1182 +1182 @@
     cat >> src/configure.ml <<EOCONF
 let magic_cookie = Magic.create ~flags:[[Magic.Mime; Magic.Symlink]] [[]]
-let file_mime s = Some (Magic.file magic_cookie s)
-let data_mime ?len s = Some (Magic.buffer magic_cookie ?len s)
+let file_mime = Some (Magic.file magic_cookie)
+let data_mime = Some (Magic.buffer magic_cookie)
 EOCONF
 fi

trunk/liquidsoap/src/Makefile

@@ -1 +1 @@
 
-SUBDIRS= tools formats playlists encoder protocols plugins stream lang \
+SUBDIRS= tools decoder playlists encoder protocols plugins stream lang \
                  ogg_formats video_converters audio_converters \
                  operators sources conversions outputs io visualization analyze synth
@@ -32 +32 @@
         $(if $(W_GAVL),video_converters/gavl_converter.ml)
 
+# TODO move all formats to encoders
 formats = \
-        $(if $(W_OGG),formats/oggformat.ml) \
         $(if $(W_VORBIS),formats/vorbisduration.ml) \
         $(if $(W_TAGLIB),formats/taglib_plug.ml) \
@@ -39 +39 @@
         formats/externalformat.ml \
         formats/midiformat.ml \
-        $(if $(W_MP3),formats/mp3.ml)
         # $(if $(W_FAAD),formats/aacformat.ml) \
+
+decoders = \
+        $(if $(W_OGG),decoder/ogg_decoder.ml) \
+        $(if $(W_MP3),decoder/mp3.ml)
 
 playlists = \
@@ -57 +60 @@
         sources/req_queue.ml sources/req_equeue.ml \
         sources/generated.ml sources/http_source.ml \
-        $(if $(W_MP3),sources/http_mp3.ml) \
-        $(if $(W_OGG),sources/http_ogg.ml) \
-        $(if $(W_FAAD),sources/http_aac.ml) \
         $(if $(W_ALSA),sources/alsa_in.ml) \
         $(if $(W_BJACK),sources/bjack_in.ml) \
@@ -110 +110 @@
         $(if $(W_GRAPHICS),outputs/graphics_out.ml) \
         $(if $(W_ALSA),outputs/alsa_out.ml) \
-        $(if $(W_BJACK),outputs/bjack_out.ml) \
-        # outputs/external_encoded.ml \
+        $(if $(W_BJACK),outputs/bjack_out.ml)
 
 io = \
@@ -157 +156 @@
         lang/lang_types.ml lang/lang_values.ml \
         lang/lang_lexer.ml lang/lang_parser.ml lang/lang_pp.ml lang/lang.ml \
-        tools/ioRing.ml tools/file_decoder.ml tools/mutils.ml \
+        tools/ioRing.ml tools/mutils.ml \
         $(video_converters) $(audio_converters) $(ogg_demuxer) $(protocols) \
         $(sources) $(operators) $(conversions) $(outputs) \
         $(encoders) $(ogg_muxer) $(io) \
-        $(analyze) $(playlists) $(visualization) $(synth) $(formats) \
+        $(analyze) $(playlists) $(visualization) $(synth) $(decoders) \
         shebang.ml \
         lang/lang_builtins.ml \
@@ -227 +226 @@
         tools/harbor.ml $(video_converters) $(audio_converters) \
         $(ogg_utils) $(protocols) $(sources) $(operators) $(outputs) $(io) \
-        $(analyze) $(playlists) $(formats) \
+        $(analyze) $(playlists) $(decoders) \
         lang/lang_builtins.ml
 libliq_objects=$(libliq_sources:.ml=.$(o))

trunk/liquidsoap/src/configure.mli

@@ -21 +21 @@
 
 (** Magic mime detection *)
-val file_mime : string -> string option
-val data_mime : ?len:int -> string -> string option
+val file_mime : (string -> string) option
+val data_mime : (?len:int -> string -> string) option
 
 val requests_table_size : int

trunk/liquidsoap/src/decoder.ml

@@ -2 +2 @@
 
   Liquidsoap, a programmable audio stream generator.
-  Copyright 2003-2009 Savonet team
+  Copyright 2003-2010 Savonet team
 
   This program is free software; you can redistribute it and/or modify
@@ -21 +21 @@
  *****************************************************************************)
 
-(** Plug for file decoding, in which [src/formats] plugins come. *)
+(** Media decoding infrastructure.
+  *
+  * We treat files and streams.
+  * We separate detection from the actual decoding.
+  * For files, the decoder detection function is passed a filename and
+  * an expected content kind.
+  * For streams, it is passed a MIME type and a content kind.
+  *
+  * In practice, most file decoders will be based on stream decoders,
+  * with a specific (more precise) detection function. Although
+  * we cannot force it at this point, we provide some infrastructure
+  * to help.
+  *
+  * In the short term, the plug infrastructure should provide
+  * a way to ban / prioritize
+  * plugins. For example:
+  *   - choose ogg_demuxer when extension = ogg
+  *   - choose mad when extension = mp3
+  *   - choose mad when mime-type = audio/mp3
+  *
+  * A few comments about the changes from the old decoding infrastructure:
+  *
+  * We need to change the closing policy (necessary to release resources
+  * immediately). In particular stream decoders shouldn't be in charge
+  * of closing the stream (sink) since they didn't open it: this trivializes
+  * the stream interface (sink) to an input function and a THREAD-SAFE
+  * generator.
+  *
+  * In MAD, we used openfile and openstream, but unifying doesn't change
+  * the performance.
+  *
+  * Estimating the remaining time can be done externally, based on the
+  * file description. This is equivalent to what is done currently,
+  * except in WAV.
+  *
+  * The WAV decoder doesn't fit the approx duration computation.
+  * The MIDI decoder doesn't use a buffer. TODO look at this carefully. *)
 
 open Dtools
@@ -27 +63 @@
 let log = Log.make ["decoder"]
 
+(** A local file is simply identified by its filename. *)
+type file = string
+
+(** A stream is identified by a MIME type. *)
+type stream = string
+
+type 'a decoder = Decoder of ('a -> unit)
+
+type input = int -> string * int
+
+(** A stream decoder does not "own" any file descriptor,
+  * and is generally assumed to not allocate resources (in the sense
+  * of things that should be explicitly managed, not just garbage collected).
+  * Hence it does not need a close function. *)
+type stream_decoder = input -> Generator.From_audio_video.t decoder
+
 (** A decoder is a filling function and a closing function,
-  * called as soon as a filling fails, i.e. is partial. *)
-type decoder = {
+  * called at least when filling fails, i.e. the frame is partial.
+  * The closing function can be called earlier e.g. if the user skips.
+  * In most cases, file decoders are wrapped stream decoders. *)
+type file_decoder = {
   fill : Frame.t -> int ; (* Return remaining ticks. *)
   close : unit -> unit ;
 }
 
-(** Plugins are given filenames and return a decoder, if possible. *)
-let formats : (string -> Frame.content_kind -> decoder option) Plug.plug =
+(** Plugins might define various decoders. In order to be accessed,
+  * they should also register methods for choosing decoders. *)
+
+(** For a given file, once a decoder is chosen it can be used several
+  * times. This is at least useful to separate the actual opening of
+  * the file from checking that it is a valid media file. *)
+let file_decoders :
+      (file -> Frame.content_kind -> (unit -> file_decoder) option)
+      Plug.plug =
   Plug.create
-    ~doc:"Method to read audio files." ~insensitive:true "audio file formats"
+    ~doc:"File decoding methods." ~insensitive:true "file decoding"
+
+let stream_decoders :
+      (stream -> Frame.content_kind -> stream_decoder option) Plug.plug =
+  Plug.create
+    ~doc:"Stream decoding methods." ~insensitive:true "stream decoding"
 
 let dummy =
@@ -45 +111 @@
     close = (fun _ -> ()) }
 
-exception Exit of (string * (string -> Frame.content_kind -> decoder option))
-(** Get a valid decoder creator for [filename].
-  * The validity is not based on file extension but only on success of the
-  * decoder instantiation.
-  * Being based on file extension is weak, and troublesome when accessing a
-  * remote file -- that would force us to create a local temporary file with the
-  * same extension. *)
-let search_valid filename kind : (string*(unit -> decoder)) option =
+exception Exit of (string * (unit -> file_decoder))
+
+(** Get a valid decoder creator for [filename]. *)
+let get_file_decoder filename kind : (unit -> file_decoder) option =
   try
-    formats#iter ~rev:true 
-      (fun format decoder ->
-         log#f 4 "Trying %s decoder for %S..." format filename ;
-         match decoder filename kind with
-           | Some d ->
-               d.close () ;
-               log#f 3 "Decoder %s chosen for %S." format filename ;
-               raise (Exit (format, decoder))
-           | None  -> ()) ;
+    file_decoders#iter ~rev:true 
+      (fun name decoder ->
+         log#f 4 "Trying method %S for %S..." name filename ;
+         match try decoder filename kind with _ -> None with
+           | Some f ->
+               log#f 3 "Method %S accepted %S." name filename ;
+               raise (Exit (name,f))
+           | None -> ()) ;
     log#f 3 "Unable to decode %S!" filename ;
     None
   with
-    | Exit (format,d) ->
-        Some (format,fun () ->
-                match d filename kind with
-                  | None ->
-                      log#f 2 "Decoder %s betrayed us on %S!" format filename ;
-                      dummy
-                  | Some d -> d)
+    | Exit (name,f) ->
+        Some (fun () ->
+                try f () with _ ->
+                  log#f 2 "Decoder %S betrayed us on %S!" name filename ;
+                  dummy)
+
+exception Exit of stream_decoder
+
+let get_stream_decoder mime kind =
+  try
+    stream_decoders#iter
+      (fun name decoder ->
+         log#f 4 "Trying method %S for %S..." name mime ;
+         match try decoder mime kind with _ -> None with
+           | Some f ->
+               log#f 3 "Method %S accepted %S." name mime ;
+               raise (Exit f)
+           | None -> ()) ;
+    log#f 3 "Unable to decode stream of type %S!" mime ;
+    None
+  with
+    | Exit f -> Some f
+
+(** {1 Helpers for defining decoders} *)
+
+module Buffered(Generator:Generator.S) =
+struct
+
+  let file_decoder filename kind create_decoder gen =
+    let frame_size = Lazy.force Frame.size in
+    let file_size = (Unix.stat filename).Unix.st_size in
+    let fd = Unix.openfile filename [Unix.O_RDONLY] 0 in
+    let input len =
+      try
+        let s = String.create len in
+        let i = Unix.read fd s 0 len in
+          s, i
+      with _ -> "", 0
+    in
+    let Decoder decoder = create_decoder input in
+    let out_ticks = ref 0 in
+    let fill frame =
+      begin try
+        while Generator.length gen < frame_size do
+          decoder gen
+        done
+      with _ -> ()
+      end ;
+
+      let offset = Frame.position frame in
+      let old_breaks = Frame.breaks frame in
+        Generator.fill gen frame ;
+        if
+          (* Check that we got only one chunk of data,
+           * and that it has a correct type. *)
+          let end_pos,content = Frame.content frame offset in
+            not (end_pos = Frame.position frame &&
+                 Frame.type_has_kind (Frame.type_of_content content) kind)
+        then begin
+          log#f 2 "Decoder of %S didn't respect its content type!" filename ;
+          (* Pretend nothing happened, and end decoding.
+           * We first restore a content layer with a valid type, so that
+           * the code which reads that frame doesn't see the anomaly.
+           * Then we reset breaks to indicate that there's no more data. *)
+          let _ =
+            Frame.content_of_type frame offset (Frame.type_of_kind kind)
+          in
+            Frame.set_breaks frame old_breaks ;
+            Frame.add_break frame offset ;
+            0
+        end else
+          let in_bytes = Unix.lseek fd 0 Unix.SEEK_CUR in
+          let gen_len = Generator.length gen in
+            out_ticks := !out_ticks + Frame.position frame - offset ;
+            (* Compute an estimated number of remaining ticks. *)
+            if in_bytes = 0 then -1 else
+              let compression =
+                (float (!out_ticks+gen_len)) /. (float in_bytes)
+              in
+              let remaining_ticks =
+                (float gen_len) +.
+                (float (file_size - in_bytes)) *. compression
+              in
+                int_of_float remaining_ticks
+    in
+      { fill = fill ;
+        close = fun () -> Unix.close fd }
+
+end

trunk/liquidsoap/src/decoder.mli

@@ -2 +2 @@
 
   Liquidsoap, a programmable audio stream generator.
-  Copyright 2003-2009 Savonet team
+  Copyright 2003-2010 Savonet team
 
   This program is free software; you can redistribute it and/or modify
@@ -21 +21 @@
  *****************************************************************************)
 
-type decoder = { fill : Frame.t -> int; close : unit -> unit; }
+val log : Dtools.Log.t
 
-val formats : (string -> Frame.content_kind -> decoder option) Plug.plug
+type file = string
+type stream = string
 
-val search_valid :
-  string -> Frame.content_kind -> (string * (unit -> decoder)) option
+type input = int -> string * int
+
+type 'a decoder = Decoder of ('a -> unit)
+type stream_decoder = input -> Generator.From_audio_video.t decoder
+type file_decoder = { fill : Frame.t -> int; close : unit -> unit; }
+
+val file_decoders :
+  (file -> Frame.content_kind -> (unit -> file_decoder) option)
+  Plug.plug
+val stream_decoders :
+  (stream -> Frame.content_kind -> stream_decoder option) Plug.plug
+
+val get_file_decoder :
+  file -> Frame.content_kind -> (unit -> file_decoder) option
+val get_stream_decoder :
+  file -> Frame.content_kind -> stream_decoder option
+
+module Buffered :
+  functor (Generator : Generator.S) ->
+    sig
+      val file_decoder :
+        string ->
+        Frame.content_kind ->
+        (input -> Generator.t decoder) ->
+        Generator.t ->
+        file_decoder
+    end

trunk/liquidsoap/src/decoder/Makefile

@@ -4 +4 @@
 top_srcdir= ../..
 include $(top_srcdir)/Makefile.rules
-
-id3tag_stubs.o: id3tag_stubs.c
-        $(CC) $(CFLAGS) -c -g -Wall -I$(shell $(OCAMLC) -where) $<
-
-test_id3tag: id3tag_stubs.o id3tag.mli id3tag.ml test_id3tag.ml
-        ocamlc id3tag.mli
-        ocamlopt -c id3tag.ml
-        ocamlopt -cclib "$(LDFLAGS)" unix.cmxa id3tag.cmx id3tag_stubs.o test_id3tag.ml -cclib -lid3tag -o test_id3tag

trunk/liquidsoap/src/decoder/mp3.ml

@@ -2 +2 @@
 
   Liquidsoap, a programmable audio stream generator.
-  Copyright 2003-2009 Savonet team
+  Copyright 2003-2010 Savonet team
 
   This program is free software; you can redistribute it and/or modify
@@ -21 +21 @@
  *****************************************************************************)
 
-(** Decode and read metadatas of mp3 files. *)
+(** Decode and read metadata from mp3 files. *)
 
 open Dtools
 
 module Generator = Generator.From_audio_video
+module Buffered = Decoder.Buffered(Generator)
 
 let log = Log.make ["format";"mp3"]
+
+let create_decoder input =
+  let resampler = Rutils.create_audio () in
+  let fd = Mad.openstream input in
+    Decoder.Decoder (fun gen ->
+      let data = Mad.decode_frame_float fd in
+      let sample_freq,channels,_ = Mad.get_output_format fd in
+      let content,length =
+        resampler ~audio_src_rate:(float sample_freq) data
+      in
+      let content =
+        if Random.int 100 = 0 then [|content.(0)|] else content
+      in
+        Generator.put_audio gen content 0 (Array.length content.(0)))
+
+let create_file_decoder filename kind =
+  let generator = Generator.create Generator.Audio in
+    Buffered.file_decoder filename kind create_decoder generator
 
 let conf_mad =
   Conf.void ~p:(Configure.conf#plug "mad")
     "Mad (mp3) decoding options."
-let conf_mime =
-  Conf.bool ~p:(conf_mad#plug "check_mime") ~d:true
-      "Enable magic mime test, if compiled."
 let conf_mime_types =
   Conf.list ~p:(conf_mad#plug "mime_types")
@@ -40 +56 @@
     ~d:["audio/mpeg";"application/octet-stream";"video/x-unknown"]
 
-let check file =
-  if conf_mime#get then
-    match Configure.file_mime file with
-      (* libmagic does not always detect mp3 as audio/mpeg
-       * (Repeat after me: mp3 formats sucks, mp3 format.... )
-       * So it might return other types.
-       * We hope other formats like jpeg, gif, etc..
-       * will most likely be correctly detected *)
-      | Some s when List.mem s conf_mime_types#get -> true
-      | None -> true
-      | Some s ->
-         log#f 2 "Mime type for %s is not valid: %s" file s;
-         false
-  else
-   (** Mime check disabled.. *)
-   true
+(* Get the number of channels of audio in an MP3 file.
+ * This is done by decoding a first chunk of data, thus checking
+ * that libmad can actually open the file -- which doesn't mean much. *)
+let get_type filename =
+  let fd = Mad.openfile filename in
+    ignore(Mad.decode_frame_float fd);
+    let rate,channels,_ = Mad.get_output_format fd in
+      log#f 4
+        "Libmad recognizes %S as MP3 (%dHz,%d channels)."
+        filename rate channels ;
+      Mad.close fd ;
+      { Frame.
+          audio = channels ;
+          video = 0 ;
+          midi  = 0 }
 
-let decoder =
-  {
-   File_decoder.
-    log = log;
-    openfile =
-      (fun file ->
-        if not (check file) then
-          assert false;
-        Mad.openfile file,
-        Rutils.create_audio ());
-    get_kind =
-      (fun (fd,_) ->
-         (* Decode some data *)
-         ignore(Mad.decode_frame_float fd);
-         (* Get number of channels *)
-         let _,channels,_ = Mad.get_output_format fd in
-         { Frame.
-            audio = Frame.mul_of_int channels ;
-            video = Frame.mul_of_int 0 ;
-            midi  = Frame.mul_of_int 0 });
-    decode =
-      (fun (fd,converter) buffer ->
-         let data = Mad.decode_frame_float fd in
-         let sample_freq,_,_ = Mad.get_output_format fd in
-         let content,length =
-           converter ~audio_src_rate:(float sample_freq) 
-           data
-         in
-         Generator.put_audio buffer content 0 length);
-    position = (fun (fd,_) -> Mad.get_current_position fd);
-    close = (fun (fd,_) -> Mad.close fd)
-  }
+let () =
+  match Configure.file_mime with
+    | None ->
+        Decoder.file_decoders#register
+          "MP3/libmad"
+          ~sdoc:"Use libmad to decode MP3, if it works."
+          (fun filename kind ->
+             if Frame.type_has_kind (get_type filename) kind then
+               Some (fun () -> create_file_decoder filename kind)
+             else begin
+               None
+             end)
+    | Some mime_type ->
+        Decoder.file_decoders#register
+          "MP3/libmad/mime"
+          ~sdoc:"Use libmad to decode MP3 if MIME type is appropriate."
+          (fun filename kind ->
+             let mime = mime_type filename in
+               if not (List.mem mime conf_mime_types#get) then begin
+                 log#f 3 "Invalid MIME type for %s: %s!" filename mime ;
+                 None
+               end else
+                 if kind.Frame.audio = Frame.Variable ||
+                    kind.Frame.audio = Frame.Succ Frame.Variable ||
+                    (* libmad always respects the first two kinds *)
+                    Frame.type_has_kind (get_type filename) kind
+                 then
+                   Some (fun () -> create_file_decoder filename kind)
+                 else
+                   None)
+
+let () =
+  Decoder.stream_decoders#register
+    "MP3/libmad"
+    ~sdoc:"Use libmad to decode any stream with an appropriate MIME type."
+     (fun mime kind ->
+        let (<:) a b = Frame.mul_sub_mul a b in
+          if List.mem mime conf_mime_types#get &&
+             kind.Frame.video <: Frame.Zero &&
+             kind.Frame.midi <: Frame.Zero &&
+             kind.Frame.audio <> Frame.Zero
+          then
+            (* In fact we can't be sure that we'll satisfy the content
+             * kind, because the MP3 stream might be mono or stereo.
+             * For now, we let this problem result in an error at
+             * decoding-time. Failing early would only be an advantage
+             * if there was possibly another plugin for decoding
+             * correctly the stream (e.g. by performing conversions). *)
+            Some create_decoder
+          else
+            None)
+
+let check filename =
+  match Configure.file_mime with
+    | Some f -> List.mem (f filename) conf_mime_types#get
+    | None -> (try ignore (get_type filename) ; true with _ -> false)
 
 let duration file =
-  if not (check file) then
-    raise Not_found;
+  if not (check file) then raise Not_found ;
   let ans = Mad.duration file in
   match ans with
@@ -98 +136 @@
     | _ -> ans
 
-let () = Decoder.formats#register "MP3" (File_decoder.decode decoder);
-         Request.dresolvers#register "MP3" duration
+let () =
+  Request.dresolvers#register "MP3" duration

trunk/liquidsoap/src/decoder/ogg_decoder.ml

@@ -2 +2 @@
 
   Liquidsoap, a programmable audio stream generator.
-  Copyright 2003-2009 Savonet team
+  Copyright 2003-2010 Savonet team
 
   This program is free software; you can redistribute it and/or modify
@@ -23 +23 @@
 (** Decode and read ogg files. *)
 
+module Generator = Generator.From_audio_video
+module Buffered = Decoder.Buffered(Generator)
+
 let log = Dtools.Log.make ["format";"ogg"]
-
-module Generator = Generator.From_audio_video
 
 exception Channels of int
@@ -109 +110 @@
       end
 
-type state = {
-  decoder : Ogg_demuxer.t ;
-  fd : Unix.file_descr ;
-  video_convert : Ogg_demuxer.video -> RGB.t ;
-  audio_resample : ?audio_src_rate:float -> Float_pcm.pcm -> Float_pcm.pcm*int ;
-  video_resample : in_freq:int -> out_freq:int ->
-                   RGB.t array -> int -> int -> RGB.t array
-}
-
-let decoder =
-  {
-   File_decoder.
-    log = log;
-    openfile =
-      (fun file ->
-        let sync,fd = Ogg.Sync.create_from_file file in
-        begin
-         try
-           {
-             decoder = Ogg_demuxer.init sync ;
-             fd = fd ;
-             video_convert = video_convert () ;
-             audio_resample = Rutils.create_audio () ;
-             video_resample = video_resample ()
-           }
-         with
-           | e -> (try Unix.close fd with _ -> ()); raise e
-        end);
-    get_kind =
-      (fun {decoder=decoder} ->
-        let feed ((buf,_),_) =
-          raise (Channels (Array.length buf))
+(* TODO this mimicks the old code, but in the near future decoding should
+ * take into account the target content kind, e.g. for dropping channels *)
+let create_decoder input =
+  let decoder =
+    let sync = Ogg.Sync.create input in
+      Ogg_demuxer.init sync
+  in
+  let video_convert = video_convert () in
+  let audio_resample = Rutils.create_audio () in
+  let video_resample = video_resample () in
+    Decoder.Decoder (fun buffer ->
+      if Ogg_demuxer.eos decoder then
+        raise Ogg_demuxer.End_of_stream;
+      let feed ((buf,sample_freq),_) =
+        let audio_src_rate = float sample_freq in
+        let content,length =
+          audio_resample ~audio_src_rate buf
         in
-        let audio =
-          try
-            Ogg_demuxer.decode_audio_rec decoder feed;
-            raise Not_found
-          with
-            | Channels x -> x
-            | Not_found  -> 0
-        in
-        let feed (buf,_) =
-          raise (Channels 1)
-        in
-        let video =
-          try
-            Ogg_demuxer.decode_video_rec decoder feed;
-            raise Not_found
-          with
-            | Channels x -> x
-            | Not_found  -> 0
-        in
-        { Frame.
-            audio = Frame.mul_of_int audio ;
-            video = Frame.mul_of_int video ;
-            midi  = Frame.mul_of_int 0 });
-    decode =
-      (fun s buffer ->
-          if Ogg_demuxer.eos s.decoder then
-            raise Ogg_demuxer.End_of_stream;
-          let feed ((buf,sample_freq),_) =
-            let audio_src_rate = float sample_freq in
-            let content,length =
-              s.audio_resample ~audio_src_rate buf
-            in
-            Generator.put_audio buffer content 0 length
-          in
-          let got_audio =
-           try
-            Ogg_demuxer.decode_audio s.decoder feed ;
-            true
-           with
-             | Not_found
-             | Ogg.Not_enough_data -> false
-          in
-          let feed (buf,_) =
-            let in_freq = int_of_float buf.Ogg_demuxer.fps in
-            let out_freq = Lazy.force Frame.video_rate in
-            let rgb = s.video_convert buf in
-            let stream = s.video_resample ~in_freq ~out_freq [|rgb|] 0 1 in
-              Generator.put_video buffer [|stream|] 0 (Array.length stream)
-          in
-          (* Try to decode video. *)
-          let got_video =
-            try
-              Ogg_demuxer.decode_video s.decoder feed ;
-              true
-            with
-              | Not_found
-              | Ogg.Not_enough_data -> false
-          in
-          if not got_audio && not got_video then
-            Ogg_demuxer.feed s.decoder);
-    position = (fun s -> Unix.lseek s.fd 0 Unix.SEEK_CUR);
-    close = (fun s ->
-               try
-                 Unix.close s.fd
-               with _ -> ())
-  }
-
-let () = Decoder.formats#register "OGG" (File_decoder.decode decoder)
+          Generator.put_audio buffer content 0 length
+      in
+      let got_audio =
+        try
+          Ogg_demuxer.decode_audio decoder feed ;
+          true
+        with
+          | Not_found
+          | Ogg.Not_enough_data -> false
+      in
+      let feed (buf,_) =
+        let in_freq = int_of_float buf.Ogg_demuxer.fps in
+        let out_freq = Lazy.force Frame.video_rate in
+        let rgb = video_convert buf in
+        let stream = video_resample ~in_freq ~out_freq [|rgb|] 0 1 in
+          Generator.put_video buffer [|stream|] 0 (Array.length stream)
+      in
+      (* Try to decode video. *)
+      let got_video =
+        try
+          Ogg_demuxer.decode_video decoder feed ;
+          true
+        with
+          | Not_found
+          | Ogg.Not_enough_data -> false
+      in
+        if not got_audio && not got_video then
+          Ogg_demuxer.feed decoder)
+
+let create_file_decoder filename content_type kind =
+  let mode =
+    match content_type.Frame.video, content_type.Frame.audio with
+      | 0, _ -> Generator.Audio
+      | _, 0 -> Generator.Video
+      | _, _ -> Generator.Both
+  in
+  let generator = Generator.create mode in
+    Buffered.file_decoder filename kind create_decoder generator
+
+let get_type filename =
+  let sync,fd = Ogg.Sync.create_from_file filename in
+  let decoder = Ogg_demuxer.init sync in
+  let feed ((buf,_),_) =
+    raise (Channels (Array.length buf))
+  in
+  let audio =
+    try
+      Ogg_demuxer.decode_audio_rec decoder feed;
+      raise Not_found
+    with
+      | Channels x -> x
+      | Not_found  -> 0
+  in
+  let feed (buf,_) =
+    raise (Channels 1)
+  in
+  let video =
+    try
+      Ogg_demuxer.decode_video_rec decoder feed;
+      raise Not_found
+    with
+      | Channels x -> x
+      | Not_found  -> 0
+  in
+  let c_type =
+    { Frame.
+        audio = audio ;
+        video = video ;
+        midi  = 0 }
+  in
+    Unix.close fd ;
+    c_type
+
+let () =
+  Decoder.file_decoders#register "OGG"
+    ~sdoc:"Decode a file as OGG provided that libogg accepts it."
+    (fun filename kind ->
+       let content_type = get_type filename in
+         if Frame.type_has_kind content_type kind then
+           Some (fun () -> create_file_decoder filename content_type kind)
+         else
+           None)
 
 exception Metadata of (string*string) list
 
-let get_tags ~format file =
-  (* Fail if file is not decoded using the OGG demuxer. *)
-  if format <> "OGG" then
-    raise Not_found;
+let get_tags file =
   let sync,fd = Ogg.Sync.create_from_file file in
   let close () =

trunk/liquidsoap/src/lang/lang_builtins.ml

@@ -157 +157 @@
       Lang.unit)
 
+(* TODO restore the following code when Wav and External decoding are back
+
 let () =
   let process_t =
@@ -216 +218 @@
          Externalformat.register_external_metadata_resolver format resolver;
          Lang.unit)
+ *)
 
 let () =

trunk/liquidsoap/src/playlists/playlist_basic.ml

@@ -2 +2 @@
 
   Liquidsoap, a programmable audio stream generator.
-  Copyright 2003-2009 Savonet team
+  Copyright 2003-2010 Savonet team
 
   This program is free software; you can redistribute it and/or modify
@@ -29 +29 @@
 
 let test_text s = 
-  match Configure.data_mime s with
+  match Configure.data_mime with
     | None -> ()
-    | Some e when Pcre.pmatch ~pat:"text/.*" e -> ()
-    | Some e -> 
-       begin
-         log#f 3 "Wrong mime type %s for playlist" e ;
-         assert false
-       end
+    | Some get_mime ->
+        let mime = get_mime s in
+          if not (Pcre.pmatch ~pat:"text/.*" mime) then begin
+            log#f 3 "Wrong mime type %s for playlist!" mime ;
+            (* TODO this shouldn't be an assert false, it can happen *)
+            assert false
+          end
 
 (* This parser cannot detect the format !! *)

trunk/liquidsoap/src/request.ml

@@ -2 +2 @@
 
   Liquidsoap, a programmable audio stream generator.
-  Copyright 2003-2009 Savonet team
+  Copyright 2003-2010 Savonet team
 
   This program is free software; you can redistribute it and/or modify
@@ -154 +154 @@
 
 (** Requests.
-  * The purpose of a request is to get a valid file. The file can be audio,
+  * The purpose of a request is to get a valid file. The file can contain media
   * in which case validity implies finding a working decoder, or can be
   * something arbitrary, like a playlist.
@@ -217 +217 @@
   mutable root_metadata : metadata ;
   mutable indicators : indicator list list ;
-  mutable decoder : (unit -> Decoder.decoder) option ;
+  mutable decoder : (unit -> Decoder.file_decoder) option ;
 }
 
@@ -317 +317 @@
       let indicator = peek_indicator t in
       let name = indicator.string in
-        match Decoder.search_valid name kind with
-          | Some (format,f) ->
+        match Decoder.get_file_decoder name kind with
+          | Some f ->
               t.decoder <- Some f ;
               mresolvers#iter
                 (fun _ resolver ->
                    try
-                     let ans = resolver ~format name in
+                     let ans = resolver name in
                        List.iter
                          (fun (k,v) ->
@@ -378 +378 @@
   try
     dresolvers#iter
-      (fun format resolver ->
+      (fun name resolver ->
         try
          let ans = resolver file in

trunk/liquidsoap/src/request.mli

@@ -2 +2 @@
 
   Liquidsoap, a programmable audio stream generator.
-  Copyright 2003-2009 Savonet team
+  Copyright 2003-2010 Savonet team
 
   This program is free software; you can redistribute it and/or modify
@@ -163 +163 @@
 (** Return a decoder if the file has been resolved, guaranteed to have
   * available data to deliver. *)
-val get_decoder : t -> Decoder.decoder option
+val get_decoder : t -> Decoder.file_decoder option
 
 (** {1 Plugs}
@@ -173 +173 @@
 
 val dresolvers : (string -> float) Plug.plug
-val mresolvers : (format:string -> string -> (string*string) list) Plug.plug
+val mresolvers : (string -> (string*string) list) Plug.plug
 val protocols : protocol Plug.plug

trunk/liquidsoap/src/sources/generated.ml

@@ -2 +2 @@
 
   Liquidsoap, a programmable audio stream generator.
-  Copyright 2003-2009 Savonet team
+  Copyright 2003-2010 Savonet team
 
   This program is free software; you can redistribute it and/or modify
@@ -21 +21 @@
  *****************************************************************************)
 
-module type Generator_t =
-sig
-  type t
-  val length : t -> int (* ticks *)
-  val remaining : t -> int (* ticks *)
-  val clear : t -> unit
-  val fill : t -> Frame.t -> unit
-  val add_metadata : t -> Frame.metadata -> unit
-end
-
-module Make (Generator:Generator_t) =
+module Make (Generator:Generator.S) =
 struct
 

trunk/liquidsoap/src/sources/harbor_input.ml

@@ -2 +2 @@
 
   Liquidsoap, a programmable audio stream generator.
-  Copyright 2003-2009 Savonet team
+  Copyright 2003-2010 Savonet team
 
   This program is free software; you can redistribute it and/or modify
@@ -24 +24 @@
 open Http_source
 
-
 (* {1 Input handling} *)
-
-exception NoDecoder
 
 class http_input_server ~kind ~dumpfile ~logfile
@@ -33 +30 @@
                         ~on_connect ~on_disconnect
                         ~login ~debug =
-  let abg_max_len = Frame.audio_of_seconds max in
+  (* let abg_max_len = Frame.audio_of_seconds max in
+     TODO handle buffer overflow, cf. input.http *)
 object (self)
   inherit Source.source kind
@@ -43 +41 @@
   val mutable relaying = false
   val mutable ns = []
-  val mutable decoder = fun _ -> raise NoDecoder
-  val mutable stype = None
+  val mutable create_decoder = fun _ -> assert false
+  val mutable mime_type = None
 
   val mutable dump = None
@@ -65 +63 @@
     Generator.add_metadata generator m
 
-  method put sample_freq data =
-    if not relaying then failwith "relaying stopped" ;
-    Mutex.lock lock ;
-    (* TODO There must be two ways of handling overfull generator:
-     * (1) when streaming, one should just stop the decoder for a while;
-     * (2) when not streaming, one should throw some data.
-     * Doing 1 instead of 2 can lead to deconnections.
-     * Doing 2 instead of 1 leads to ugly sound.
-     * Here, we drop data since we want to remain
-     * connected to the client. *)
-    if Generator.length generator >= abg_max_len then
-      begin
-        Mutex.unlock lock ;
-        Thread.delay (max /. 3.) ;
-        Mutex.lock lock ;
-        if Generator.length generator >= abg_max_len then
-        (* Here, we drop some data after the maximun buffer has been filled.
-         * Delaying the function can lead to deconnection/connection cycles
-         * when the source is not pulled. *)
-          Generator.remove generator (Generator.length generator - abg_max_len)
-      end ;
-    (* TODO: convert sample rate *)
-    Generator.put_audio generator data 0 (Array.length data.(0));
-    Mutex.unlock lock
-
-  method register_decoder s =
-    match
-      Http_source.stream_decoders#get s
-    with
-      | Some d -> decoder <- d ; stype <- Some s
-      | None -> raise Harbor.Unknown_codec
-
-  method get_type = stype
-
-  method feed socket  =
+  (* TODO There must be two ways of handling overfull generator:
+   * (1) when streaming, one should just stop the decoder for a while;
+   * (2) when not streaming, one should throw some data.
+   * Doing 1 instead of 2 can lead to deconnections.
+   * Doing 2 instead of 1 leads to ugly sound.
+   * Here, we USED TO drop data since we want to remain
+   * connected to the client.
+   * TODO Restore the old behavior. *)
+
+  method get_mime_type = mime_type
+
+  method feed socket =
     self#log#f 3 "Decoding..." ;
-    let close () = () in
     let t0 = Unix.gettimeofday () in
     let read len =
@@ -112 +86 @@
               if float n >= Harbor.conf_timeout#get then
                begin
-                self#log#f 4 "network activity timeout! disconnecting source" ;
+                self#log#f 4 "Network activity timeout! Disconnecting source." ;
                 self#disconnect
                end
@@ -122 +96 @@
       let input = Unix.read socket buf 0 len in
       if input<=0 then raise End_of_file ;
-      let s = String.sub buf 0 input in
       begin match dump with
-        | Some b -> output_string b s
+        | Some b -> output_string b (String.sub buf 0 input)
         | None -> ()
       end ;
@@ -133 +106 @@
         | None -> ()
       end ;
-      s
+      buf,input
     in
-    let sink =
-      { put = self#put ; read = read ;
-        insert_metadata = self#insert_metadata ; close = close }
-    in
-     begin
-      try decoder sink with
-        | e -> self#log#f 2 "Feeding stopped: %s" (Printexc.to_string e) ;
-               if debug then raise e
-     end;
-    self#disconnect ;
-    try
-      Unix.close socket
-    with
-      | _ -> ()
+    let Decoder.Decoder decoder = create_decoder read in
+      try
+        while true do
+          if not relaying then failwith "relaying stopped" ;
+          decoder generator
+        done
+      with
+        | e ->
+            self#log#f 2 "Feeding stopped: %s" (Printexc.to_string e) ;
+            if debug then raise e ;
+            self#disconnect ;
+            begin try Unix.close socket with _ -> () end
 
   method private wake_up _ =
@@ -176 +147 @@
   method private sleep =
     if relaying then self#disconnect
+
+  method register_decoder mime =
+    match
+      Decoder.get_stream_decoder mime kind
+    with
+      | Some d -> create_decoder <- d ; mime_type <- Some mime
+      | None -> raise Harbor.Unknown_codec
 
   method relay (headers:(string*string) list) socket =
@@ -220 +198 @@
 
 let () =
-  (* TODO: handle video too! *)
   let kind = Lang.kind_type_of_kind_format ~fresh:1 Lang.audio_any in
     Lang.add_operator "input.harbor"

trunk/liquidsoap/src/sources/http_source.ml

@@ -2 +2 @@
 
   Liquidsoap, a programmable audio stream generator.
-  Copyright 2003-2009 Savonet team
+  Copyright 2003-2010 Savonet team
 
   This program is free software; you can redistribute it and/or modify
@@ -42 +42 @@
     ]
 
-type sink = {
-  read : int -> string ;
-  put : int -> float array array -> unit ;
-  insert_metadata : Frame.metadata -> unit ;
-  close : unit -> unit
-}
-
 (** Types for playlist handling *)
 type playlist_mode =  Random | First | Randomize | Normal
 
-
-let stream_decoders : (sink -> unit) Plug.plug =
-  Plug.create ~doc:"Methods for decoding audio streams." "stream formats"
-
-(** Utilities for reading icy metadata *)
-
+(** Utility for reading icy metadata *)
 let read_metadata () = let old_chunk = ref "" in fun socket ->
   let size =
@@ -128 +116 @@
   let chunkbuf = ref "" in
   let read buf offs len =
-    if chunked then
-      (
-        if String.length !chunkbuf = 0 then chunkbuf := read_chunk socket;
-        let n = min len (String.length !chunkbuf) in
-          String.blit !chunkbuf 0 buf offs n;
-          chunkbuf := String.sub !chunkbuf n (String.length !chunkbuf - n);
-          n
-      )
-    else
+    if chunked then begin
+      if String.length !chunkbuf = 0 then chunkbuf := read_chunk socket;
+      let n = min len (String.length !chunkbuf) in
+        String.blit !chunkbuf 0 buf offs n;
+        chunkbuf := String.sub !chunkbuf n (String.length !chunkbuf - n);
+        n
+    end else
       Unix.read socket buf 0 len
   in
@@ -144 +130 @@
             let b = String.create len in
             let r = read b 0 len in
-              if r < 0 then "" else String.sub b 0 r
+              if r < 0 then "",0 else b,r
       | Some metaint ->
           let readcnt = ref 0 in
@@ -151 +137 @@
               let b = String.create len in
               let r = read b 0 len in
-                if r < 0 then "" else begin
+                if r < 0 then "",0 else begin
                   readcnt := !readcnt + r;
                   if !readcnt = metaint then begin
@@ -159 +145 @@
                       | None -> ()
                   end ;
-                  String.sub b 0 r
+                  b,r
                 end
 
-(** Generic http input *)
+(** HTTP input *)
 
 let url_expr = Str.regexp "^http://\\([^/]+\\)\\(/.*\\)?$"
@@ -202 +188 @@
         ~debug ?(logfile=None)
         ~user_agent url =
-  let max_len =
+  let _ =
+  (* TODO
+   * We used to deal with overfull generators in the [put] method,
+   * passed to the stream decoders in the [sink]. Now, the
+   * interface is simpler, but we need to put this back somewhere:
+   * add overfull management to Generators? This can be done
+   * for a specific kind of generator, that also needs to be
+   * thread safe:
+   *
+   * The old "sink" system was used to:
+   *  - control concurrency on the generator
+   *  - log
+   *  - conversions (samplerate)
+   *  - control (fail to stop feeding on source/output stop)
+   * Most of it was adapted by passing directly a generator to the
+   * decoder, but we still need to handle multi-threading,
+   * by ensuring that read/writing in the generator don't occur
+   * at the same time. *)
     Frame.audio_of_seconds (Pervasives.max max bufferize)
   in
@@ -225 +228 @@
   val mutable logf = None
 
-  (* Frame content converter *)
-  (* TODO: VIDEO !*)
-  val converter = Rutils.create_audio ()
-
   val mutable connected = false
   val mutable relaying = autostart
@@ -241 +240 @@
     if track_on_meta then Generator.add_break generator ;
 
-  (* Feed the buffer generator
-   * TODO this is too restrictive, data could be of any [kind] *)
-  method private put sample_freq data =
-    if not relaying then failwith "relaying stopped" ;
-    if poll_should_stop then failwith "source stopped" ;
-    Mutex.lock lock ;
-    (* Drop data when buffer is full. This is the only way
-     * to make it work with switches, when input.http is not
-     * pulled for some time.
-     * It can also be necessary if liquidsoap is slower than the stream. *)
-    if Generator.length generator >= max_len then begin
-      (* TODO Inserting a break in the generator could be a good idea,
-       * for notifying about the gap/drop.
-       * It would require to stop the current #put, since multiple
-       * breaks are not allowed. *)
-      self#log#f 5 "Overfull buffer: dropping data." ;
-      Generator.remove generator (Generator.length generator - max_len)
-    end;
-   let audio_src_rate = float sample_freq in
-   let content,length =
-     converter ~audio_src_rate data
-   in
-     Generator.put_audio generator content 0 (Frame.master_of_audio length) ;
-     Mutex.unlock lock
-
-  method feeding ?(newstream=true) dec socket chunked metaint =
+  method feeding ?(newstream=true) create_decoder socket chunked metaint =
     connected <- true ;
-    let close () = Http.disconnect socket in
     let read = read_stream socket chunked metaint self#insert_metadata in
     let read =
@@ -276 +249 @@
             let t0 = Unix.gettimeofday () in
               fun len ->
-                let ret : string = read len in
+                let ret = read len in
                 let time = (Unix.gettimeofday () -. t0) /. 60. in
                   Printf.fprintf f "%f %d\n%!" time self#length ;
                   ret
     in
-    let sink =
-      { put = self#put ; read = read ;
-        insert_metadata = self#insert_metadata ; close = close }
-    in
+    let Decoder.Decoder decoder = create_decoder read in
       try
-       (* Starting decoding: adding a break here *)
-       Generator.add_break generator ;
-       dec sink
+        while true do
+          if should_fail then failwith "end of track" ;
+          if poll_should_stop then failwith "source stopped" ;
+          decoder generator
+        done
       with
         | e ->
@@ -431 +403 @@
                         let dec =
                           match
-                            stream_decoders#get content_type
+                            Decoder.get_stream_decoder content_type kind
                           with
                             | Some d -> d
@@ -491 +463 @@
                ~descr:"Get the buffer's length, in seconds."
        (fun _ -> Printf.sprintf "%.2f" (Frame.seconds_of_audio self#length))
-
 
   method sleep = poll_should_stop <- true

trunk/liquidsoap/src/sources/lastfm_input.ml

@@ -2 +2 @@
 
   Liquidsoap, a programmable audio stream generator.
-  Copyright 2003-2009 Savonet team
+  Copyright 2003-2010 Savonet team
 
   This program is free software; you can redistribute it and/or modify
@@ -80 +80 @@
           session <- None ;
           self#log#f 4
-            "Could not get file from lastfm: %s" (Lastfm.Radio.string_of_error e)
+            "Could not get file from lastfm: %s"
+            (Lastfm.Radio.string_of_error e)
       | e -> self#log#f 4 "Lastfm connection failed: %s" (Printexc.to_string e)
 
-  val mutable abort_stream = false
+  (* TODO abort streaming on #abort_track,
+   *   setting relaying <- false is too radical, it would completely
+   *   stop. *)
 
-  method put sample_freq data =
-    if abort_stream then begin
-      abort_stream <- false ;
-      failwith "streaming was aborted"
-    end ;
-    http#put sample_freq data
-
-  method abort_track =
-    abort_stream <- true
-
-  method get ab = 
-    http#get ab ;
+  method private get_frame ab = 
+    http#get_frame ab ;
     if Frame.is_partial ab then
      begin
@@ -108 +101 @@
         | None -> ()
      end
+
 end
 
@@ -115 +109 @@
       ~kind:(Lang.Unconstrained k)
       ~category:Lang.Input
-      ~descr:("Forwards the given lastfm stream. The relay can be "^
-              "paused/resumed using the start/stop telnet commands.")
+      ~descr:"Forwards the given lastfm stream. The relay can be \
+              paused/resumed using the start/stop telnet commands."
       [ "autostart", Lang.bool_t, Some (Lang.bool true),
         Some "Initially start relaying or not." ;
@@ -122 +116 @@
         Some "Duration of the pre-buffered data." ;
         "bind_address", Lang.string_t, Some (Lang.string ""),
-        Some ("address to bind on the local machine. This option can be useful if " ^
-        "your machine is bound to multiple IPs. \"\" means no bind address.") ;
+        Some "Address to bind on the local machine. \
+              This option can be useful if your machine is bound to \
+              multiple IPs. \"\" means no bind address." ;
         "timeout", Lang.float_t, Some (Lang.float 10.),
         Some "Timeout for HTTP connections." ;

trunk/liquidsoap/src/stream/generator.ml

@@ -2 +2 @@
 
   Liquidsoap, a programmable audio stream generator.
-  Copyright 2003-2009 Savonet team
+  Copyright 2003-2010 Savonet team
 
   This program is free software; you can redistribute it and/or modify
@@ -21 +21 @@
  *****************************************************************************)
 
-(** The base module doesn't even know what it is buffering. *)
+module type S =
+sig
+  type t
+  val length : t -> int (* ticks *)
+  val remaining : t -> int (* ticks *)
+  val clear : t -> unit
+  val fill : t -> Frame.t -> unit
+  val add_metadata : t -> Frame.metadata -> unit
+end
+
+(** The base module doesn't even know what kind of data it is buffering. *)
 module Generator =
 struct

trunk/liquidsoap/src/stream/generator.mli

@@ -2 +2 @@
 
   Liquidsoap, a programmable audio stream generator.
-  Copyright 2003-2009 Savonet team
+  Copyright 2003-2010 Savonet team
 
   This program is free software; you can redistribute it and/or modify
@@ -20 +20 @@
 
  *****************************************************************************)
+
+module type S =
+sig
+  type t
+  val length : t -> int (* ticks *)
+  val remaining : t -> int (* ticks *)
+  val clear : t -> unit
+  val fill : t -> Frame.t -> unit
+  val add_metadata : t -> Frame.metadata -> unit
+end
 
 module Generator :

trunk/liquidsoap/src/tools/harbor.ml

@@ -2 +2 @@
 
   Liquidsoap, a programmable audio stream generator.
-  Copyright 2003-2009 Savonet team
+  Copyright 2003-2010 Savonet team
 
   This program is free software; you can redistribute it and/or modify
@@ -71 +71 @@
   method virtual is_taken : bool
   method virtual register_decoder : string -> unit
-  method virtual get_type : string option
+  method virtual get_mime_type : string option
 
 end
@@ -267 +267 @@
       | _ ->
           s#register_decoder stype ;
-          log#f 3 "Adding source on mountpoint '%s' with type '%s'." uri stype ;
+          log#f 3 "Adding source on mountpoint %S with type %S." uri stype ;
           if not icy then write_answer ~keep:true c "HTTP/1.0 200 OK\r\n\r\n" ;
           s#relay headers c
@@ -366 +366 @@
                     "Source is not mp3")
               in
-              if not (List.mem (Utils.get_some s#get_type) 
+              if not (List.mem (Utils.get_some s#get_mime_type) 
                                conf_icy_metadata#get) 
               then