Add support for splitting on video key frame in output.file.hls

Author: toots

src/encoder.ml

@@ -157,6 +157,13 @@ let extension = function
   | Shine _ -> "mp3"
   | Flac _ -> "flac"
   | FdkAacEnc _ -> "aac"
+  (* Todo: add more.. *)
+  | Ffmpeg { Ffmpeg_format.format = Some "ogg" } -> "ogg"
+  | Ffmpeg { Ffmpeg_format.format = Some "opus" } -> "opus"
+  | Ffmpeg { Ffmpeg_format.format = Some "libmp3lame" } -> "mp3"
+  | Ffmpeg { Ffmpeg_format.format = Some "mpegts" } -> "ts"
+  | Ffmpeg { Ffmpeg_format.format = Some "mp4" } -> "mp4"
+  | Ffmpeg { Ffmpeg_format.format = Some "wav" } -> "wav"
   | _ -> raise Not_found
 
 (** Mime types *)
@@ -194,32 +201,46 @@ let with_url_output encoder file =
     | _ -> failwith "No file output!"
 
 (** An encoder, once initialized, is something that consumes
-  * frames, insert metadata and that you eventually close 
-  * (triggers flushing). 
-  * Insert metadata is really meant for inline metadata, i.e.
-  * in most cases, stream sources. Otherwise, metadata are
-  * passed when creating the encoder. For instance, the mp3 
-  * encoder may accept metadata initally and write them as 
-  * id3 tags but does not support inline metadata. 
-  * Also, the ogg encoder supports inline metadata but restarts
-  * its stream. This is ok, though, because the ogg container/streams 
-  * is meant to be sequentialized but not the mp3 format. 
-  * header contains data that should be sent first to streaming 
-  * client. *)
+    frames, insert metadata and that you eventually close 
+    (triggers flushing). 
+    Insert metadata is really meant for inline metadata, i.e.
+    in most cases, stream sources. Otherwise, metadata are
+    passed when creating the encoder. For instance, the mp3 
+    encoder may accept metadata initally and write them as 
+    id3 tags but does not support inline metadata. 
+    Also, the ogg encoder supports inline metadata but restarts
+    its stream. This is ok, though, because the ogg container/streams 
+    is meant to be sequentialized but not the mp3 format. 
+    header contains data that should be sent first to streaming 
+    client. *)
+
+type split_result =
+  [ (* Returns (flushed, first_bytes_for_next_segment) *)
+    `Ok of
+    Strings.t * Strings.t
+  | `Nope of Strings.t ]
+
+type hls = {
+  (* Returns (init_segment, first_bytes) *)
+  init_encode : Frame.t -> int -> int -> Strings.t option * Strings.t;
+  split_encode : Frame.t -> int -> int -> split_result;
+}
+
 type encoder = {
   insert_metadata : Meta_format.export_metadata -> unit;
-  (* Encoder are all called from the main 
-   * thread so there's no need to protect this
-   * value with a mutex so far.. *)
+  (* Encoder are all called from the main
+     thread so there's no need to protect this
+     value with a mutex so far.. *)
   mutable header : Strings.t;
+  hls : hls;
   encode : Frame.t -> int -> int -> Strings.t;
   stop : unit -> Strings.t;
 }
 
 type factory = string -> Meta_format.export_metadata -> encoder
 
 (** A plugin might or might not accept a given format.
-  * If it accepts it, it gives a function creating suitable encoders. *)
+    If it accepts it, it gives a function creating suitable encoders. *)
 type plugin = format -> factory option
 
 let plug : plugin Plug.plug =

src/encoder.mli

