1. /*
2.  * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
3.  * Copyright (C) 2005-2014, Anthony Minessale II <anthm@freeswitch.org>
4.  *
5.  * Version: MPL 1.1
6.  *
7.  * The contents of this file are subject to the Mozilla Public License Version
8.  * 1.1 (the "License"); you may not use this file except in compliance with
9.  * the License. You may obtain a copy of the License at
10.  * http://www.mozilla.org/MPL/
11.  *
12.  * Software distributed under the License is distributed on an "AS IS" basis,
13.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
14.  * for the specific language governing rights and limitations under the
15.  * License.
16.  *
17.  * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
18.  *
19.  * The Initial Developer of the Original Code is
20.  * Anthony Minessale II <anthm@freeswitch.org>
21.  * Portions created by the Initial Developer are Copyright (C)
22.  * the Initial Developer. All Rights Reserved.
23.  *
24.  * Contributor(s):
25.  *  
26.  * Mathieu Rene <mrene@avgs.ca>
27.  *
28.  * fs_encode.c -- Encode a native file
29.  *
30.  */
31.  
32. #ifndef _XOPEN_SOURCE
33. #define _XOPEN_SOURCE 600
34. #endif
35.  
36. #ifndef WIN32
37. /*GRC: #include <linux/limits.h> */
38. #ifdef HAVE_SETRLIMIT
39. #include <sys/resource.h>
40. #endif
41. #endif
42.  
43. // C
44. #include <dirent.h>
45. //#include <stdio.h>
46. // #include <strings.h>
47. // C++
48. //#include <string>
49. // Freeswitch
50. #include <switch.h>
51.  
52. /* Picky compiler */
53. #ifdef __ICC
54. #pragma warning (disable:167)
55. #endif
56.  
57. #define PATH_MAX 4096
58.  
59.  
60. int encode_wav_file(int DEBUG, const char* input, int channels, int rate, int ptime, switch_codec_t* pcmu_codec, switch_codec_t* g729_codec);
61. int encode_chunk(int DEBUG,char* buf, size_t bufsize, size_t len, int rate, switch_codec_t* codec, switch_file_handle_t fh_output);
62. void substring(const char [], char[], int, int);
63.  
64. static void cleanup_globals()
65. {
66.         switch_safe_free(SWITCH_GLOBAL_dirs.conf_dir);
67.         switch_safe_free(SWITCH_GLOBAL_dirs.mod_dir);
68.         switch_safe_free(SWITCH_GLOBAL_dirs.log_dir);
69. }
70.  
71. int main(int argc, char *argv[])
72. {
73.         int i;
74.         int r = 1;
75.         switch_bool_t verbose = SWITCH_FALSE;
76.         int DEBUG = 0;
77.         const char* err = NULL;
78.         int cmd_fail = 0;
79.         const char *fmtp = "";
80.         const char *input;
81.         int ptime = 20;
82.         int channels = 1;
83.         int rate = 8000;
84.         int bitrate = 0;
85.         switch_memory_pool_t *pool = NULL;
86.         switch_codec_t pcmu_codec = { 0 };
87.         switch_codec_t g729_codec = { 0 };
88.         DIR* dir = NULL;
89.         struct dirent* ent = NULL;
90.         const char* dot = NULL;
91.         int num_converted = 0;
92.         char filename[PATH_MAX];
93.         const char* slash = "";
94.         const char* loadable_modules[] = {"mod_dahdi_codec","mod_spandsp","mod_sndfile", "mod_native_file"};
95.  
96.         for (i = 1; i < argc; i++) {
97.                 if (argv[i][0] == '-') {
98.                         switch(argv[i][1]) {
99.                                 case 'c':
100.                                         i++;
101.                                         if((SWITCH_GLOBAL_dirs.conf_dir = (char *) malloc(strlen(argv[i]) + 1)) == NULL) {
102.                                                 return 255;
103.                                         }
104.                                         strcpy(SWITCH_GLOBAL_dirs.conf_dir, argv[i]);
105.                                         break;
106.                                 case 'k':
107.                                         i++;
108.                                         if((SWITCH_GLOBAL_dirs.log_dir = (char *) malloc(strlen(argv[i]) + 1)) == NULL) {
109.                                                 return 255;
110.                                         }
111.                                         strcpy(SWITCH_GLOBAL_dirs.log_dir, argv[i]);
112.                                         break;
113.                                 case 'm':
114.                                         i++;
115.                                         if((SWITCH_GLOBAL_dirs.mod_dir = (char *) malloc(strlen(argv[i]) + 1)) == NULL) {
116.                                                 return 255;
117.                                         }
118.                                         strcpy(SWITCH_GLOBAL_dirs.mod_dir, argv[i]);
119.                                         break;
120.                                 case 'f':
121.                                         fmtp = argv[++i];
122.                                         break;
123.                                 case 'p':
124.                                         ptime = atoi(argv[++i]);
125.                                         break;
126.                                 case 'r':
127.                                         rate = atoi(argv[++i]);
128.                                         break;
129.                                 case 'b':
130.                                         bitrate = atoi(argv[++i]);
131.                                         break;
132.                                 case 'v':
133.                                         verbose = SWITCH_TRUE;
134.                                         DEBUG = 1;
135.                                         break;
136.                                 default:
137.                                         printf("Command line option not recognized: %s\n", argv[i]);
138.                                         cmd_fail = 1;
139.                         }
140.                 } else {
141.                         break;
142.                 }
143.         }
144.         if (DEBUG)
145.                 fprintf(stderr, "GRC: Parsed arguments\n");
146.         if (argc - i < 1 || cmd_fail) {
147.                 goto usage;
148.         }
149.        
150.         input = argv[i++];
151.         if (zstr(input)) {
152.                 goto usage;
153.         }
154.        
155.         if (switch_core_init(SCF_MINIMAL, verbose, &err) != SWITCH_STATUS_SUCCESS) {
156.                 fprintf(stderr, "Cannot init core [%s]\n", err);
157.                 goto end;
158.         }
159.     if (DEBUG){
160.                 fprintf(stderr, "GRC: Inistialized Core\n");
161.                 fprintf(stderr, "Mod dir=%s\n", SWITCH_GLOBAL_dirs.mod_dir);
162.         }
163.        
164.         switch_loadable_module_init(SWITCH_FALSE);
165.         switch_loadable_module_load_module((char*)"", (char*)"CORE_PCM_MODULE", SWITCH_TRUE, &err);
166.         if (DEBUG) fprintf(stderr, "GRC: Inistialized CORE_PCM_MODULE: %s\n",err);
167.         switch_loadable_module_load_module((char*)"", (char*)"CORE_SPEEX_MODULE", SWITCH_TRUE, &err);
168.         if (DEBUG) fprintf(stderr, "GRC: Inistialized CORE_SPEEX_MODULE: %s\n",err);
169.         switch_loadable_module_load_module((char*)"", (char*)"CORE_SOFTTIMER_MODULE", SWITCH_TRUE, &err);
170.         if (DEBUG) fprintf(stderr, "GRC: Inistialized CORE_SOFTTIMER_MODULE: %s\n",err);
171.        
172.         if (DEBUG) fprintf(stderr, "GRC: Loadable modules: %d\n",(int)(sizeof(loadable_modules)/sizeof(loadable_modules[0])));
173.  
174.         for (i = 0; i < (int)(sizeof(loadable_modules)/sizeof(loadable_modules[0])); i++) {
175.                 if (switch_loadable_module_load_module((char*) SWITCH_GLOBAL_dirs.mod_dir, (char*)loadable_modules[i], SWITCH_TRUE, &err) != SWITCH_STATUS_SUCCESS) {
176.                         fprintf(stderr, "Cannot init %s [%s]\n", loadable_modules[i], err);
177.                         goto end;
178.                 }
179.                 if (DEBUG) fprintf(stderr, "GRC: Inistialized Loadable module: %s -- %s\n",(char*)loadable_modules[i],err);
180.         }
181.         if (DEBUG) fprintf(stderr, "GRC: Inistialized Loadable modules: %s\n",err);
182.        
183.         switch_core_new_memory_pool(&pool);
184.         if (DEBUG) fprintf(stderr, "GRC: Allocated memory pool\n");
185.        
186.         if (input[strlen(input)-1] != '/') {
187.                 slash = "/";
188.         }
189.         if (DEBUG) {
190.                 fprintf(stderr, "GRC: Slash: %s\n",slash);
191.                 fprintf(stderr, "GRC: Input: %s\n",input);
192.                 fprintf(stderr, "About to initialize PCMU codec for PCMU@%dh@%di  Channels %d   Bitrate %d\n", rate, ptime, channels, bitrate);
193.         }
194.        
195.         i=switch_core_codec_init_with_bitrate(&pcmu_codec, "PCMU", NULL,fmtp,rate, ptime, channels, bitrate,(uint32_t)SWITCH_CODEC_FLAG_ENCODE, NULL,pool);
196.                                
197.                                 /* switch_codec_t*, const char*, const char*, uint32_t, int, int, uint32_t, uint32_t, const switch_codec_settings_t*, switch_memory_pool_t**/
198.                                
199.         if (DEBUG) fprintf(stderr, "i:%d\n", i);       
200.         if (i != SWITCH_STATUS_SUCCESS) {
201.                 fprintf(stderr, "Couldn't initialize codec for PCMU@%dh@%di\n", rate, ptime);
202.                 goto end;
203.         }
204.         if (DEBUG) fprintf(stderr, "GRC: Inistialized PCMU\n");
205.         i=0;
206.        
207.         if (DEBUG) fprintf(stderr, "About to initialize G729 codec for G729@%dh@%di  Channels %d   Bitrate %d\n", rate, ptime, channels, bitrate);
208.        
209.         i = switch_core_codec_init_with_bitrate(&g729_codec, "G729", NULL, fmtp, rate, ptime, channels, bitrate,
210.                                 SWITCH_CODEC_FLAG_ENCODE, NULL, pool);
211.         if (DEBUG) fprintf(stderr, "i:%d\n", i);
212.         if (i != SWITCH_STATUS_SUCCESS) {
213.                 fprintf(stderr, "Couldn't initialize codec for G729@%dh@%di\n", rate, ptime);
214.                 goto end;
215.         }
216.         if (DEBUG) fprintf(stderr, "GRC: Inistialized G.729\n");
217.        
218.  
219.        
220.         if ((dir = opendir(input)) != NULL) {
221.                 while ((ent = readdir(dir)) != NULL) {
222.                         if (ent->d_type == 8) {   //DT_REG
223.                                 if ((dot = strrchr(ent->d_name, '.')) != NULL && strcasecmp(dot, ".WAV") == 0) {
224.                                         sprintf(filename, "%s%s%s", input, slash, ent->d_name);
225.                                         if (DEBUG) printf("Converting %s\n", filename);
226.                                         if (encode_wav_file(DEBUG, filename, channels, rate, ptime, &pcmu_codec, &g729_codec)) {
227.                                                 num_converted++;
228.                                         } else {
229.                                                 fprintf(stderr, "Error converting %s\n", ent->d_name);
230.                                                 goto end;
231.                                         }
232.                                 }
233.                         }
234.                 }
235.         } else {
236.                 fprintf(stderr, "Couldn't open directory %s\n", input);
237.                 goto end;
238.         }
239.  
240.         if (DEBUG) fprintf(stdout, "Done converting %d file(s).\n", num_converted);
241.         r = 0;
242.  
243. end:
244.         if (dir) {
245.                 closedir (dir);
246.         }
247.  
248.         switch_core_codec_destroy(&pcmu_codec);
249.         switch_core_codec_destroy(&g729_codec);
250.  
251.         if (pool) {
252.                 switch_core_destroy_memory_pool(&pool);
253.         }
254.  
255.         cleanup_globals();
256.         return r;
257.  
258. usage:
259.         printf("Usage: %s [options] dir\n\n", argv[0]);
260.         printf("dir: path to directory containing .WAV files to convert\n");
261.         printf("\t\t -c path\t\t Path to the FS configurations.\n");
262.         printf("\t\t -k path\t\t Path to the FS log directory\n");
263.         printf("\t\t -m path\t\t Path to the modules.\n");
264.         printf("\t\t -f format\t\t fmtp to pass to the codec\n");
265.         printf("\t\t -p ptime\t\t ptime to use while encoding\n");
266.         printf("\t\t -r rate\t\t sampling rate\n");
267.         printf("\t\t -b bitrate\t\t codec bitrate (if supported)\n");
268.         printf("\t\t -v\t\t\t verbose\n");
269.  
270.         cleanup_globals();
271.         return 1;
272. }
273.  
274. void substring(const char s[], char sub[], int p, int l) {
275.    int c = 0;
276.  
277.    while (c < l) {
278.       sub[c] = s[p+c-1];
279.       c++;
280.    }
281.    sub[c] = '\0';
282. }
283.  
284. int encode_wav_file(int DEBUG,const char* input, int channels, int rate, int ptime, switch_codec_t* pcmu_codec, switch_codec_t* g729_codec)
285. {
286.         //using namespace std;
287.  
288.         int pos = 0;
289.         char* charpos;
290.         int r = 1;
291.         switch_file_handle_t fh_wav = { 0 };
292.         switch_file_handle_t fh_pcmu = { 0 };
293.         switch_file_handle_t fh_g729 = { 0 };
294.         char buf[2048];
295.         char basename[PATH_MAX];
296.         char pcmu_output[PATH_MAX];
297.         char g729_output[PATH_MAX];
298.        
299.         switch_size_t len = (rate*ptime)/1000;
300.         int blocksize = len;
301.        
302.         switch_assert(sizeof(buf) >= len * 2);
303.  
304.         //string tmp = input;
305.         //size_t pos = tmp.find_last_of('.');
306.         charpos = strrchr(input,'.');
307.         if (charpos == NULL) {
308.                 fprintf(stderr, "Missing file extension in %s\n", input);
309.                 return 0;
310.         }
311.        
312.         //string basename = tmp.substr(0, pos);
313.         //string pcmu_output = basename + ".PCMU";
314.         //string g729_output = basename + ".G729";
315.        
316.         pos = charpos - input;
317.         if (DEBUG) fprintf(stderr, "encode_wav_file:pos: %d\n", pos);
318.         //substring(input,basename,0,pos);
319.         strncpy(basename,input,pos);
320.         basename[pos]='\0';
321.  
322.         sprintf(pcmu_output,"%s.PCMU",basename);
323.         sprintf(g729_output,"%s.G729",basename);
324.        
325.         if (DEBUG){
326.                 fprintf(stderr, "encode_wav_file:input: %s\n", input);
327.                 fprintf(stderr, "encode_wav_file:basename: %s\n", basename);
328.                 fprintf(stderr, "encode_wav_file:PCMU %s\n", pcmu_output);
329.                 fprintf(stderr, "encode_wav_file:G729 %s\n", g729_output);
330.         }
331.        
332.         if (switch_core_file_open(&fh_wav, input, channels, rate,
333.                                 SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT, NULL) != SWITCH_STATUS_SUCCESS) {
334.                 fprintf(stderr, "Couldn't open %s\n", input);
335.                 goto end;
336.         }
337.  
338.         if (switch_core_file_open(&fh_pcmu, pcmu_output, channels, pcmu_codec->implementation->actual_samples_per_second,
339.                                 SWITCH_FILE_FLAG_WRITE | SWITCH_FILE_NATIVE, NULL) != SWITCH_STATUS_SUCCESS) {
340.                 fprintf(stderr, "Couldn't open %s\n", pcmu_output);
341.                 goto end;      
342.         }
343.  
344.         if (switch_core_file_open(&fh_g729, g729_output, channels, g729_codec->implementation->actual_samples_per_second,
345.                                 SWITCH_FILE_FLAG_WRITE | SWITCH_FILE_NATIVE, NULL) != SWITCH_STATUS_SUCCESS) {
346.                 fprintf(stderr, "Couldn't open %s\n", g729_output);
347.                 goto end;      
348.         }
349.  
350.         if (DEBUG) fprintf(stderr, "encode_wav_file:blocksize %d, rate %d\n", blocksize, rate);
351.         while (switch_core_file_read(&fh_wav, buf, &len) == SWITCH_STATUS_SUCCESS) {
352.                 if (!encode_chunk(DEBUG,(char*)buf, sizeof(buf), len, rate, pcmu_codec, fh_pcmu) ||
353.                         !encode_chunk(DEBUG,(char*)buf, sizeof(buf), len, rate, g729_codec, fh_g729)) {
354.                         goto end;
355.                 }
356.                
357.                 len = blocksize;
358.         }
359.  
360.         r = 1;
361.  
362. end:
363.         if (fh_wav.file_interface) {
364.                 switch_core_file_close(&fh_wav);
365.         }
366.  
367.         if (fh_pcmu.file_interface) {
368.                 switch_core_file_close(&fh_pcmu);
369.         }
370.        
371.         if (fh_g729.file_interface) {
372.                 switch_core_file_close(&fh_g729);
373.         }
374.  
375.         return r;
376. }
377.  
378. int encode_chunk(int DEBUG,char* buf, size_t bufsize, size_t len, int rate, switch_codec_t* codec, switch_file_handle_t fh_output) {
379.         char encode_buf[2048];
380.         uint32_t encoded_len = bufsize;
381.         uint32_t encoded_rate = rate;
382.         unsigned int flags = 0;
383.  
384.         if (switch_core_codec_encode(codec, NULL, buf, len*2, rate, encode_buf, &encoded_len, &encoded_rate, &flags) != SWITCH_STATUS_SUCCESS) {
385.                 fprintf(stderr, "Codec encoder error\n");
386.                 return 0;
387.         }
388.        
389.         len = encoded_len;
390.         if (DEBUG) fprintf(stderr, "encode_chunk: len: %d\n",(int)len);
391.         if (switch_core_file_write(&fh_output, encode_buf, &len) != SWITCH_STATUS_SUCCESS) {
392.                 fprintf(stderr, "Write error\n");
393.                 return 0;
394.         }
395.        
396.         if (len != encoded_len) {
397.                 printf("Short write: wrote %"SWITCH_SIZE_T_FMT"/%d bytes\n", len, encoded_len);
398.                 return 0;
399.         }
400.  
401.         return 1;
402. }
403.  
404.  
405.