Updated muxing code

Author: djthorpe

encoder.go

@@ -146,3 +146,13 @@ func (encoder *encoder) Close() error {
 	// Return success
 	return nil
 }
+
+////////////////////////////////////////////////////////////////////////////////
+// PRIVATE METHODS
+
+func (encoder *encoder) encode(fn MuxFunc) (*ff.AVPacket, error) {
+	packet, err := fn(encoder.stream.Id())
+	if packet != nil {
+	}
+
+}

sys/ffmpeg61/avcodec_encoding.go

@@ -50,3 +50,15 @@ func AVCodec_receive_packet(ctx *AVCodecContext, pkt *AVPacket) error {
 	}
 	return nil
 }
+
+// Write a packet to an output media file ensuring correct interleaving.
+// This function will buffer the packets internally as needed to make sure the packets in the output file are
+// properly interleaved, usually ordered by increasing dts. Callers doing their own interleaving should
+// call av_write_frame() instead of this function.
+func AVCodec_interleaved_write_frame(ctx *AVFormatContext, pkt *AVPacket) error {
+	if err := AVError(C.av_interleaved_write_frame((*C.AVFormatContext)(ctx), (*C.AVPacket)(pkt))); err != 0 {
+		return err
+	}
+	// Return success
+	return nil
+}

writer.go

@@ -193,45 +193,109 @@ func (w *writer) Decoder(DecoderMapFunc) (Decoder, error) {
 	return nil, ErrOutOfOrder.With("not an input stream")
 }
 
-func (w *writer) Mux(context.Context, MuxFunc) error {
-	return ErrNotImplemented
-
-	/*
-			while (1) {
-		        AVStream *in_stream, *out_stream;
-
-		        ret = av_read_frame(ifmt_ctx, pkt);
-		        if (ret < 0)
-		            break;
-
-		        in_stream  = ifmt_ctx->streams[pkt->stream_index];
-		        if (pkt->stream_index >= stream_mapping_size ||
-		            stream_mapping[pkt->stream_index] < 0) {
-		            av_packet_unref(pkt);
-		            continue;
-		        }
-
-		        pkt->stream_index = stream_mapping[pkt->stream_index];
-		        out_stream = ofmt_ctx->streams[pkt->stream_index];
-		        log_packet(ifmt_ctx, pkt, "in");
-
-		        // copy packet
-		        av_packet_rescale_ts(pkt, in_stream->time_base, out_stream->time_base);
-		        pkt->pos = -1;
-		        log_packet(ofmt_ctx, pkt, "out");
-
-		        ret = av_interleaved_write_frame(ofmt_ctx, pkt);
-		        // pkt is now blank (av_interleaved_write_frame() takes ownership of
-		        // its contents and resets pkt), so that no unreferencing is necessary.
-		        // This would be different if one used av_write_frame().
-		        if (ret < 0) {
-		            fprintf(stderr, "Error muxing packet\n");
-		            break;
-		        }
-		    }
-	*/
+func (w *writer) Mux(ctx context.Context, fn MuxFunc) error {
+	// Check fn
+	if fn == nil {
+		return ErrBadParameter.With("nil mux function")
+	}
+
+	// Create a new map of encoders
+	encoders := make(map[int]*encoder, len(w.encoder))
+	for k, v := range w.encoder {
+		encoders[k] = v
+	}
+
+FOR_LOOP:
+	for {
+		select {
+		case <-ctx.Done():
+			break FOR_LOOP
+		default:
+			// Loop until no more encoders are available to send packets
+			if len(encoders) == 0 {
+				break FOR_LOOP
+			}
+
+			// Find the first encoder which should return a packet
+			next_time := 0
+			next_stream := 0
+			for stream := range encoders {
+				if next_time == 0 || encoder.nextTime() < next_time {
+					next_time = encoder.nextTime()
+					next_stream = stream
+				}
+			}
+
+			// Get a packet from the encoder
+			packet, err := encoders[next_stream].encode(fn)
+			if errors.Is(err, io.EOF) {
+				break FOR_LOOP
+			} else if err != nil {
+				return err
+			} else if packet == nil {
+				// Remove the encoder from the map
+				delete(encoders, next_stream)
+				continue FOR_LOOP
+			}
+
+			// Send the packet to the muxer
+			//av_packet_rescale_ts(pkt, in_stream->time_base, out_stream->time_base);
+			// Packet's stream_index field must be set to the index of the corresponding stream in s->streams.
+			// The timestamps (pts, dts) must be set to correct values in the stream's timebase
+			//  (unless the output format is flagged with the AVFMT_NOTIMESTAMPS flag, then they can be set
+			// to AV_NOPTS_VALUE). The dts for subsequent packets in one stream must be strictly increasing
+			// (unless the output format is flagged with the AVFMT_TS_NONSTRICT, then they merely have to
+			// be nondecreasing). duration should also be set if known.
+			if err := ff.AVCodec_interleaved_write_frame(w.output, packet); err != nil {
+				return err
+			}
+		}
+	}
+
+	// Flush
+	if err := ff.AVCodec_interleaved_write_frame(w.output, nil); err != nil {
+		return err
+	}
+
+	// Return the context error, which will be nil if the loop ended normally
+	return ctx.Err()
 }
 
+/*
+		while (1) {
+	        AVStream *in_stream, *out_stream;
+
+	        ret = av_read_frame(ifmt_ctx, pkt);
+	        if (ret < 0)
+	            break;
+
+	        in_stream  = ifmt_ctx->streams[pkt->stream_index];
+	        if (pkt->stream_index >= stream_mapping_size ||
+	            stream_mapping[pkt->stream_index] < 0) {
+	            av_packet_unref(pkt);
+	            continue;
+	        }
+
+	        pkt->stream_index = stream_mapping[pkt->stream_index];
+	        out_stream = ofmt_ctx->streams[pkt->stream_index];
+	        log_packet(ifmt_ctx, pkt, "in");
+
+	        // copy packet
+	        av_packet_rescale_ts(pkt, in_stream->time_base, out_stream->time_base);
+	        pkt->pos = -1;
+	        log_packet(ofmt_ctx, pkt, "out");
+
+	        ret = av_interleaved_write_frame(ofmt_ctx, pkt);
+	        // pkt is now blank (av_interleaved_write_frame() takes ownership of
+	        // its contents and resets pkt), so that no unreferencing is necessary.
+	        // This would be different if one used av_write_frame().
+	        if (ret < 0) {
+	            fprintf(stderr, "Error muxing packet\n");
+	            break;
+	        }
+	    }
+*/
+
 // Return OUTPUT and combination of DEVICE and STREAM
 func (w *writer) Type() MediaType {
 	return OUTPUT