@@ -0,0 +1,110 @@
+(*****************************************************************************
+
+  Liquidsoap, a programmable audio stream generator.
+  Copyright 2003-2020 Savonet team
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details, fully stated in the COPYING
+  file at the root of the liquidsoap distribution.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+
+ *****************************************************************************)
+
+(** Common infrastructure for encoding streams *)
+
+type format =
+  | WAV of Wav_format.t
+  | AVI of Avi_format.t
+  | Ogg of Ogg_format.t
+  | MP3 of Mp3_format.t
+  | Shine of Shine_format.t
+  | Flac of Flac_format.t
+  | Ffmpeg of Ffmpeg_format.t
+  | FdkAacEnc of Fdkaac_format.t
+  | External of External_encoder_format.t
+  | GStreamer of Gstreamer_format.t
+
+val audio_kind : int -> Frame.kind Frame.fields
+val audio_video_kind : int -> Frame.kind Frame.fields
+val kind_of_format : format -> Frame.kind Frame.fields
+val string_of_format : format -> string
+
+(** ISO Base Media File Format, see RFC 6381 section 3.3. *)
+val iso_base_file_media_file_format : format -> string
+
+(** Proposed extension for files. *)
+val extension : format -> string
+
+(** Mime types *)
+val mime : format -> string
+
+(** Bitrate estimation in bits per second. *)
+val bitrate : format -> int
+
+(** Encoders that can output to a file. *)
+val file_output : format -> bool
+
+val with_file_output : format -> string -> format
+
+(** Encoders that can output to a arbitrary url. *)
+val url_output : format -> bool
+
+val with_url_output : format -> string -> format
+
+(** An encoder, once initialized, is something that consumes
+  * frames, insert metadata and that you eventually close 
+  * (triggers flushing). 
+  * Insert metadata is really meant for inline metadata, i.e.
+  * in most cases, stream sources. Otherwise, metadata are
+  * passed when creating the encoder. For instance, the mp3 
+  * encoder may accept metadata initally and write them as 
+  * id3 tags but does not support inline metadata. 
+  * Also, the ogg encoder supports inline metadata but restarts
+  * its stream. This is ok, though, because the ogg container/streams 
+  * is meant to be sequentialized but not the mp3 format. 
+  * header contains data that should be sent first to streaming 
+  * client. *)
+
+type split_result =
+  [ (* Returns (flushed, first_bytes_for_next_segment) *)
+    `Ok of
+    Strings.t * Strings.t
+  | `Nope of Strings.t ]
+
+type hls = {
+  (* Returns (init_segment, first_bytes) *)
+  init_encode : Frame.t -> int -> int -> Strings.t option * Strings.t;
+  split_encode : Frame.t -> int -> int -> split_result;
+}
+
+type encoder = {
+  insert_metadata : Meta_format.export_metadata -> unit;
+  (* Encoder are all called from the main 
+   * thread so there's no need to protect this
+   * value with a mutex so far.. *)
+  mutable header : Strings.t;
+  hls : hls;
+  encode : Frame.t -> int -> int -> Strings.t;
+  stop : unit -> Strings.t;
+}
+
+type factory = string -> Meta_format.export_metadata -> encoder
+
+(** A plugin might or might not accept a given format.
+  * If it accepts it, it gives a function creating suitable encoders. *)
+type plugin = format -> factory option
+
+val plug : plugin Plug.plug
+
+(** Return the first available encoder factory for that format. *)
+val get_factory : format -> factory

src/encoder/avi_encoder.ml

@@ -78,8 +78,15 @@ let encoder avi =
       Strings.dda header ans )
     else ans
   in
+  let hls =
+    {
+      Encoder.init_encode = (fun f o l -> (None, encode f o l));
+      split_encode = (fun f o l -> `Ok (Strings.empty, encode f o l));
+    }
+  in
   {
     Encoder.insert_metadata = (fun _ -> ());
+    hls;
     encode;
     header = Strings.of_string header;
     stop = (fun () -> Strings.empty);

src/encoder/external_encoder.ml

@@ -153,12 +153,19 @@ let encoder id ext =
         Condition.wait condition mutex;
         Strings.Mutable.flush buf)
   in
+  let hls =
+    {
+      Encoder.init_encode = (fun f o l -> (None, encode f o l));
+      split_encode = (fun f o l -> `Ok (Strings.empty, encode f o l));
+    }
+  in
   {
     Encoder.insert_metadata;
     (* External encoders do not support 
      * headers for now. They will probably
      * never do.. *)
     header = Strings.empty;
+    hls;
     encode;
     stop;
   }

src/encoder/fdkaac_encoder.ml

@@ -159,9 +159,16 @@ module Register (Fdkaac : Fdkaac_t) = struct
       Strings.Mutable.add rem (Fdkaac.Encoder.flush enc);
       Strings.Mutable.to_strings rem
     in
+    let hls =
+      {
+        Encoder.init_encode = (fun f o l -> (None, encode f o l));
+        split_encode = (fun f o l -> `Ok (Strings.empty, encode f o l));
+      }
+    in
     {
       Encoder.insert_metadata = (fun _ -> ());
       header = Strings.empty;
+      hls;
       encode;
       stop;
     }

src/encoder/ffmpeg_copy_encoder.ml

@@ -55,10 +55,14 @@ let mk_stream_copy ~get_data output =
       | _ -> failwith "Packet missing duration!"
   in
 
+  let was_keyframe = ref false in
+
   let encode frame start len =
     let stop = start + len in
     let data = (get_data frame).Ffmpeg_content_base.data in
 
+    was_keyframe := false;
+
     List.iter
       (fun (pos, { Ffmpeg_copy_content.packet; time_base }) ->
         let stream = Option.get !stream in
@@ -76,7 +80,12 @@ let mk_stream_copy ~get_data output =
           add ~duration ~time_base next_dts;
           add ~duration ~time_base next_pts;
 
-          Av.write_packet stream master_time_base packet ))
+          Av.write_packet stream master_time_base packet;
+          if List.mem `Keyframe Avcodec.Packet.(get_flags packet) then
+            was_keyframe := true ))
       data
   in
