FrameMapper.h

Go to the documentation of this file.

 
// Copyright (c) 2008-2019 OpenShot Studios, LLC
//
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#ifndef OPENSHOT_FRAMEMAPPER_H
#define OPENSHOT_FRAMEMAPPER_H
 
#include <assert.h>
#include <iostream>
#include <vector>
#include <memory>
 
#include "AudioResampler.h"
#include "CacheMemory.h"
#include "ReaderBase.h"
#include "Frame.h"
#include "Fraction.h"
#include "KeyFrame.h"
 
 
// Include FFmpeg headers and macros
#include "FFmpegUtilities.h"
#include "OpenMPUtilities.h"
 
 
namespace openshot
{
    enum PulldownType
    {
        PULLDOWN_CLASSIC,   
        PULLDOWN_ADVANCED,  
        PULLDOWN_NONE,      
    };

    struct Field
    {
        int64_t Frame;
        bool isOdd;
    };

    struct SampleRange
    {
        int64_t frame_start;
        int sample_start;
 
        int64_t frame_end;
        int sample_end;

        void Extend(int64_t samples, openshot::Fraction fps, int sample_rate, int channels, bool right_side) {
            int remaining_samples = samples;
            while (remaining_samples > 0) {
                if (right_side) {
                    // Extend range to the right
                    int samples_per_frame = Frame::GetSamplesPerFrame(frame_end, fps, sample_rate, channels);
                    if (remaining_samples + sample_end < samples_per_frame) {
                        sample_end += remaining_samples;
                        remaining_samples = 0;
                    } else {
                        frame_end++;
                        remaining_samples -= (samples_per_frame - sample_end);
                        sample_end = 0;
                    }
                } else {
                    // Extend range to the left
                    if (sample_start - remaining_samples >= 0) {
                        sample_start -= remaining_samples;
                        remaining_samples = 0;
                    } else {
                        frame_start--;
                        remaining_samples -= (sample_start + 1);
                        sample_start = Frame::GetSamplesPerFrame(frame_start, fps, sample_rate, channels) - 1;
                    }
                }
            }
 
            // Increase total
            total += samples;
        }

        void Shrink(int64_t samples, openshot::Fraction fps, int sample_rate, int channels, bool right_side) {
            int remaining_samples = samples;
            while (remaining_samples > 0) {
                if (right_side) {
                    // Shrink range on the right
                    if (sample_end - remaining_samples >= 0) {
                        sample_end -= remaining_samples;
                        remaining_samples = 0;
                    } else {
                        frame_end--;
                        int samples_per_frame = Frame::GetSamplesPerFrame(frame_end, fps, sample_rate, channels);
                        remaining_samples -= (sample_end + 1);
                        sample_end = samples_per_frame - 1;
                    }
                } else {
                    // Shrink range on the left
                    int samples_per_frame = Frame::GetSamplesPerFrame(frame_start, fps, sample_rate, channels);
                    if (sample_start + remaining_samples < samples_per_frame) {
                        sample_start += remaining_samples;
                        remaining_samples = 0;
                    } else {
                        frame_start++;
                        remaining_samples -= (samples_per_frame - sample_start);
                        sample_start = 0;
                    }
                }
            }
 
            // Reduce total
            total -= samples;
        }
 
        void Shift(int64_t samples, openshot::Fraction fps, int sample_rate, int channels, bool right_side) {
            // Extend each side of the range (to SHIFT the range) by adding (or subtracting) from both sides
            // For example:   [ range    ]
            // For example:    [    range    ]
            if (right_side) {
                // SHIFT both sides to the right
                Extend(samples, fps, sample_rate, channels, true);
                Shrink(samples, fps, sample_rate, channels, false);
            } else {
                // SHIFT both sides to the left
                Extend(samples, fps, sample_rate, channels, false);
                Shrink(samples, fps, sample_rate, channels, true);
            }
        }
 
        int total;
    };

    struct MappedFrame
    {
        Field Odd;
        Field Even;
        SampleRange Samples;
    };
 

    class FrameMapper : public ReaderBase {
    private:
        bool field_toggle;      // Internal odd / even toggle (used when building the mapping)
        Fraction original;      // The original frame rate
        Fraction target;        // The target frame rate
        PulldownType pulldown;  // The pull-down technique
        ReaderBase *reader;     // The source video reader
        CacheMemory final_cache;        // Cache of actual Frame objects
        bool is_dirty;          // When this is true, the next call to GetFrame will re-init the mapping
        float parent_position;  // Position of parent clip (which is used to generate the audio mapping)
        float parent_start;     // Start of parent clip (which is used to generate the audio mapping)
        int64_t previous_frame; // Used during resampling, to determine when a large gap is detected
        SWRCONTEXT *avr;    // Audio resampling context object
 
        // Time curve / direction
        std::recursive_mutex directionMutex;
        bool have_hint = false;
        bool hint_increasing = true;
        bool last_is_increasing = true;
        bool last_dir_initialized = false;
 
        // Audio resampler (if resampling audio)
        openshot::AudioResampler *resampler;
 
        // Internal methods used by init
        void AddField(int64_t frame);
        void AddField(int64_t frame, bool isOdd);
        void AddField(Field field);
 
        // Clear both the fields & frames lists
        void Clear();
 
        // Get Frame or Generate Blank Frame
        std::shared_ptr<Frame> GetOrCreateFrame(int64_t number);

        int64_t AdjustFrameNumber(int64_t clip_frame_number);
 
        // Use the original and target frame rates and a pull-down technique to create
        // a mapping between the original fields and frames or a video to a new frame rate.
        // This might repeat or skip fields and frames of the original video, depending on
        // whether the frame rate is increasing or decreasing.
        void Init();
 
    public:
        // Init some containers
        std::vector<Field> fields;      // List of all fields
        std::vector<MappedFrame> frames;    // List of all frames

        FrameMapper(ReaderBase *reader, Fraction target_fps, PulldownType target_pulldown, int target_sample_rate, int target_channels, ChannelLayout target_channel_layout);

        virtual ~FrameMapper();

        void ChangeMapping(Fraction target_fps, PulldownType pulldown,  int target_sample_rate, int target_channels, ChannelLayout target_channel_layout);

        void Close() override;

        MappedFrame GetMappedFrame(int64_t TargetFrameNumber);

        CacheMemory* GetCache() override { return &final_cache; };

        std::shared_ptr<Frame> GetFrame(int64_t requested_frame) override;

        bool IsOpen() override;

        std::string Name() override { return "FrameMapper"; };
 
        // Get and Set JSON methods
        std::string Json() const override; 
        void SetJson(const std::string value) override; 
        Json::Value JsonValue() const override; 
        void SetJsonValue(const Json::Value root) override; 

        void Open() override;

        void SetDirectionHint(const bool increasing);

        void PrintMapping(std::ostream* out=&std::cout);

        ReaderBase* Reader();

        void Reader(ReaderBase *new_reader) { reader = new_reader; }

        void ResampleMappedAudio(std::shared_ptr<Frame> frame, int64_t original_frame_number);
    };
}
 
#endif