Byzanz is a desktop recorder and command line tool allowing you to record your current desktop or parts of it to an animated GIF, Ogg Theora, Flash or WebM. This is especially useful for publishing on the web.

Byzanz also allows recording of audio, when the output format supports it.

sudo add-apt-repository ppa:fossfreedom/byzanz
sudo apt-get update && sudo apt-get install byzanz

sudo apt-get install byzanz

byzanz-record --duration=10 --x=100 --y=200 --width=700 --height=400 out.gif

全书要义可以概括为两条基本原则：一、个人的行为只要不涉及他人的利害，个人就有完全的行动自由，不必向社会负责；他人对于这个人的行为不得干涉，至多可以进行忠告、规劝或避而不理。二、只有当个人的行为危害到他人利益时，个人才应当接受社会的或法律的惩罚。社会只有在这个时候，才对个人的行为有裁判权，也才能对个人施加强制力量。  摘录自豆瓣

#include <boost/smart_ptr.hpp>
using namespace boost;

void test()
{
    int* p = new int(3);
    ...
    delete p;
}

scoped_ptr<T> ptr_t(new T); // 假设内置指针为p_t

// scoped_ptr usage
scoped_ptr<string> sp(new string("text"));
cout << *sp << endl;
cout << sp->size() << endl;

// pointer 管理权移交 scoped_ptr
auto_ptr<int> ap(new int(10));
scoped_ptr<int> scoped(ap);
assert(ap.get() == 0);

ap.reset(new int(20));
cout << *ap << ", " << *scoped << endl;

auto_ptr<int> ap2;
ap2 = ap;
assert(ap.get() == 0);			// ap is null-pointer

#include <iostream>
#include <boost/smart_ptr.hpp>

class SmallClass
{
    public:
        SmallClass(int x_val)
        {
            x = x_val;
            std::cout << "SmallClass construct " << x << std::endl;
        }

        virtual ~SmallClass()
        {
            std::cout << "SmallClass destory " << x << std::endl;
        }

        int GetX()
        {
            return x;
        }

    private:
        int x;
};

int main()
{
    std::cout << "main start" << std::endl;

    // scoped_ptr on basic
    boost::scoped_ptr<int> int_ptr(new int);
    *int_ptr = 100;
    ++*int_ptr;
    std::cout << *int_ptr << std::endl;

    // scoped_ptr on class
    boost::scoped_ptr<SmallClass> sc_ptr(new SmallClass(0));
    std::cout << sc_ptr->GetX() << std::endl;
    sc_ptr.reset();
    std::cout << "main end" << std::endl;

    return 0;
}

#include <iostream>
#include <string>
#include <vector>
#include <boost/smart_ptr.hpp>

using namespace std;
using namespace boost;

int main(int argc, const char * argv[]) {

    scoped_array<int> scopedarr(new int[100]);
    scopedarr[0] = 100;           // 赋值
//    *(scopedarr+1) = 200;       // error

	// fill array with 100 value 2
    fill_n(&scopedarr[0], 100, 2);
    cout << scopedarr[2] << endl;

    scopedarr[3] = scopedarr[0]+scopedarr[1];
    cout << scopedarr[3] << endl;

    cout << scopedarr.get()[3] << endl;

    return 0;
}

#include <iostream>
#include <string>
#include <vector>
#include <random>
#include <boost/smart_ptr.hpp>
#include <boost/make_shared.hpp>

using namespace boost;

void print_count_func(shared_ptr<int> p){
    std::cout << "cout: " << p.use_count() << " value= " << *p << std::endl;
}

class shared {
private:
    shared_ptr<int> p;

public:
    shared(shared_ptr<int> _p):p(_p) {}
    void print(){
        std::cout << "cout: " << p.use_count() << " value= " << *p << std::endl;
    }
};