-  { Ffmpeg_encoder_common.mk_stream; encode }
+
+  let was_keyframe () = !was_keyframe in
+
+  { Ffmpeg_encoder_common.mk_stream; was_keyframe; encode }

src/encoder/ffmpeg_encoder_common.ml

@@ -27,6 +27,7 @@ let log = Ffmpeg_utils.log
 type encoder = {
   mk_stream : Frame.t -> unit;
   encode : Frame.t -> int -> int -> unit;
+  was_keyframe : unit -> bool;
 }
 
 type handler = {
@@ -110,6 +111,34 @@ let encoder ~mk_audio ~mk_video ffmpeg meta =
     { output; audio_stream; video_stream; started = false }
   in
   let encoder = ref (make ()) in
+  let init_encode frame start len =
+    let encoder = !encoder in
+    match ffmpeg.Ffmpeg_format.format with
+      | Some "mp4" ->
+          encode ~encoder frame start len;
+          Av.flush encoder.output;
+          let init = Strings.Mutable.flush buf in
+          (Some init, Strings.empty)
+      | Some "webm" ->
+          Av.flush encoder.output;
+          let init = Strings.Mutable.flush buf in
+          encode ~encoder frame start len;
+          (Some init, Strings.Mutable.flush buf)
+      | _ ->
+          encode ~encoder frame start len;
+          (None, Strings.Mutable.flush buf)
+  in
+  let split_encode frame start len =
+    let encoder = !encoder in
+    Av.flush encoder.output;
+    let flushed = Strings.Mutable.flush buf in
+    encode ~encoder frame start len;
+    let encoded = Strings.Mutable.flush buf in
+    match encoder.video_stream with
+      | Some s when s.was_keyframe () -> `Ok (flushed, encoded)
+      | None -> `Ok (flushed, encoded)
+      | _ -> `Nope (Strings.append flushed encoded)
+  in
   let encode frame start len =
     encode ~encoder:!encoder frame start len;
     Strings.Mutable.flush buf
@@ -120,4 +149,5 @@ let encoder ~mk_audio ~mk_video ffmpeg meta =
     Av.close !encoder.output;
     Strings.Mutable.flush buf
   in
-  { Encoder.insert_metadata; header = Strings.empty; encode; stop }
+  let hls = { Encoder.init_encode; split_encode } in
+  { Encoder.insert_metadata; header = Strings.empty; hls; encode; stop }

src/encoder/ffmpeg_internal_encoder.ml

@@ -200,11 +200,13 @@ let mk_audio ~ffmpeg ~options output =
         flush () )
   in
 
+  let was_keyframe () = false in
+
   let encode frame start len =
     List.iter write_frame (converter frame start len)
   in
 
-  { Ffmpeg_encoder_common.mk_stream; encode }
+  { Ffmpeg_encoder_common.mk_stream; was_keyframe; encode }
 
 let mk_video ~ffmpeg ~options output =
   let codec =
@@ -276,6 +278,8 @@ let mk_video ~ffmpeg ~options output =
 
   let stream_time_base = Av.get_time_base stream in
 
+  let was_keyframe = ref false in
+
   let fps_converter ~time_base frame =
     let converter =
       get_converter ~time_base
@@ -291,7 +295,8 @@ let mk_video ~ffmpeg ~options output =
             (Avutil.frame_pts frame)
         in
         Avutil.frame_set_pts frame frame_pts;
-        Av.write_frame stream frame)
+        Av.write_frame stream frame;
+        if Av.was_keyframe stream then was_keyframe := true)
   in
 
   let internal_converter cb =
@@ -369,6 +374,11 @@ let mk_video ~ffmpeg ~options output =
       | _ -> assert false
   in
 
-  let encode = converter fps_converter in
+  let encode =
+    was_keyframe := false;
+    converter fps_converter
+  in
+
+  let was_keyframe () = !was_keyframe in
 
-  { Ffmpeg_encoder_common.mk_stream; encode }
+  { Ffmpeg_encoder_common.mk_stream; was_keyframe; encode }

src/encoder/flac_encoder.ml

@@ -64,11 +64,18 @@ let encoder flac meta =
     Flac.Encoder.finish !enc cb;
     Strings.Mutable.flush buf
   in
+  let hls =
+    {
+      Encoder.init_encode = (fun f o l -> (None, encode f o l));
+      split_encode = (fun f o l -> `Ok (Strings.empty, encode f o l));
+    }
+  in
   {
     Encoder.insert_metadata = (fun _ -> ());
     (* Flac encoder do not support header
      * for now. It will probably never do.. *)
     header = Strings.empty;
+    hls;
     encode;
     stop;
   }