recorder: don't use a magic index for mp_recorder_get_sink()

Although this was sort of elegant, it just seems to complicate things
slightly. Originally, the API meant that you cache mp_recorder_sink
yourself (which would avoid the mess of passing an index around), but
that too seems slightly roundabout.

In a later change, I want to change the set of streams passed to
mp_recorder_create(), and then I'd have to keep track of the index for
each stream, which would suck. With this commit, I can just pass the
unambiguous sh_stream to it, and it will be guaranteed to match the
correct stream.

The disadvantages are barely worth discussing. It's a new linear search
per packet, but usually only 2 to 4 streams are active at a time. Also,
in theory a user could want to write 2 streams using the same sh_stream
(same metadata, just writing different packets or so), but in practice
this is never done.

common/recorder.c

@@ -328,11 +328,17 @@ void mp_recorder_mark_discontinuity(struct mp_recorder *priv)
 }
 
 // Get a stream for writing. The pointer is valid until mp_recorder is
-// destroyed. The stream is the index referencing the stream passed to
-// mp_recorder_create().
-struct mp_recorder_sink *mp_recorder_get_sink(struct mp_recorder *r, int stream)
+// destroyed. The stream ptr. is the same as one passed to
+// mp_recorder_create() (returns NULL if it wasn't).
+struct mp_recorder_sink *mp_recorder_get_sink(struct mp_recorder *r,
+                                              struct sh_stream *stream)
 {
-    return stream >= 0 && stream < r->num_streams ? r->streams[stream] : NULL;
+    for (int n = 0; n < r->num_streams; n++) {
+        struct mp_recorder_sink *rst = r->streams[n];
+        if (rst->sh == stream)
+            return rst;
+    }
+    return NULL;
 }
 
 // Pass a packet to the given stream. The function does not own the packet, but

common/recorder.h

@@ -14,7 +14,8 @@ struct mp_recorder *mp_recorder_create(struct mpv_global *global,
 void mp_recorder_destroy(struct mp_recorder *r);
 void mp_recorder_mark_discontinuity(struct mp_recorder *r);
 
-struct mp_recorder_sink *mp_recorder_get_sink(struct mp_recorder *r, int stream);
+struct mp_recorder_sink *mp_recorder_get_sink(struct mp_recorder *r,
+                                              struct sh_stream *stream);
 void mp_recorder_feed_packet(struct mp_recorder_sink *s,
                              struct demux_packet *pkt);
 

demux/demux.c

@@ -1907,7 +1907,8 @@ static void write_dump_packet(struct demux_internal *in, struct demux_packet *dp
     assert(in->dumper);
     assert(in->dumper_status == CONTROL_TRUE);
 
-    struct mp_recorder_sink *sink = mp_recorder_get_sink(in->dumper, dp->stream);
+    struct mp_recorder_sink *sink =
+        mp_recorder_get_sink(in->dumper, in->streams[dp->stream]);
     if (sink) {
         mp_recorder_feed_packet(sink, dp);
     } else {
@@ -1935,7 +1936,7 @@ static void record_packet(struct demux_internal *in, struct demux_packet *dp)
 
     if (in->recorder) {
         struct mp_recorder_sink *sink =
-            mp_recorder_get_sink(in->recorder, dp->stream);
+            mp_recorder_get_sink(in->recorder, in->streams[dp->stream]);
         if (sink) {
             mp_recorder_feed_packet(sink, dp);
         } else {

player/loadfile.c

@@ -1874,7 +1874,7 @@ void open_recorder(struct MPContext *mpctx, bool on_init)
         // (We expect track->stream not to be reused on other tracks.)
         if (track->stream == streams[n_stream]) {
             struct mp_recorder_sink * sink =
-                mp_recorder_get_sink(mpctx->recorder, n_stream);
+                mp_recorder_get_sink(mpctx->recorder, streams[n_stream]);
             assert(sink);
             set_track_recorder_sink(track, sink);
             n_stream++;