int main(int argc, const char * argv[]) {

    // 构造函数
    // 无参数构造空指针 shared_ptr
    shared_ptr<int> p0;

    // shared_ptr(Y * p) 获得指向类型 T 的指针 p 的管理权
    shared_ptr<int> p1(new int);
    *p1 = 12;

    // shared_ptr(shared_ptr const & r) 从另外 shared_ptr 获取管理权，两个 shared_ptr 同时共享一个指针管理权
    shared_ptr<int> p2(p1);                 // p1 引用计数加1
    std::cout << "p1 count: " << p1.use_count() << " value: " << *p2 << std::endl;
    *p2 = 13;
    std::cout << "p1 count: " << p1.use_count() << " value: " << *p2 << std::endl;
    p2.reset();
    std::cout << "p1 count: " << p1.use_count() << std::endl;


    // shared_ptr(std::auto_ptr<Y> & r) 从 auto_ptr 获得指针管理权， 同时 auto_ptr 失去管理权
    std::auto_ptr<int> p;
    shared_ptr<int> p3(p);

    // operator= 赋值操作符，从另外一个 shared_ptr 或 auto_ptr 获得指针管理权，等同于构造函数
    shared_ptr<int> p4 = p1;

    // shared_ptr(Y * p, D d) 类似于 shared_ptr(Y * p)
    // 第一个参数是要被管理的指针，第二个删除参数 d 告诉 shared_ptr 在析构时不使用 delete 来操作指针 p，而使用 d 来操作，把 delete p 换成 d(p)


    // usage
    shared_ptr<int> sp(new int(100));
    print_count_func(sp);
    shared shared1(sp), shared2(sp);

    shared1.print();
    shared2.print();

    *sp = 200;

    print_count_func(sp);
    shared1.print();

    // make_shared
    // include <boost/make_shared.hpp>

    shared_ptr<std::string> strp = make_shared<std::string>("make_test");
    shared_ptr<std::vector<int> > vecp = make_shared< std::vector<int> >(10, 3);

    std::cout << *strp << " " << vecp->size() << std::endl;

    // shared_ptr in vector
    // 因为 shared_ptr 实现了拷贝构造、=赋值构造等函数，因此可以完美的放入STL容器中。
    typedef std::vector< shared_ptr<int> > vs;
    vs v(10);

    int i = 0;
    for (vs::iterator pos = v.begin(); pos != v.end(); ++pos) {
        *pos = make_shared<int>(++i);
        std::cout << *(*pos) << ", ";
    }
    std::cout << std::endl;

    shared_ptr<int> ptest = v[9];
    *ptest = 100;
    std::cout << *v[9] << std::endl;


    return 0;
}

#include <iostream>
#include <string>
#include <vector>
#include <random>
#include <boost/smart_ptr.hpp>
#include <boost/make_shared.hpp>

using namespace boost;

class ClassOne
{
public:
    ClassOne(int data_param):data(NULL)
    {
        init(data_param);
        std::cout << "construct" << std::endl;
    }

    virtual ~ClassOne()
    {
        if(data)
        {
            delete data;
        }
        data = NULL;
    }

    void init(int data_param)
    {
        if(data)
        {
            delete data;
        }
        data = new int(data_param);
    }

private:
    int* data;
};

int main(int argc, const char * argv[]) {
    ClassOne c1(10);
    ClassOne c2(c1);
    ClassOne c3 = c2;

    return 0;
}

#include <iostream>
#include <string>
#include <vector>
#include <random>
#include <boost/smart_ptr.hpp>
#include <boost/make_shared.hpp>

using namespace boost;

class ClassOne
{
public:
    ClassOne():data(NULL) {}
    ClassOne(int data_param):data(NULL)
    {
        init(data_param);
        std::cout << "construct" << std::endl;
    }

    virtual ~ClassOne()
    {
        if (data) {
            delete data;
        }
        data = NULL;
    }

    ClassOne(const ClassOne& rhs){
        std::cout<< "copy " <<std::endl;
        data = NULL;
        init(*rhs.data);
    }

    ClassOne& operator = (const ClassOne& rhs){
        std::cout<< "assign " <<std::endl;
        delete data;               // delete your own old data
        data = new int(*rhs.data); // clone the rhs's data
        return *this;
    }

    void init(int data_param)
    {
        delete data;
        data = new int(data_param);
    }

private:
    int* data;
};

int main(int argc, const char * argv[]) {
    ClassOne c1(10);
    ClassOne c2(c1);       // 实际调用的是B(A)拷贝操作 call copy constructor
    ClassOne c3;
    c3 = c1;               // 申明之后进行赋值运算 call assignment function
    return 0;
}

#include <iostream>
#include <string>
#include <vector>
#include <random>
#include <boost/smart_ptr.hpp>
#include <boost/make_shared.hpp>

using namespace boost;

class ClassOne
{
public:
    ClassOne(int data_param):ptr_data(new int)
    {
        init(data_param);
        std::cout << "construct" << std::endl;
    }

    virtual ~ClassOne()
    {

    }

    int get_data() const{
        return *ptr_data;
    }

    long ptr_count() const {
        return ptr_data.use_count();
    }

