transcode_ffmpeg.h

Go to the documentation of this file.

/*
    Copyright (C) 2010 Paul Davis
    Author: 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., 675 Mass Ave, Cambridge, MA 02139, USA.

*/
#ifndef __ardour_transcode_ffmpeg_h__
#define __ardour_transcode_ffmpeg_h__

#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);
                virtual ~TranscodeFfmpeg ();
                bool transcode (std::string, const int outwidth=0, const int outheight=0, const int kbitps =0);
                bool extract_audio (std::string outfile, ARDOUR::framecnt_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);
                FFSettings default_encoder_settings ();
                FFSettings default_meta_data ();
                void cancel();
                bool probe_ok () { return probeok; }
                bool ffexec_ok () { return ffexecok; }

                PBD::Signal2<void, ARDOUR::framecnt_t, ARDOUR::framecnt_t> Progress;
                PBD::Signal0<void> Finished;

                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::framecnt_t get_duration() { return m_duration; }
                std::string  get_codec() { return m_codec; }

                FFAudioStreams get_audio() { return m_audio; }

                void set_duration(ARDOUR::framecnt_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_fps(double fps) { m_fps = fps; } // on export, used for rounding only.

#if 1 /* tentative debug mode */
                void   set_debug (bool onoff) { debug_enable = onoff; }
#endif
        protected:
                std::string infile;
                ARDOUR::SystemExec  *ffcmd;

                bool probe ();

                double m_fps;
                double m_aspect;
                std::string m_sar;
                ARDOUR::framecnt_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;

                char *format_metadata (std::string, std::string);
                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 ffoutput;

                std::string ffmpeg_exe;
                std::string ffprobe_exe;
#if 1 /* tentative debug mode */
                bool debug_enable;
#endif
};

#endif /* __ardour_transcode_ffmpeg_h__ */