ffmpeg命令行封装

lhd666

本来想把 ffmpeg 命令行简单封装一下，让它易于使用，但是我实在是太菜，反而弄得更啰嗦难用了，大家指导一下，指点思路呗

1. #include <glib.h>
   
2. 
   
3. struct ffmpeg_wrap {
   
4.         char *input_url;
   
5.         char *output_url;
   
6.         GVariantDict *input_dict;
   
7.         GVariantDict *output_dict;
   
8.         gboolean overwrite;
   
9. };
   
10. 
    
11. 
    
12. struct ffmpeg_wrap *ffmpeg_wrap_new(void)
    
13. {
    
14.         struct ffmpeg_wrap *wrap;
    
15. 
    
16.         wrap = g_new0(struct ffmpeg_wrap, 1);
    
17.         wrap->input_dict = g_variant_dict_new(NULL);
    
18.         wrap->output_dict = g_variant_dict_new(NULL);
    
19.         wrap->overwrite = FALSE;
    
20. 
    
21.         return wrap;
    
22. }
    
23. 
    
24. void ffmpeg_wrap_free(struct ffmpeg_wrap *wrap)
    
25. {
    
26.         g_free(wrap->input_url);
    
27.         g_free(wrap->output_url);
    
28.         g_variant_dict_unref(wrap->input_dict);
    
29.         g_variant_dict_unref(wrap->output_dict);
    
30.         g_free(wrap);
    
31. }
    
32. 
    
33. void ffmpeg_wrap_input_set_url(struct ffmpeg_wrap *wrap, const gchar *url)
    
34. {
    
35.         if (wrap->input_url)
    
36.                 g_free(wrap->input_url);
    
37.         wrap->input_url = g_strdup(url);
    
38. }
    
39. 
    
40. void ffmpeg_wrap_output_set_url(struct ffmpeg_wrap *wrap, const gchar *url)
    
41. {
    
42.         if (wrap->output_url)
    
43.                 g_free(wrap->output_url);
    
44.         wrap->output_url = g_strdup(url);
    
45. }
    
46. 
    
47. /*
    
48. * 设置输出视频分辨率，默认使用源视频分辨率
    
49. * 如：1280, 720
    
50. */
    
51. void ffmpeg_wrap_output_set_size(struct ffmpeg_wrap *wrap, guint width, guint height)
    
52. {
    
53.         g_variant_dict_insert(wrap->output_dict, "-s", "(uu)", width, height);
    
54. }
    
55. 
    
56. /*
    
57. * 设置输出音频编码格式，不设置ffmpeg会根据输出文件名自动推导，设置为"copy"，
    
58. * 可以直接复制音频，避免解码和编码，但如果输出文件容器不支持，执行会失败
    
59. * 如："aac"
    
60. */
    
61. void ffmpeg_wrap_output_set_acodec(struct ffmpeg_wrap *wrap, const gchar *acodec)
    
62. {
    
63.         g_variant_dict_insert(wrap->output_dict, "-acodec", "s", acodec);
    
64. }
    
65. 
    
66. /*
    
67. * 设置输出音频编码器格式，不设置ffmpeg会根据输出文件名自动推导，设置为"copy",
    
68. * 可以直接复制视频，避免解码和编码，但如果输出文件容器不支持，执行会失败
    
69. * 如："h264"
    
70. */
    
71. void ffmpeg_wrap_output_set_vcodec(struct ffmpeg_wrap *wrap, const gchar *vcodec)
    
72. {
    
73.         g_variant_dict_insert(wrap->output_dict, "-vcodec", "s", vcodec);
    
74. }
    
75. 
    
76. /*
    
77. * 设置输出帧率，默认25
    
78. */
    
79. void ffmpeg_wrap_output_set_fps(struct ffmpeg_wrap *wrap, guint fps)
    
80. {
    
81.         g_variant_dict_insert(wrap->output_dict, "-r", "u", fps);
    
82. }
    
83. 
    
84. /*
    
85. * 设置最大输出码率，单位：kbps
    
86. */
    
87. void ffmpeg_wrap_output_set_maxrate(struct ffmpeg_wrap *wrap, guint maxrate)
    
88. {
    
89.         g_variant_dict_insert(wrap->output_dict, "-maxrate", "u", maxrate);
    
90. }
    
91. 
    
92. /*
    
93. * 设置最小输出码率，单位：kbps
    
94. */
    
95. void ffmpeg_wrap_output_set_minrate(struct ffmpeg_wrap *wrap, guint minrate)
    
96. {
    
97.         g_variant_dict_insert(wrap->output_dict, "-minrate", "u", minrate);
    
98. }
    
99. 
    