    void init(int data_param)
    {
        *ptr_data = data_param;
    }

private:
    shared_ptr<int> ptr_data;
};

int main(int argc, const char * argv[]) {
    ClassOne c1(10);
    ClassOne c2(c1);
    ClassOne c3 = c2;

    std::cout << c1.ptr_count() << std::endl;
    std::cout << c2.get_data() << std::endl;

    return 0;
}

#include <string>
#include <iostream>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>

class parent;
class children;

typedef boost::shared_ptr<parent> parent_ptr;
typedef boost::shared_ptr<children> children_ptr;

class parent
{
public:
    ~parent() { std::cout <<"destroying parent\n"; }

public:
    children_ptr children;
};

class children
{
public:
    ~children() { std::cout <<"destroying children\n"; }

public:
    parent_ptr parent;
};

void test()
{
    parent_ptr father(new parent());
    children_ptr son(new children);

    father->children = son;
    son->parent = father;
}

void main()
{
    std::cout<<"begin test...\n";
    test();
    std::cout<<"end test.\n";
}

class children
{
public:
    ~children() { std::cout <<"destroying children\n"; }

public:
    boost::weak_ptr<parent> parent;
};

#include <boost/smart_ptr.hpp>
#include <iostream>

int main()
{
    boost::shared_ptr<int> ptr(new int(10));
    std::cout << ptr.use_count() << std::endl;
    boost::weak_ptr<int> ptr_weak(ptr);
    std::cout << ptr.use_count() << std::endl;
    std::cout << ptr_weak.expired() << std::endl;
    return 0;
}

date d1;					// 无效日期
date d2(2010,1,1);
date d3(2000, Jan, 1);
date d4(d2);				// 拷贝构造

//you can compare between d1 d2 d3 d4 with == < >

date d0 = from_string("1999-12-31");
date d5 ( from_string("2005/1/1") );
date d6 = from_undelimited_string("20001109");

// local date and UTC date
cout << day_clock::local_day() << endl;
cout << day_clock::universal_day() << endl;

date neg(neg_infin);			//negative infinite time
date pos(pos_infin);			//positive infinite time
date notdate(not_a_date_time);	//not a date time
date maxdate(max_date_time);	//max date
date mindate(min_date_time); 	//min date
cout << neg << endl << pos << endl << maxdate << endl << mindate <<endl;

date nowdate = day_clock::local_day();
date::ymd_type ymd = nowdate.year_month_day();
cout << ymd.year << endl << ymd.month << endl << ymd.day << endl;

// day_of_week() return Monday, Tuesday..
// day_of_year() return number of the day in this year, max 366
// end_of_month() return the date of end of month
cout << nowdate.day_of_week() << endl;
cout << nowdate.day_of_year() << endl;
cout << nowdate.end_of_month() << endl;

date now = day_clock::local_day();
// date output
cout << to_simple_string(now) << endl;			//YYYY-mmm-DD  mmm English
cout << to_iso_string(now) << endl;				//YYYYMMDD
cout << to_iso_extended_string(now) << endl;		//YYYY-MM-DD
cout << now << endl;

date inputdate;
cout << "Input a date: ";						// 2010-Jan-01
cin >> inputdate;								//default using YYYY-mmm-DD English abbr
cout << "\nThe input date is: " << inputdate << endl;

days dd1(10);			// ten days
weeks w(2);				// two weeks
months m(5);			// five months
years y(2);				// two years

months m2 = y + m;		// two years and 5 months

// date compute
date dstart(2000,1,1), dend(2008,8,8);
cout << dend - dstart << endl;			// 3142 days

dstart += days(10);						// 2000-1-11
dstart += months(2);					// 2000-3-11
dstart -= weeks(1);						// 2000-3-4
dstart += years(4);						// 2004-3-4

//something need to be noticed
date endofmonth(2010, 3, 30);
endofmonth -= months(1);				//2010-2-28
endofmonth -= months(1);				//2010-1-31
endofmonth += months(2); 				//2010-3-31

// date period
date_period pd(dstart, dend);			// (date, date)
date_period pd1(dstart, days(10));		// (date, days)

cout << pd << endl;

pd.shift(days(10));						// shift days 平移N天，长度不变
cout << pd << endl;
pd.expand(days(3));						// expand days 像两端扩展三天，长度加2n天
cout << pd << endl;

