promising

hack/compare-hash.sh

···
 echo "  meld $(realpath 1.frames) $(realpath 2.frames)"
 echo "Compare frame headers:"
 echo "  meld $(realpath 1.trace_headers) $(realpath 2.trace_headers)"
+echo "Compare hex hashes:"
+echo "  meld $(realpath 1.xxd) $(realpath 2.xxd)"
+echo "Compare framemd5 hashes:"
+echo "  meld $(realpath 1.md5) $(realpath 2.md5)"
 exit 1

pkg/config/config.go

···
 	Replicators                []string
 	WebsocketURL               string
 	BehindHTTPSProxy           bool
+	SegmentDebugDir            string
 }
 
 // ContentFilters represents the content filtering configuration
···
 	fs.BoolVar(&cli.SQLLogging, "sql-logging", false, "enable sql logging")
 	fs.StringVar(&cli.SentryDSN, "sentry-dsn", "", "sentry dsn for error reporting")
 	fs.BoolVar(&cli.LivepeerDebug, "livepeer-debug", false, "log livepeer segments to $SP_DATA_DIR/livepeer-debug")
+	fs.StringVar(&cli.SegmentDebugDir, "segment-debug-dir", "", "directory to log segment validation to")
 	cli.StringSliceFlag(fs, &cli.Tickets, "tickets", []string{}, "tickets to join the swarm with")
 	fs.StringVar(&cli.IrohTopic, "iroh-topic", "", "topic to use for the iroh swarm (must be 32 bytes in hex)")
 	fs.BoolVar(&cli.DisableIrohRelay, "disable-iroh-relay", false, "disable the iroh relay")

pkg/media/clip.go

···
 	defer cancel()
 
 	pipelineSlice := []string{
-		fmt.Sprintf("mp4mux name=muxer faststart=true interleave-bytes=%d interleave-time=%d ! appsink sync=false name=mp4sink", InterleaveBytes, InterleaveTime),
-		"capsfilter caps=video/x-h264,parsed=true name=videoqueue ! queue  ! muxer.",
+		fmt.Sprintf("mp4mux name=muxer faststart=true interleave-bytes=%d interleave-time=%d movie-timescale=60000 trak-timescale=60000 ! appsink sync=false name=mp4sink", InterleaveBytes, InterleaveTime),
+		"capsfilter caps=video/x-h264,parsed=true name=videoqueue ! queue ! muxer.",
 		"opusparse name=audioparse ! queue ! muxer.",
 	}
 
···
 		return fmt.Errorf("failed to get mp4sink element: %w", err)
 	}
 
-	eos := make(chan struct{})
-
 	appSink := app.SinkFromElement(mp4Sink)
 	appSink.SetCallbacks(&app.SinkCallbacks{
 		NewSampleFunc: WriterNewSample(ctx, w),
-		EOSFunc: func(sink *app.Sink) {
-			close(eos)
-		},
 	})
 
 	// Start the pipeline
···
 
 	// Handle bus messages
 	err = HandleBusMessages(ctx, pipeline)
-
-	<-eos
+	if err != nil {
+		return fmt.Errorf("failed to handle bus messages: %w", err)
+	}
 
 	if err != nil {
 		return fmt.Errorf("pipeline error: %w", err)

pkg/media/segmenter.go

···
 	"fmt"
 	"io"
 	"os"
+	"path/filepath"
+	"slices"
 	"strings"
 	"time"
 
 	"github.com/go-gst/go-gst/gst"
 	"github.com/go-gst/go-gst/gst/app"
+	"stream.place/streamplace/pkg/aqtime"
 	"stream.place/streamplace/pkg/log"
 )
 
···
 		if err != nil {
 			panic("error setting interleave-time" + err.Error())
 		}
+		err = muxEle.SetProperty("faststart", true)
+		if err != nil {
+			panic("error setting faststart" + err.Error())
+		}
+		err = muxEle.SetProperty("movie-timescale", uint(60000))
+		if err != nil {
+			panic("error setting movie-timescale" + err.Error())
+		}
+		err = muxEle.SetProperty("trak-timescale", uint(60000))
+		if err != nil {
+			panic("error setting trak-timescale" + err.Error())
+		}
 	})
 	if err != nil {
 		return nil, fmt.Errorf("failed to connect muxer-added handler: %w", err)
···
 				err := cb(ctx, bs, now)
 				if err != nil {
 					log.Error(ctx, "error signing segment", "error", err)
+					elem.ErrorMessage(gst.DomainCore, gst.CoreErrorFailed, "Error signing segment", err.Error())
 					return
 				}
 				close(mySegCh)
···
 	return elem, nil
 }
 
