Add set_decoder to specify explicit decoder for stream.

Author: toots

.ocamlformat

@@ -1,4 +1,4 @@
-version=0.18.0
+version=0.19.0
 profile = conventional
 break-separators = after
 space-around-lists = false

av/av.ml

@@ -121,10 +121,15 @@ external input_obj : input container -> 'a = "ocaml_av_input_obj"
 let input_obj c = Obj.magic (input_obj c, c)
 
 (* Input Stream *)
-type ('a, 'b, 'c) stream = { container : 'a container; index : int }
+type ('a, 'b, 'c) stream = {
+  container : 'a container;
+  index : int;
+  mutable decoder : ('b, Avcodec.decode) Avcodec.codec option;
+}
+
 type media_type = MT_audio | MT_video | MT_subtitle
 
-let mk_stream container index = { container; index }
+let mk_stream container index = { container; index; decoder = None }
 
 external get_codec_params : (_, 'm, _) stream -> 'm Avcodec.params
   = "ocaml_av_get_stream_codec_parameters"
@@ -153,6 +158,7 @@ let get_streams input media_type =
 let get_audio_streams input = get_streams input MT_audio
 let get_video_streams input = get_streams input MT_video
 let get_subtitle_streams input = get_streams input MT_subtitle
+let set_decoder s decoder = s.decoder <- Some decoder
 
 external _find_best_stream : input container -> media_type -> int
   = "ocaml_av_find_best_stream"
@@ -182,26 +188,29 @@ type input_result =
   | `Subtitle_frame of int * subtitle frame ]
 
 (** Reads the selected streams if any or all streams otherwise. *)
-external read_input : int array -> int array -> input container -> input_result
-  = "ocaml_av_read_input"
+external read_input :
+  (int * ('a, Avcodec.decode) Avcodec.codec option) array ->
+  (int * ('a, Avcodec.decode) Avcodec.codec option) array ->
+  input container ->
+  input_result = "ocaml_av_read_input"
 
-let get_id input =
-  List.map (fun { index; container } ->
+let _get input =
+  List.map (fun { index; container; decoder } ->
       if container != input then
         raise (Failure "Inconsistent stream and input!");
-      index)
+      (index, Obj.magic decoder))
 
 let read_input ?(audio_packet = []) ?(audio_frame = []) ?(video_packet = [])
     ?(video_frame = []) ?(subtitle_packet = []) ?(subtitle_frame = []) input =
   let packet =
     Array.of_list
-      (get_id input audio_packet @ get_id input video_packet
-      @ get_id input subtitle_packet)
+      (_get input audio_packet @ _get input video_packet
+     @ _get input subtitle_packet)
   in
   let frame =
     Array.of_list
-      (get_id input audio_frame @ get_id input video_frame
-      @ get_id input subtitle_frame)
+      (_get input audio_frame @ _get input video_frame
+     @ _get input subtitle_frame)
   in
   read_input packet frame input
 

av/av.mli

@@ -136,6 +136,10 @@ val get_duration : ?format:Time_format.t -> (input, _, _) stream -> Int64.t
 (** Same as {!Av.get_input_metadata} for the input streams. *)
 val get_metadata : (input, _, _) stream -> (string * string) list
 
+(** For the use of a specific decoder for the given input stream. *)
+val set_decoder :
+  (input, 'a, _) stream -> ('a, Avcodec.decode) Avcodec.codec -> unit
+
 type input_result =
   [ `Audio_packet of int * audio Avcodec.Packet.t
   | `Audio_frame of int * audio frame

av/av_stubs.c

@@ -784,7 +784,7 @@ static stream_t *allocate_stream_context(av_t *av, int index, AVCodec *codec) {
   return stream;
 }
 
-static stream_t *open_stream_index(av_t *av, int index) {
+static stream_t *open_stream_index(av_t *av, int index, AVCodec *dec) {
   int err;
 
   if (!av->format_context)
@@ -798,10 +798,11 @@ static stream_t *open_stream_index(av_t *av, int index) {
 
   // find decoder for the stream
   AVCodecParameters *dec_param = av->format_context->streams[index]->codecpar;
-
-  caml_release_runtime_system();
-  AVCodec *dec = avcodec_find_decoder(dec_param->codec_id);
-  caml_acquire_runtime_system();
+  if (!dec) {
+    caml_release_runtime_system();
+    dec = avcodec_find_decoder(dec_param->codec_id);
+    caml_acquire_runtime_system();
+  }
 
   if (!dec)
     ocaml_avutil_raise_error(AVERROR_DECODER_NOT_FOUND);
@@ -829,12 +830,6 @@ static stream_t *open_stream_index(av_t *av, int index) {
   return stream;
 }
 
-#define Check_stream(av, index)                                                \
-  {                                                                            \
-    if (!(av)->streams || !(av)->streams[(index)])                             \
-      open_stream_index((av), (index));                                        \
-  }
-
 CAMLprim value ocaml_av_find_best_stream(value _av, value _media_type) {
   CAMLparam2(_av, _media_type);
   av_t *av = Av_val(_av);
@@ -924,6 +919,8 @@ CAMLprim value ocaml_av_read_input(value _packet, value _frame, value _av) {
   av_t *av = Av_val(_av);
   AVFrame *frame;
   int i, ret, frame_kind, skip;
+  value _dec;
+  AVCodec *dec = NULL;
 
   if (!av->streams && !allocate_input_context(av))
     caml_raise_out_of_memory();
@@ -948,21 +945,29 @@ CAMLprim value ocaml_av_read_input(value _packet, value _frame, value _av) {
 
       skip = 1;
       for (i = 0; i < Wosize_val(_packet); i++)
-        if (Int_val(Field(_packet, i)) == packet->stream_index)
+        if (Int_val(Field(Field(_packet, i), 0)) == packet->stream_index) {
+          _dec = Field(Field(_packet, i), 1);
           skip = 0;
+        }
 
       for (i = 0; i < Wosize_val(_frame); i++)
-        if (Int_val(Field(_frame, i)) == packet->stream_index)
+        if (Int_val(Field(Field(_frame, i), 0)) == packet->stream_index) {
+          _dec = Field(Field(_frame, i), 1);
           skip = 0;
+        }
 
       if (skip)
         continue;
 
+      if (_dec != Val_none) {
+        dec = (AVCodec *)Some_val(_dec);
+      }
+
       if ((stream = streams[packet->stream_index]) == NULL)
-        stream = open_stream_index(av, packet->stream_index);
+        stream = open_stream_index(av, packet->stream_index, dec);
 
       for (i = 0; i < Wosize_val(_packet); i++) {
-        if (Int_val(Field(_packet, i)) == packet->stream_index) {
+        if (Int_val(Field(Field(_packet, i), 0)) == packet->stream_index) {
           decoded_content = caml_alloc_tuple(2);
           Field(decoded_content, 0) = Val_int(packet->stream_index);
           Field(decoded_content, 1) = value_of_ffmpeg_packet(packet);
@@ -999,7 +1004,7 @@ CAMLprim value ocaml_av_read_input(value _packet, value _frame, value _av) {
 
     skip = 1;
     for (i = 0; i < Wosize_val(_frame); i++) {
-      if (Int_val(Field(_frame, i)) == stream->index) {
+      if (Int_val(Field(Field(_frame, i), 0)) == stream->index) {
         skip = 0;
       }
     }

ffmpeg-av.opam

@@ -21,6 +21,7 @@ conflicts: [
   "ffmpeg" {< "0.5.0"}
 ]
 build: [
+  ["dune" "subst"] {dev}
   [
     "dune"
     "build"

ffmpeg-avcodec.opam

@@ -20,6 +20,7 @@ conflicts: [
   "ffmpeg" {< "0.5.0"}
 ]
 build: [
+  ["dune" "subst"] {dev}
   [
     "dune"
     "build"

ffmpeg-avdevice.opam

@@ -20,6 +20,7 @@ conflicts: [
   "ffmpeg" {< "0.5.0"}
 ]
 build: [
+  ["dune" "subst"] {dev}
   [
     "dune"
     "build"

ffmpeg-avfilter.opam

@@ -20,6 +20,7 @@ conflicts: [
   "ffmpeg" {< "0.5.0"}
 ]
 build: [
+  ["dune" "subst"] {dev}
   [
     "dune"
     "build"

ffmpeg-avutil.opam

@@ -20,6 +20,7 @@ conflicts: [
   "ffmpeg" {< "0.5.0"}
 ]
 build: [
+  ["dune" "subst"] {dev}
   [
     "dune"
     "build"

ffmpeg-swresample.opam

@@ -21,6 +21,7 @@ conflicts: [
   "ffmpeg" {< "0.5.0"}
 ]
 build: [
+  ["dune" "subst"] {dev}
   [
     "dune"
     "build"

ffmpeg-swscale.opam

@@ -20,6 +20,7 @@ conflicts: [
   "ffmpeg" {< "0.5.0"}
 ]
 build: [
+  ["dune" "subst"] {dev}
   [
     "dune"
     "build"

ffmpeg.opam

@@ -20,6 +20,7 @@ depends: [
   "odoc" {with-doc}
 ]
 build: [
+  ["dune" "subst"] {dev}
   [
     "dune"
     "build"