date date2014 = from_string("2014-01-01");
date nowdate = day_clock::local_day();
date_period pdl(date2014, nowdate);
date one_day_in_2015 = from_undelimited_string("20150101");
cout << pdl.contains(one_day_in_2015) << endl;

/*
 * date_period
 * is_before(), is_after()
 * contains()
 * intersects()				区间是否存在交集
 * intersections()			返回两个区间的交集
 * is_adjacent()			是否相邻
 * merge()					返回两个区间并集，如果无交集或者不相邻则返回无效区间
 * span()					合并两区间及两者间的间隔
 */

/*
 * date iterator
 * use only ++iterator, --iterator, don't use iterator++, iterator--
 */
date d(2006,11,26);
day_iterator d_iter(d);
++d_iter;

year_iterator y_iter(d,3);		// 增减步长为3年
++y_iter;						// 增加3年
cout << y_iter->year();

void print_one_month(){
	date nowdate = day_clock::local_day();
	date month_start(nowdate.year(), nowdate.month(), 1);
	date month_end = nowdate.end_of_month();

	for(day_iterator d_iter(month_start); d_iter != month_end; ++d_iter){
		cout << *d_iter << " " << d_iter->day_of_week() << "\t";
		if(d_iter->day_of_week() == boost::date_time::Sunday){
			cout << endl;
		}
	}
}
/*
 * input your birthday and years after that output the day of
 * future birthday
 */
void birthday_week(){
	date birthday(1992, 06, 05);
	years y30(30);
	date future_birthday = birthday + y30;
	cout << future_birthday.day_of_week() << endl;
}
/*
 * printout the days passed since you were born.
 */
void days_passed(){
	date birthday(1990, 10, 8);
	date nowdate = day_clock::local_day();
	cout << "Since you were born, there were " << nowdate - birthday << " days passed!"<< endl;
}

#include <boost/date_time/posix_time/posix_time.hpp>
using namespace boost::posix_time;

// 2 h 01 m 06.001 s
time_duration td(1, 60, 60, 1000*1000*6 + 1000);

hours h(1);				// one hour
minutes m(10);
seconds s(30);
millisec ms(1);

time_duration td1 = h + m + s + ms;

time_duration td2 = duration_from_string("1:10:30:001");
cout << td2 << endl;			// 01:10:30.001000
cout << to_simple_string(td1) << endl;
cout << to_iso_string(td2) << endl;

using namespace boost::gregorian;

ptime p(date(2010,3,5), hours(1));
ptime p1 = time_from_string("2012-09-11 09:09:09");
cout << p1 << endl;
ptime p2 = from_iso_string("20100909T011001");
cout << p2 << endl;

ptime nowtime = second_clock::local_time();			// second accurate
ptime nowtime2 = microsec_clock::universal_time();	// milli second accurate

ptime pnot(not_a_date_time);
ptime pinf(pos_infin);

cout << to_simple_string(nowtime) << endl;
cout << to_iso_string(nowtime) << endl;
cout << to_iso_extended_string(nowtime) << endl;

time_period tp1(nowtime, hours(8));					// start from nowtime, last for eight hours
tp1.shift(hours(2));
tp1.expand(hours(1));

ptime p(day_clock::local_day(),hours(10));
for (time_iterator t_iter(p, minutes(10)); t_iter < p+hours(1); ++ t_iter) {
    cout << *t_iter << endl;
}

#include <boost/timer.hpp>
using namespace boost;

/**
	 * timer simple and useful, suitable for short time task.
	 * Do not use it to calculate time for long time.
	 * For long time calculate check date_time lib
	 */
using boost::timer;
timer t;															// declare timer start counting
cout << "max timespan:" << t.elapsed_max() / 3600 << "h" << endl;
cout << "min timespan:" << t.elapsed_min() << "s" << endl;
cout << "now time elapsed:" << t.elapsed() << "s" << endl;

class timer
{
 public:
         timer() { _start_time = std::clock(); } // postcondition: elapsed()==0
//         timer( const timer& src );      // post: elapsed()==src.elapsed()
//        ~timer(){}
//  timer& operator=( const timer& src );  // post: elapsed()==src.elapsed()
  void   restart() { _start_time = std::clock(); } // post: elapsed()==0
  double elapsed() const                  // return elapsed time in seconds
    { return  double(std::clock() - _start_time) / CLOCKS_PER_SEC; }

  double elapsed_max() const   // return estimated maximum value for elapsed()
  // Portability warning: elapsed_max() may return too high a value on systems
  // where std::clock_t overflows or resets at surprising values.
  {
    return (double((std::numeric_limits<std::clock_t>::max)())
       - double(_start_time)) / double(CLOCKS_PER_SEC); 
  }