+var MaxSegmentTries = 10
+
 func (mm *MediaManager) SegmentAndSignElem(ctx context.Context, ms MediaSigner) (*gst.Element, error) {
 	return SegmentElem(ctx, func(ctx context.Context, bs []byte, now int64) error {
+		signedBs, err := ms.SignMP4(ctx, bytes.NewReader(bs), now)
+		if err != nil {
+			return fmt.Errorf("error calling SignMP4: %w", err)
+		}
+		previousBs := []byte{}
+		currentBs := signedBs
+		i := 0
+		for i = 0; i <= MaxSegmentTries; i++ {
+			if slices.Compare(previousBs, currentBs) == 0 {
+				break
+			}
+			if mm.cli.SegmentDebugDir != "" {
+				mydir := filepath.Join(mm.cli.SegmentDebugDir, ms.Streamer())
+				err := os.MkdirAll(mydir, 0755)
+				if err != nil {
+					return fmt.Errorf("failed to create debug directory: %w", err)
+				}
+				aqt := aqtime.FromMillis(now)
+				outFile := filepath.Join(mm.cli.SegmentDebugDir, fmt.Sprintf("%s-attempt-%03d.mp4", aqt.FileSafeString(), i))
+				err = os.WriteFile(outFile, currentBs, 0644)
+				if err != nil {
+					return fmt.Errorf("failed to write debug file: %w", err)
+				}
+				log.Log(ctx, "wrote debug file", "path", outFile)
+			}
+			buf := bytes.Buffer{}
+			err := CombineSegmentsUnsigned(ctx, []io.ReadSeeker{bytes.NewReader(currentBs)}, &buf)
+			if err != nil {
+				return fmt.Errorf("failed to attempt segment convergence: %w", err)
+			}
+			previousBs = currentBs
+			currentBs = buf.Bytes()
+		}
+		if slices.Compare(previousBs, currentBs) != 0 {
+			return fmt.Errorf("failed to converge segment after %d tries", MaxSegmentTries)
+		}
+		bs = currentBs
+		log.Log(ctx, "converged segments", "tries", i, "size", len(bs))
 		if mm.cli.SmearAudio {
 			smearedBuf := &bytes.Buffer{}
 			err := SmearAudioTimestamps(ctx, bytes.NewReader(bs), smearedBuf)
···
 			}
 			bs = smearedBuf.Bytes()
 		}
-		signedBs, err := ms.SignMP4(ctx, bytes.NewReader(bs), now)
+		signedBs, err = ms.SignMP4(ctx, bytes.NewReader(bs), now)
 		if err != nil {
-			return err
+			return fmt.Errorf("error calling SignMP4: %w", err)
 		}
-		return mm.ValidateMP4(ctx, bytes.NewReader(signedBs), true)
+		log.Log(ctx, "signed segment", "size", len(signedBs))
+		err = mm.ValidateMP4(ctx, bytes.NewReader(signedBs), true)
+		if err != nil {
+			return fmt.Errorf("error validating just-signed segment: %w", err)
+		}
+		return nil
 	})
 }
 

pkg/media/validate.go

···
 	defer span.End()
 	buf, err := io.ReadAll(input)
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to read input: %w", err)
 	}
 
 	valid, err := ValidateMP4Media(ctx, buf)
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to validate MP4 media: %w", err)
 	}
 	meta := valid.Meta
 	pub := valid.Pub
···
 	if label != nil && mm.model != nil {
 		oldSeg, err := mm.model.GetSegment(*label)
 		if err != nil {
-			return err
+			return fmt.Errorf("failed to get old segment: %w", err)
 		}
 		if oldSeg != nil {
 			log.Warn(ctx, "segment already exists, skipping", "segmentID", *label)
···
 	}
 	err = json.Unmarshal([]byte(maniStr), &maniCert)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to unmarshal manifest and cert: %w", err)
 	}
 	activeManifest := maniCert.ValidationResults.ActiveManifest
-	if activeManifest == nil {
-		return nil, fmt.Errorf("no active manifest found")
-	}
-	if activeManifest.Failure == nil {
-		return nil, fmt.Errorf("active manifest failure array not found?!")
-	}
-	if len(activeManifest.Failure) > 0 {
-		bs, _ := json.Marshal(activeManifest.Failure)
-		return nil, fmt.Errorf("active manifest has failures: %s", string(bs))
+	if activeManifest != nil {
+		if activeManifest.Failure == nil {
+			return nil, fmt.Errorf("active manifest failure array not found?!")
+		}
+		if len(activeManifest.Failure) > 0 {
+			bs, _ := json.Marshal(activeManifest.Failure)
+			return nil, fmt.Errorf("active manifest has failures: %s", string(bs))
+		}
 	}
 	pub, err := signers.ParseES256KCert([]byte(maniCert.Cert))
 	if err != nil {

rust/iroh-streamplace/src/c2pa.rs

···
             "manifest": manifest,
             "cert": cert_chain,
             "validation_results": reader.validation_results(),
+            "validation_state": reader.validation_state(),
         });
 
         return Ok(result.to_string());