transcode_ffmpeg.h

Go to the documentation of this file.

/*
 * Copyright (C) 2013-2018 Robin Gareus <robin@gareus.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
#pragma once
 
#include <string>
 
#include "ardour/system_exec.h"
#include "ardour/types.h"
 
class TranscodeFfmpeg : public sigc::trackable, public PBD::ScopedConnectionList
{
public:
        struct FFAudioStream {
                std::string name;
                std::string stream_id;
                uint32_t    channels;
        };
 
        typedef std::vector<FFAudioStream>         FFAudioStreams;
        typedef std::map<std::string, std::string> FFSettings;
 
        TranscodeFfmpeg (std::string f);
 
        bool transcode (std::string outfile, const int width = 0, const int height = 0, const int kbitps = 0);
 
        bool extract_audio (std::string outfile, ARDOUR::samplecnt_t samplerate, unsigned int stream = 0);
 
        bool encode (std::string outfile, std::string inf_a, std::string inf_v, FFSettings ffs, FFSettings meta, bool map = true);
 
        void cancel ();
 
        FFSettings default_encoder_settings ();
 
        FFSettings default_meta_data ();
 
        bool probe_ok ()
        {
                return probeok;
        }
 
        bool ffexec_ok ()
        {
                return ffexecok;
        }
 
        double get_fps ()
        {
                return m_fps;
        }
 
        double get_aspect ()
        {
                return m_aspect;
        }
 
        int get_width ()
        {
                return m_width;
        }
 
        int get_height ()
        {
                return m_height;
        }
 
        ARDOUR::samplecnt_t get_duration ()
        {
                return m_duration;
        }
 
        std::string get_codec ()
        {
                return m_codec;
        }
 
        FFAudioStreams get_audio ()
        {
                return m_audio;
        }
 
        void set_duration (ARDOUR::samplecnt_t d)
        {
                m_duration = d;
        }
 
        /* offset, lead-in/out are in seconds */
        void set_avoffset (double av_offset)
        {
                m_avoffset = av_offset;
        }
 
        void set_leadinout (double lead_in, double lead_out)
        {
                m_lead_in  = lead_in;
                m_lead_out = lead_out;
        }
 
        void set_debug (bool onoff)
        {
                debug_enable = onoff;
        }
 
        PBD::Signal<void(ARDOUR::samplecnt_t, ARDOUR::samplecnt_t)> Progress;
 
        PBD::Signal<void(int)> Finished;
 
protected:
        bool probe ();
        void ffmpegparse_v (std::string d, size_t s);
        void ffmpegparse_a (std::string d, size_t s);
        void ffprobeparse (std::string d, size_t s);
        void ffexit ();
 
        std::string         infile;
        ARDOUR::SystemExec* ffcmd;
        double              m_fps;
        std::string         m_fps_str;
        double              m_aspect;
        std::string         m_sar;
        ARDOUR::samplecnt_t m_duration;
        int                 m_width;
        int                 m_height;
        std::string         m_codec;
        int                 m_videoidx;
        double              m_avoffset;
        double              m_lead_in;
        double              m_lead_out;
        bool                ffexecok;
        bool                probeok;
        FFAudioStreams      m_audio;
        std::string         ffoutput;
        std::string         ffmpeg_exe;
        std::string         ffprobe_exe;
        bool                debug_enable;
};