  double elapsed_min() const            // return minimum value for elapsed()
   { return double(1)/double(CLOCKS_PER_SEC); }

 private:
  std::clock_t _start_time;
}; // timer

#include <boost/progress.hpp>
using namespace boost;

progress_timer t;
// do some work
cout << t.elapsed() << endl;	//print out elapsed time for the task

#include <boost/progress.hpp>
using namespace boost;

vector<string> v(100);
ofstream fs("test.txt");
progress_display pd(v.size());					// 构造函数，传入进度总数

vector<string>::iterator pos;
for (pos = v.begin(); pos != v.end(); ++pos){	// 遍历迭代，处理字符串，写文件
    fs << *pos << endl;
    ++pd;										// 更新进度
}

bitrate = 20.8M bit/60s = 20.8 * 1024 * 1024 * 8 bit/60s = 2831 Kbps

2831 Kbps - 128 Kbps = 2703 Kbps

apt-get install ffmpeg

ffmpeg -i input.avi

ffmpeg -i input.mp4 frames/frame%03d.png

ffmpeg -i frames/frame%3d.png output.mp4

ffmpeg -i input.mp4 -f mp3 output.mp3
# or
ffmpeg -i input.mp4 -vn output.mp3
# or
ffmpeg -i input.mp4 -vn -ar 44100 -ac 2 -ab 320 -f mp3 output.mp3

ffmpeg -i input_music.mp3 -i input_video.mp4 output.mp4

ffmpeg -i input.mp4 output.avi

ffmpeg -i input.flv -vcodec copy -acodec copy out.mp4

ffmpeg -y -i input_video.mp4 -bitexact -vcodec h263 -b 128 -r 15 -s 176x144 -acodec aac -ac 2 -ar 22500 -ab 24 -f 3gp test.3gp

ffmpeg -y -i test.wmv -ac 1 -acodec libamr_nb -ar 8000 -ab 12200 -s 176x144 -b 128 -r 15 test.3gp

ffmpeg -i input.mp4 -ss 00:01:45 -t 10 output.mp4

ffmpeg -i input.mp4 -vf “setpts=0.5*PTS” output.mp4

ffmpeg -i input.mp4 -vf “setpts=2.0*PTS” output.mp4

ffmpeg -i input_video.mp4 -y -f image2 -t 0.001 -ss 10 -s 1920x1080 output.jpg

ffmpeg -i input_video.mp4 -ss 00:00:06.000 -vframes 1 output.png

ffmpeg -i input_video.mp4 -vframes 30 -y -f gif output.gif

ffmpeg -ss 00:00:00.000 -i input.mp4 -pix_fmt rgb24 -r 10 -s 320x240 -t 00:00:10.000 output.gif

 convert -layers Optimize output.gif output_optimized.gif

ffmpeg -i bg.mp3 -i frame.%3d.jpg -s hd720 -vcodec mpeg4 output.avi

ffmpeg -i input.mp4 -b:v 2000k output.mp4

ffmpeg -i input.mp4 -b:v 2000k -bufsize 2000k output.mp4

ffmpeg -i input.mp4 -b:v 2000k -bufsize 2000k -maxrate 2500k output.mp4

 ffmpeg -i input.mp4 -vcodec h264 -acodec mp3 output.mp4

ffmpeg -i input.mp4 -filter:v scale=1280:720 -c:a copy output.mp4
# or
ffmpeg -i input.mp4 -s 1280x720 -c:a copy output.mp4

ffmpeg -i input.mp4 -filter:v "crop=w:h:x:y" output.mp4

ffmpeg -i input.mp4 -aspect 16:9 output.mp4

ffmpeg -loop 1 -i input_image.jpg -i input_audio.mp3 -c:v libx264 -c:a aac -strict experimental -b:a 192k -shortest output.mp4

ffmpeg -formats | less

 ffmpeg -i input.avi -b:v 64k -bufsize 64k output.avi

 ffmpeg -i input.avi -r 24 output.avi

 ffmpeg -r 1 -i input.mp4 -r 24 output.avi

mkdir frames
ffmpeg -i input.mp4 -r 10 frames/frame%03d.png
convert -delay 5 -loop 0 frames/frame*.png output.gif

ffmpeg -i input.mp4 -i picture.png -filter_complex overlay="(main_w/2)-(overlay_w/2):(main_h/2)-(overlay_h)/2" output.mp4

