How to Record Video of a Dynamic Div Containing Multiple Media Elements in React Konva?

Question

I'm working on a React application where I need to record a video of a specific div with the class name "layout." This div contains multiple media elements (such as images and videos) that are dynamically rendered inside divisions. I've tried several approaches, including using MediaRecorder, canvas-based recording with html2canvas, RecordRTC, and even ffmpeg, but none seem to capture the entire div along with its dynamic content effectively.

What would be the best approach to achieve this? How can I record a video of this dynamically rendered div including all its media elements, ensuring a smooth capture of the transitions?

What I’ve Tried: MediaRecorder API: Didn't work effectively for capturing the entire div and its elements. html2canvas: Captures snapshots but struggles with smooth transitions between media elements. RecordRTC HTML Element Recording: Attempts to capture the canvas, but the output video size is 0 bytes. CanvasRecorder, FFmpeg, and various other libraries also didn't provide the desired result.

import React, { useEffect, useState, useRef } from "react";

const Preview = ({ layout, onClose }) => {
  const [currentContent, setCurrentContent] = useState([]);
  const totalDuration = useRef(0);
  const videoRefs = useRef([]); // Store refs to each video element
  const [totalTime, setTotalTime] = useState(0); // Add this line
  const [elapsedTime, setElapsedTime] = useState(0); // Track elapsed time in seconds

  // video recording variable and state declaration
  //  video recorder end
  // for video record useffect
  // Function to capture the renderDivision content

  const handleDownload = async () => {
    console.log("video downlaod function in developing mode.");
  };

  // end video record useffect

  // to apply motion and swtich in media of division start
  useEffect(() => {
    if (layout && layout.divisions) {
      const content = layout.divisions.map((division) => {
        let divisionDuration = 0;

        division.imageSrcs.forEach((src, index) => {
          const mediaDuration = division.durations[index]
            ? division.durations[index] * 1000 // Convert to milliseconds
            : 5000; // Fallback to 5 seconds if duration is missing
          divisionDuration += mediaDuration;
        });

        return {
          division,
          contentIndex: 0,
          divisionDuration,
        };
      });

      // Find the maximum duration
      const maxDuration = Math.max(...content.map((c) => c.divisionDuration));

      // Filter divisions that have the max duration
      const maxDurationDivisions = content.filter(
        (c) => c.divisionDuration === maxDuration
      );

      // Select the first one if there are multiple with the same max duration
      const selectedMaxDurationDivision = maxDurationDivisions[0];

      totalDuration.current = selectedMaxDurationDivision.divisionDuration; // Update the total duration in milliseconds

      setTotalTime(Math.floor(totalDuration.current / 1000000)); // Convert to seconds and set in state

      // console.log(
      //   "Division with max duration (including ties):",
      //   selectedMaxDurationDivision
      // );

      setCurrentContent(content);
    }
  }, [layout]);

  useEffect(() => {
    if (currentContent.length > 0) {
      const timers = currentContent.map(({ division, contentIndex }, i) => {
        const duration = division.durations[contentIndex]
          ? division.durations[contentIndex] // Duration is already in ms
          : 5000; // Default to 5000ms if no duration is defined

        const mediaElement = videoRefs.current[i];
        if (mediaElement && mediaElement.pause) {
          mediaElement.pause();
        }

        // Set up a timeout for each division to move to the next media after duration
        const timeoutId = setTimeout(() => {
          // Update content for each division independently
          updateContent(i, division, contentIndex, duration); // Move to the next content after duration

          // Ensure proper cleanup
          if (contentIndex + 1 >= division.imageSrcs.length) {
            clearTimeout(timeoutId); // Clear timeout to stop looping
          }
        }, duration);

        // Cleanup timers on component unmount
        return timeoutId;
      });

      // Return cleanup function to clear all timeouts
      return () => timers.forEach((timer) => clearTimeout(timer));
    }
  }, [currentContent]);
  // to apply motion and swtich in media of division end

  // Handle video updates when the duration is changed or a new video starts
  const updateContent = (i, division, contentIndex, duration) => {
    const newContent = [...currentContent];

    // Check if we are on the last media item
    if (contentIndex + 1 < division.imageSrcs.length) {
      // Move to next media if not the last one
      newContent[i].contentIndex = contentIndex + 1;
    } else {
      // If this is the last media item, pause here
      newContent[i].contentIndex = contentIndex; // Keep it at the last item
      setCurrentContent(newContent);

      // Handle video pause if the last media is a video
      const mediaElement = videoRefs.current[i];
      if (mediaElement && mediaElement.tagName === "VIDEO") {
        mediaElement.pause();
        mediaElement.currentTime = mediaElement.duration; // Pause at the end of the video
      }
      return; // Exit the function as we don't want to loop anymore
    }

    // Update state to trigger rendering of the next media
    setCurrentContent(newContent);

    // Handle video playback for the next media item
    const mediaElement = videoRefs.current[i];
    if (mediaElement) {
      mediaElement.pause();
      mediaElement.currentTime = 0;
      mediaElement
        .play()
        .catch((error) => console.error("Error playing video:", error));
    }
  };

  const renderDivision = (division, contentIndex, index) => {
    const mediaSrc = division.imageSrcs[contentIndex];

    if (!division || !division.imageSrcs || division.imageSrcs.length === 0) {
      return (
        
          No media available
        
      );
    }

    if (!mediaSrc) {
      return (
        
          No media available
        
      );
    }

    if (mediaSrc.endsWith(".mp4")) {
      return (

I tried several methods to record the content of the div with the class "layout," which contains dynamic media elements such as images and videos. The approaches I attempted include:

MediaRecorder API: I expected this API to capture the entire div and its contents, but it didn't handle the rendering of all dynamic media elements properly.

html2canvas: I used this to capture the layout as a canvas and then attempted to convert it into a video stream. However, it could not capture smooth transitions between media elements, leading to a choppy or incomplete video output.

RecordRTC: I integrated RecordRTC to capture the canvas stream of the div. Despite setting up the recorder, the resulting video file either had a 0-byte size or only captured parts of the content inconsistently.

FFmpeg and other libraries: I explored these tools hoping they would provide a seamless capture of the dynamic content, but they also failed to capture the full media elements, including videos playing within the layout.

In all cases, I expected to get a complete video recording of the div, including all media transitions, but the results were incomplete or not functional.

Now, I’m seeking an approach or best practice to record the entire div with its dynamic content and media playback.

How to Record Video of a Dynamic Div Containing Multiple Media Elements in React Konva?

Answers (0)

Related Questions