100. /*
     
101. * 不输出音频
     
102. */
     
103. void ffmpeg_wrap_output_disable_audio(struct ffmpeg_wrap *wrap)
     
104. {
     
105.         g_variant_dict_insert(wrap->output_dict, "-an", "s", "");
     
106. }
     
107. 
     
108. /*
     
109. * 不输出视频
     
110. */
     
111. void ffmpeg_wrap_output_disable_video(struct ffmpeg_wrap *wrap)
     
112. {
     
113.         g_variant_dict_insert(wrap->output_dict, "-vn", "s", "");
     
114. }
     
115. 
     
116. /*
     
117. * 如果输出文件名重复，覆盖
     
118. */
     
119. void ffmpeg_wrap_output_set_overwrite(struct ffmpeg_wrap *wrap)
     
120. {
     
121.         wrap->overwrite = TRUE;
     
122. }
     
123. 
     
124. static GString *get_kwargs(GString *comand, GVariantDict *dict)
     
125. {
     
126.         GVariantIter iter;
     
127.         GVariant *value;
     
128.         gchar *key;
     
129. 
     
130.         g_variant_iter_init(&iter, g_variant_dict_end(dict));
     
131.         while (g_variant_iter_loop(&iter, "{sv}", &key, &value)) {
     
132.                 if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
     
133.                         g_string_append_printf(comand, "%s %s ", key, g_variant_get_string(value, NULL));
     
134.                 } else if (g_variant_is_of_type(value, G_VARIANT_TYPE_UINT32)) {
     
135.                         g_string_append_printf(comand, "%s %u ", key, g_variant_get_uint32(value));
     
136.                 } else if (g_variant_is_of_type(value, G_VARIANT_TYPE_TUPLE)) {
     
137.                         /* FIXME: 目前tuple只能分辨率，但也许这样做并不安全 */
     
138.                         guint32 width, height;
     
139.                         g_variant_get(value, "(uu)", &width, &height);
     
140.                         g_string_append_printf(comand, "%s %ux%u ", key, width, height);
     
141.                 }
     
142.         }
     
143. 
     
144.         return comand;
     
145. }
     
146. 
     
147. static GString *get_command(struct ffmpeg_wrap *wrap)
     
148. {
     
149.         GString *comand;
     
150. 
     
151.         comand = g_string_new("/bin/ffmpeg ");
     
152. 
     
153.         /* 输入参数，好吧，实际上并没有设置(<: */
     
154.         get_kwargs(comand, wrap->input_dict);
     
155. 
     
156.         g_string_append_printf(comand, "-i %s ", wrap->input_url);
     
157. 
     
158.         /* 输出参数 */
     
159.         get_kwargs(comand, wrap->output_dict);
     
160. 
     
161.         g_string_append(comand, wrap->output_url);
     
162. 
     
163.         /* 重名时是否覆盖输出文件 */
     
164.         if (wrap->overwrite)
     
165.                 g_string_append(comand, " -y");
     
166. 
     
167.         return comand;
     
168. }
     
169. 
     
170. void ffmpeg_wrap_run(struct ffmpeg_wrap *wrap)
     
171. {
     
172.         GString *comand;
     
173. 
     
174.         comand = get_command(wrap);
     
175.         /* 需要增加system()或popen() */
     
176.         g_print("%s\n", comand->str);
     
177.         g_string_free(comand, TRUE);
     
178. }
     
179. 
     
180. int main(int argc, char **argv)
     
181. {
     
182.         struct ffmpeg_wrap *wrap;
     
183. 
     
184.         wrap = ffmpeg_wrap_new();
     
185.         ffmpeg_wrap_input_set_url(wrap, "input.mp4");
     
186.         ffmpeg_wrap_output_set_url(wrap, "output.mp4");
     
187.         ffmpeg_wrap_output_set_fps(wrap, 25);
     
188.         ffmpeg_wrap_output_set_vcodec(wrap, "h264");
     
189.         ffmpeg_wrap_output_set_acodec(wrap, "aac");
     
190.         ffmpeg_wrap_output_set_size(wrap, 1280, 720);
     
191.         ffmpeg_wrap_output_set_overwrite(wrap);
     
192.         ffmpeg_wrap_run(wrap);
     
193.         ffmpeg_wrap_free(wrap);
     
194. 
     
195.         return 0;
     
196. }

复制代码

它会输出如下信息：
/bin/ffmpeg -i input.mp4 -vcodec h264 -acodec aac -r 25 -s 1280x720 output.mp4 -y

我想的是将参数分为输入和输出两块，用字典存储它们。如果参数后面有值，字典存储正好，如果没值，值用""代替，最后拼接成要执行的命令，但结果就是这个鸟样子了。