ffmpeg [global_options] {[input_file_options] -i input_file} ... {[output_file_options] output_file} ...

-L license 显示协议
-h 帮助
-formats 显示可用的格式，编解码的，协议的
-decoders 可用解码器
-encoders 可用编码器

-i 	filename 输入文件
-y 	覆盖输出文件
-n 	不覆盖输出文件，如果输出文件存在则退出
-t 	duration (input/output)
    设置纪录时间 hh:mm:ss[.xxx] 格式的记录时间也支持，在 `-i` 之前使用，则对输入文件限制记录时间；如果对输出文件使用，则是限制输出文件的时长。

-ss position
    搜索到指定的时间 [-]hh:mm:ss[.xxx] 的格式也支持 ，更多[参考](https://ffmpeg.org/ffmpeg-utils.html#time-duration-syntax)

-title string 设置标题
-author string 设置作者
-copyright string 设置版权
-comment string 设置评论
-f fmt 强迫采用格式 fmt 输出

-c[:stream_specifier] codec (input/output, per-stream)
-codec[:stream_specifier] codec (input/output, per-stream)
    给输入文件指定解码器，给输出文件指定编码器， codec 为编码器名字，如果 codec 值为 `copy` 则默认为和原视频一致。

-vcodec codec
    vcodec 是 -codec:v 的一个别称，强制使用 codec 编解码方式，未设定时使用与输入流相同的编码器。如果用 copy 表示原始编解码数据必须被拷贝。

-target type 设置目标文件类型 (vcd,svcd,dvd) 所有的格式选项（比特率，编解码以及缓冲区大小）自动设置，只需要输入如下的就可以了：

    ffmpeg -i input.avi -target vcd /tmp/vcd.mpg

-hq 激活高质量设置
-itsoffset offset 设置以秒为基准的时间偏移，该选项影响所有后面的输入文件。该偏移被加到输入文件的时戳，定义一个正偏移意味着相应的流被延迟了 offset 秒。 [-]hh:mm:ss[.xxx] 的格式也支持

### 视频选项 {#video-options}

-vframes number (output)
    设置视频输出帧数，是`-frames:v`的别称。

-b bitrate 设置比特率，缺省 200kb/s
-r fps 设置帧率 缺省 25
-s size 设置画面的宽高

    设置帧大小，分辨率， 格式为 wxh 缺省为原视频大小。下面的简写也可以直接使用：
    ntsc 720x480
    snits 640x480
    hd720 1280x720
    hd1080 1920x1080
    更多[参考](https://ffmpeg.org/ffmpeg-utils.html#toc-Video-size)

-aspect aspect 设置画面比例 4:3 16:9 或 1.3333 1.7777
-croptop size 设置顶部切除带大小 像素单位
-cropbottom size –cropleft size –cropright size
-padtop size 设置顶部补齐的大小 像素单位

-padbottom size –padleft size –padright size –padcolor color 设置补齐条颜色 (hex,6 个 16 进制的数，红：绿：兰排列，比如 000000 代表黑色）

-vn 不做视频记录，输出无视频内容
-bt tolerance 设置视频码率容忍度 kbit/s
-maxrate bitrate 设置最大视频码率容忍度
-minrate bitreate 设置最小视频码率容忍度

-bufsize size 设置码率控制缓冲区大小

-sameq 使用同样视频质量作为源（VBR）

-pass n 选择处理遍数（1 或者 2）。两遍编码非常有用。第一遍生成统计信息，第二遍生成精确的请求的码率

-passlogfile file 选择两遍的纪录文件名为 file

-g gop_size 设置图像组大小

-intra 仅适用帧内编码

-qscale q 使用固定的视频量化标度 (VBR)

-qmin q 最小视频量化标度 (VBR)

-qmax q 最大视频量化标度 (VBR)

-qdiff q 量化标度间最大偏差 (VBR)

-qblur blur 视频量化标度柔化 (VBR)

-qcomp compression 视频量化标度压缩 (VBR)

-rc_init_cplx complexity 一遍编码的初始复杂度

-b_qfactor factor 在 p 和 b 帧间的 qp 因子

-i_qfactor factor 在 p 和 i 帧间的 qp 因子

-b_qoffset offset 在 p 和 b 帧间的 qp 偏差

-i_qoffset offset 在 p 和 i 帧间的 qp 偏差

-rc_eq equation 设置码率控制方程 默认 tex^qComp

-rc_override override 特定间隔下的速率控制重载

-me method 设置运动估计的方法 可用方法有 zero phods log x1 epzs（缺省） full

-dct_algo algo 设置 dct 的算法 可用的有 0 FF_DCT_AUTO 缺省的 DCT 1 FF_DCT_FASTINT 2 FF_DCT_INT 3 FF_DCT_MMX 4 FF_DCT_MLIB 5 FF_DCT_ALTIVEC

-idct_algo algo 设置 idct 算法。可用的有 0 FF_IDCT_AUTO 缺省的 IDCT 1 FF_IDCT_INT 2 FF_IDCT_SIMPLE 3 FF_IDCT_SIMPLEMMX 4 FF_IDCT_LIBMPEG2MMX 5 FF_IDCT_PS2 6 FF_IDCT_MLIB 7 FF_IDCT_ARM 8 FF_IDCT_ALTIVEC 9 FF_IDCT_SH4 10 FF_IDCT_SIMPLEARM

-er n 设置错误残留为 n 1 FF_ER_CAREFULL 缺省 2 FF_ER_COMPLIANT 3 FF_ER_AGGRESSIVE 4 FF_ER_VERY_AGGRESSIVE

-ec bit_mask 设置错误掩蔽为 bit_mask, 该值为如下值的位掩码 1 FF_EC_GUESS_MVS (default=enabled) 2 FF_EC_DEBLOCK (default=enabled)

-bf frames 使用 frames B 帧，支持 mpeg1,mpeg2,mpeg4

-mbd mode 宏块决策 0 FF_MB_DECISION_SIMPLE 使用 mb_cmp 1 FF_MB_DECISION_BITS 2 FF_MB_DECISION_RD

-4mv 使用 4 个运动矢量 仅用于 mpeg4

-part 使用数据划分 仅用于 mpeg4

-bug param 绕过没有被自动监测到编码器的问题

-strict strictness 跟标准的严格性

-aic 使能高级帧内编码 h263+

-umv 使能无限运动矢量 h263+

-deinterlace 不采用交织方法

-interlace 强迫交织法编码仅对 mpeg2 和 mpeg4 有效。当你的输入是交织的并且你想要保持交织以最小图像损失的时候采用该选项。可选的方法是不交织，但是损失更大

-psnr 计算压缩帧的 psnr

-vstats 输出视频编码统计到 vstats_hhmmss.log

-vhook module 插入视频处理模块 module 包括了模块名和参数，用空格分开

### 音频选项 {#audio-options}

-aframes number (output)
    设置输出文件音频帧数，是`-frames:a` 的别名

-ab bitrate
    设置音频码率，声音比特率，-ac 设为立体声时要以一半比特率来设置，比如 192kbps 的就设置成 96，高品质音乐建议 160kbps(80) 一上

-ar freq
    设置音频采样率，一般设置 44100

-ac channels
    设置通道，声道数， 缺省为 1, 1 为单声道，2 为立体声

-an 不使用音频纪录

-acodec codec
    使用 codec 编解码，是`-codec:a`的别名

-vd device 设置视频捕获设备。比如 /dev/video0

-vc channel 设置视频捕获通道 DV1394 专用

-tvstd standard 设置电视标准 NTSC PAL(SECAM)

-dv1394 设置 DV1394 捕获

-av device 设置音频设备 比如 /dev/dsp

### 高级选项 {#advance-option}

-map file:stream 设置输入流映射

-debug 打印特定调试信息

-benchmark 为基准测试加入时间

-hex 倾倒每一个输入包

-bitexact 仅使用位精确算法 用于编解码测试

-ps size 设置包大小，以 bits 为单位

-re 以本地帧频读数据，主要用于模拟捕获设备

-loop 循环输入流。只工作于图像流，用于 ffserver 测试

Hyper fast Audio and Video encoder
usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...

Getting help:
    -h      -- print basic options
    -h long -- print more options
    -h full -- print all options (including all format and codec specific options, very long)
    -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter
    See man ffmpeg for detailed description of the options.

Print help / information / capabilities:
-L                  show license
-h topic            show help
-? topic            show help
-help topic         show help
--help topic        show help
-version            show version
-buildconf          show build configuration
-formats            show available formats
-devices            show available devices
-codecs             show available codecs
-decoders           show available decoders
-encoders           show available encoders
-bsfs               show available bit stream filters
-protocols          show available protocols
-filters            show available filters
-pix_fmts           show available pixel formats
-layouts            show standard channel layouts
-sample_fmts        show available audio sample formats
-colors             show available color names
-sources device     list sources of the input device
-sinks device       list sinks of the output device
-hwaccels           show available HW acceleration methods

Global options (affect whole program instead of just one file:
-loglevel loglevel  set logging level
-v loglevel         set logging level
-report             generate a report
-max_alloc bytes    set maximum size of a single allocated block
-y                  overwrite output files
-n                  never overwrite output files
-ignore_unknown     Ignore unknown stream types
-stats              print progress report during encoding
-max_error_rate ratio of errors (0.0: no errors, 1.0: 100% error  maximum error rate
-bits_per_raw_sample number  set the number of bits per raw sample
-vol volume         change audio volume (256=normal)

Per-file main options:
-f fmt              force format
-c codec            codec name
-codec codec        codec name
-pre preset         preset name
-map_metadata outfile[,metadata]:infile[,metadata]  set metadata information of outfile from infile
-t duration         record or transcode "duration" seconds of audio/video
-to time_stop       record or transcode stop time
-fs limit_size      set the limit file size in bytes
-ss time_off        set the start time offset
-sseof time_off     set the start time offset relative to EOF
-seek_timestamp     enable/disable seeking by timestamp with -ss
-timestamp time     set the recording timestamp ('now' to set the current time)
-metadata string=string  add metadata
-program title=string:st=number...  add program with specified streams
-target type        specify target file type ("vcd", "svcd", "dvd", "dv" or "dv50" with optional prefixes "pal-", "ntsc-" or "film-")
-apad               audio pad
-frames number      set the number of frames to output
-filter filter_graph  set stream filtergraph
-filter_script filename  read stream filtergraph description from a file
-reinit_filter      reinit filtergraph on input parameter changes
-discard            discard
-disposition        disposition

Video options:
-vframes number     set the number of video frames to output
-r rate             set frame rate (Hz value, fraction or abbreviation)
-s size             set frame size (WxH or abbreviation)
-aspect aspect      set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)
-bits_per_raw_sample number  set the number of bits per raw sample
-vn                 disable video
-vcodec codec       force video codec ('copy' to copy stream)
-timecode hh:mm:ss[:;.]ff  set initial TimeCode value.
-pass n             select the pass number (1 to 3)
-vf filter_graph    set video filters
-ab bitrate         audio bitrate (please use -b:a)
-b bitrate          video bitrate (please use -b:v)
-dn                 disable data

Audio options:
-aframes number     set the number of audio frames to output
-aq quality         set audio quality (codec-specific)
-ar rate            set audio sampling rate (in Hz)
-ac channels        set number of audio channels
-an                 disable audio
-acodec codec       force audio codec ('copy' to copy stream)
-vol volume         change audio volume (256=normal)
-af filter_graph    set audio filters

Subtitle options:
-s size             set frame size (WxH or abbreviation)
-sn                 disable subtitle
-scodec codec       force subtitle codec ('copy' to copy stream)
-stag fourcc/tag    force subtitle tag/fourcc
-fix_sub_duration   fix subtitles duration
-canvas_size size   set canvas size (WxH or abbreviation)
-spre preset        set the subtitle options to the indicated preset

#include <boost/lexical_cast.hpp>
using namespace boost;

using boost::lexical_cast;
int a = lexical_cast<int>("123");					// string -> int
long b = lexical_cast<long>("2015");				// string -> long
double c = lexical_cast<double>("123.12");			// string -> double
float pai = lexical_cast<float>("3.14159");			// string -> float

std::cout << a << b << c << pai << std::endl;

string str = lexical_cast<string>(123);				// int -> string
std::cout << str << std::endl;
cout << lexical_cast<string>(1.234) << endl;		// float -> string
cout << lexical_cast<string>(0x11) << endl;			// 16进制 -> string

// lexical_cast can cast 0 & 1 to bool, but only support 0 & 1, not support True or False string
bool bl = lexical_cast<bool>("1");					// string -> bool, only support 1 & 0

try{
	cout << lexical_cast<int>("0x100");
	cout << lexical_cast<bool>("false");
}catch (bad_lexical_cast& e){
	cout << "error: " << e.what() << endl;
}

class demo_class{
    friend ostream& operator<<(ostream& os, const demo_class& x){
        os << "class content" << endl;
        return os;
    }
};
int main() {
    demo_class demo = demo_class();
    cout << lexical_cast<string>(demo) << endl;
}