Preserve cover art when concatenating audio files

.github/workflows/do_test.yml

@@ -15,5 +15,8 @@ jobs:
           go-version: 1.26.x
           cache: true
 
+      - name: Install ffmpeg
+        run: sudo apt-get update && sudo apt-get install -y ffmpeg
+
       - name: Run tests
         run: make test

media_processor/media_processor.go

@@ -152,22 +152,71 @@
 	return bitrate, nil
 }
 
-func (conv *FFMpegMediaProcessor) ExtractCoverArt(filepath string) (coverArtFilePath string, err error) {
+func (conv *FFMpegMediaProcessor) ExtractCoverArt(ctx context.Context, filepath string) (coverArtFilePath string, err error) {
+	_, span := otel.Tracer("github.com/dir01/mediary/media_processor").Start(ctx, "media_processor.ExtractCoverArt",
+		trace.WithAttributes(attribute.String("filepath", filepath)),
+	)
+	defer span.End()
+
 	errCtx := oops.With("filepath", filepath)
 	coverArtFilePath = filepath + ".jpg"
 	errCtx = errCtx.With("coverArtFilePath", coverArtFilePath)
 
-	cmd := exec.Command("ffmpeg", "-i", filepath, "-map", "0:v", "-map", "-0:V", "-c", "copy", "-y", coverArtFilePath)
+	cmd := exec.CommandContext(ctx, "ffmpeg", "-i", filepath, "-map", "0:v", "-map", "-0:V", "-c", "copy", "-y", coverArtFilePath)
 	errCtx = errCtx.With("cmd", cmd.String())
 
 	out, err := cmd.CombinedOutput()
 	if err != nil {
-		return "", errCtx.With("output", string(out)).Wrapf(err, "failed to run ffmpeg")
+		return "", errCtx.With("output", string(out)).Wrapf(err, "failed to extract cover art")
 	}
 
 	return coverArtFilePath, nil
 }
 
+func (conv *FFMpegMediaProcessor) EmbedCoverArt(ctx context.Context, filepath string, coverArtPath string) error {
+	_, span := otel.Tracer("github.com/dir01/mediary/media_processor").Start(ctx, "media_processor.EmbedCoverArt",
+		trace.WithAttributes(
+			attribute.String("filepath", filepath),
+			attribute.String("cover_art_path", coverArtPath),
+		),
+	)
+	defer span.End()
+
+	errCtx := oops.With("filepath", filepath, "coverArtPath", coverArtPath)
+
+	tag, err := id3v2.Open(filepath, id3v2.Options{Parse: true})
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return errCtx.Wrapf(err, "failed to open file for cover art embedding")
+	}
+	defer func() { _ = tag.Close() }()
+
+	artwork, err := os.ReadFile(coverArtPath)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return errCtx.Wrapf(err, "failed to read cover art file")
+	}
+
+	tag.AddAttachedPicture(id3v2.PictureFrame{
+		Encoding:    id3v2.EncodingUTF8,
+		MimeType:    "image/jpeg",
+		PictureType: id3v2.PTFrontCover,
+		Description: "Cover",
+		Picture:     artwork,
+	})
+
+	if err := tag.Save(); err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return errCtx.Wrapf(err, "failed to save cover art")
+	}
+
+	conv.log.Debug("embedded cover art", slog.String("filepath", filepath), slog.String("coverArtPath", coverArtPath))
+	return nil
+}
+
 func (conv *FFMpegMediaProcessor) GetDuration(filepath string) (time.Duration, error) {
 	cmd := exec.Command(
 		"ffprobe",

service/concatenate_flow.go

@@ -101,6 +101,15 @@ func (svc *Service) newConcatenateFlow(jobID string, job *Job) (func(ctx context
 				fsFilepaths = append(fsFilepaths, filepathsMap[fp])
 			}
 
+			// extract cover art from the first source file before concatenation
+			var coverArtPath string
+			if artPath, artErr := svc.mediaProcessor.ExtractCoverArt(downloadCtx, fsFilepaths[0]); artErr != nil {
+				svc.log.Debug("no cover art found in first file, proceeding without",
+					append(logAttrs, slog.Any("error", artErr))...)
+			} else {
+				coverArtPath = artPath
+			}
+
 			// collect per-file durations for chapter markers
 			var chapters []Chapter
 			var offset time.Duration
@@ -148,6 +157,14 @@ func (svc *Service) newConcatenateFlow(jobID string, job *Job) (func(ctx context
 						append(logAttrs, slog.Any("error", chapErr))...)
 				}
 			}
+
+			// re-embed cover art into the concatenated file
+			if coverArtPath != "" {
+				if embedErr := svc.mediaProcessor.EmbedCoverArt(concatCtx, resultFilepath, coverArtPath); embedErr != nil {
+					svc.log.Warn("failed to embed cover art, proceeding without",
+						append(logAttrs, slog.Any("error", embedErr))...)
+				}
+			}
 		}
 		logAttrs = append(logAttrs, slog.String("localFilename", resultFilepath))
 		errCtx = errCtx.With("localFilename", resultFilepath)

service/concatenate_flow_test.go

@@ -93,6 +93,14 @@ func TestConcatenateFlow_GetInfoErrorSkipsChapters(t *testing.T) {
 		return nil
 	})
 
+	// Cover art extraction may fail (no cover art in source); that's fine.
+	mp.ExtractCoverArtMock.Optional().Set(func(_ context.Context, fp string) (string, error) {
+		return "", errors.New("no cover art")
+	})
+	mp.EmbedCoverArtMock.Optional().Set(func(_ context.Context, fp string, coverArtPath string) error {
+		return nil
+	})
+
 	upl.UploadMock.Set(func(_ context.Context, fp string, url string) error {
 		return nil
 	})
@@ -198,6 +206,20 @@ func TestConcatenateFlow_ChapterTimestamps(t *testing.T) {
 		return nil
 	})
 
+	// Cover art: extract succeeds, embed should be called on the result file.
+	coverArtFile := "/tmp/dl/intro.mp3.jpg"
+	mp.ExtractCoverArtMock.Set(func(_ context.Context, fp string) (string, error) {
+		return coverArtFile, nil
+	})
+	var embedCoverArtCalledWith string
+	mp.EmbedCoverArtMock.Set(func(_ context.Context, fp string, artPath string) error {
+		embedCoverArtCalledWith = fp
+		if artPath != coverArtFile {
+			t.Errorf("EmbedCoverArt called with unexpected art path: %s", artPath)
+		}
+		return nil
+	})
+
 	upl.UploadMock.Set(func(_ context.Context, fp string, url string) error {
 		return nil
 	})
@@ -231,4 +253,9 @@ func TestConcatenateFlow_ChapterTimestamps(t *testing.T) {
 			t.Errorf("chapter %d EndTime: want %v, got %v", i, want.EndTime, got.EndTime)
 		}
 	}
+
+	// Verify cover art was embedded into the concatenated result file.
+	if embedCoverArtCalledWith != resultPath {
+		t.Errorf("EmbedCoverArt should be called on result file %q, got %q", resultPath, embedCoverArtCalledWith)
+	}
 }