mlt timecode extraction

[joskezelensky]

is it possible to extract the timecodes? i'm struggling with the ai-generated code i have at the moment
i'm working with video that i'm only cutting etc, so it's unnecessary to reencode all of it; is it possible to extract the right info?

const fs = require('fs');
const { parseString } = require('xml2js');

function convertKdenliveToFFmpeg(kdenliveFilePath, outputTextFilePath) {
    console.log('Reading Kdenlive file:', kdenliveFilePath);

    fs.readFile(kdenliveFilePath, 'utf-8', (err, xmlData) => {
        if (err) {
            console.error('Error reading Kdenlive file:', err);
            return;
        }

        console.log('Successfully read the Kdenlive file.');

        parseString(xmlData, (err, result) => {
            if (err) {
                console.error('Error parsing XML:', err);
                return;
            }

            console.log('XML parsed successfully.');

            if (!result.mlt || !result.mlt.playlist) {
                console.error('No playlists found in the XML.');
                return;
            }

            const playlists = result.mlt.playlist.filter(p => p.$.id.startsWith('playlist'));
            if (playlists.length === 0) {
                console.error('No valid playlists found.');
                return;
            }

            const producers = [];
            if (result.mlt.producer) producers.push(...result.mlt.producer);
            if (result.mlt.chain) producers.push(...result.mlt.chain);

            const ffmpegCommands = [];

            playlists.forEach((playlist, playlistIndex) => {
                if (!playlist.entry) {
                    console.warn(`No entries found in playlist with id "${playlist.$.id}".`);
                }

                playlist.entry.forEach((entry, entryIndex) => {
                    const producerId = entry.$.producer;

                    const producer = producers.find(p => p.$.id === producerId);

                    if (producer) {
                        const resourceProperty = producer.property.find(p => p.$.name === 'resource');
                        let mediaFile = resourceProperty ? resourceProperty._ : null;

                        if (mediaFile) {
                            if (mediaFile.includes(':')) {
                                const colonIndex = mediaFile.indexOf(':');
                                const potentialNumber = mediaFile.substring(0, colonIndex);
                                if (!isNaN(parseFloat(potentialNumber))) {
                                    mediaFile = mediaFile.substring(colonIndex + 1);
                                }
                            }

                            console.log(`Processing entry with producerId: ${producerId}, in: ${inPoint}, out: ${outPoint}, mediaFile: ${mediaFile}`);

                            const fps = getFps(producer);

                            let startTime = parseTime(inPoint, fps);
                            let endTime = parseTime(outPoint, fps);


                            let command = `ffmpeg -i "${mediaFile}" -c copy`;
                            if (startTime) {
                                command += ` -ss ${startTime}`;
                            }
                            if (endTime) {
                                command += ` -to ${endTime}`;
                            }
                            command += ` "${outputFileName}"`;

                            ffmpegCommands.push(command);
                        } else {
                            console.warn(`Media file not found for producer with id "${producerId}".`);
                        }
                    } else {
                        console.warn(`Producer with id "${producerId}" not found.`);
                    }
                });
            });

            console.log('FFmpeg commands created:', ffmpegCommands);

            fs.writeFile(outputTextFilePath, ffmpegCommands.join('\n'), (err) => {
                if (err) {
                    console.error('Error writing text file:', err);
                } else {
                    console.log('Successfully wrote FFmpeg commands to file:', outputTextFilePath);
                }
            });
        });
    });
}

function parseTime(timeStr, fps) {
    if (!timeStr) {
        return null;
    }
    if (timeStr.includes(':')) {
        return timeStr;
    } else {
        const frames = parseInt(timeStr);
        if (isNaN(frames)) {
            return null;
        } else {
            return formatTime(frames, fps);
        }
    }
}

function formatTime(timeInFrames, fps = 25) {
    const totalSeconds = timeInFrames / fps;
    const hours = Math.floor(totalSeconds / 3600).toString().padStart(2, '0');
    const minutes = Math.floor((totalSeconds % 3600) / 60).toString().padStart(2, '0');
    const seconds = Math.floor(totalSeconds % 60).toString().padStart(2, '0');
    const milliseconds = Math.floor((totalSeconds % 1) * 1000).toString().padStart(3, '0');
    const formattedTime = `${hours}:${minutes}:${seconds}.${milliseconds}`;
    return formattedTime;
}

function getFps(producer) {
    const frameRateNumProperty = producer.property.find(p => p.$.name === 'meta.media.frame_rate_num');
    const frameRateDenProperty = producer.property.find(p => p.$.name === 'meta.media.frame_rate_den');

    if (frameRateNumProperty && frameRateDenProperty) {
        const num = parseFloat(frameRateNumProperty._);
        const den = parseFloat(frameRateDenProperty._);
        if (!isNaN(num) && !isNaN(den) && den !== 0) {
            return num / den;
        }
    }

    return 25;
}

const [, , kdenliveFile, outputTextFile] = process.argv;
convertKdenliveToFFmpeg(kdenliveFile, outputTextFile);