1/*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "AudioResampler.h"
18#include <media/AudioBufferProvider.h>
19#include <unistd.h>
20#include <stdio.h>
21#include <stdlib.h>
22#include <fcntl.h>
23#include <string.h>
24#include <sys/mman.h>
25#include <sys/stat.h>
26#include <errno.h>
27#include <time.h>
28#include <math.h>
29
30using namespace android;
31
32struct HeaderWav {
33    HeaderWav(size_t size, int nc, int sr, int bits) {
34        strncpy(RIFF, "RIFF", 4);
35        chunkSize = size + sizeof(HeaderWav);
36        strncpy(WAVE, "WAVE", 4);
37        strncpy(fmt,  "fmt ", 4);
38        fmtSize = 16;
39        audioFormat = 1;
40        numChannels = nc;
41        samplesRate = sr;
42        byteRate = sr * numChannels * (bits/8);
43        align = nc*(bits/8);
44        bitsPerSample = bits;
45        strncpy(data, "data", 4);
46        dataSize = size;
47    }
48
49    char RIFF[4];           // RIFF
50    uint32_t chunkSize;     // File size
51    char WAVE[4];        // WAVE
52    char fmt[4];            // fmt\0
53    uint32_t fmtSize;       // fmt size
54    uint16_t audioFormat;   // 1=PCM
55    uint16_t numChannels;   // num channels
56    uint32_t samplesRate;   // sample rate in hz
57    uint32_t byteRate;      // Bps
58    uint16_t align;         // 2=16-bit mono, 4=16-bit stereo
59    uint16_t bitsPerSample; // bits per sample
60    char data[4];           // "data"
61    uint32_t dataSize;      // size
62};
63
64static int usage(const char* name) {
65    fprintf(stderr,"Usage: %s [-p] [-h] [-s] [-q {dq|lq|mq|hq|vhq}] [-i input-sample-rate] "
66                   "[-o output-sample-rate] [<input-file>] <output-file>\n", name);
67    fprintf(stderr,"    -p    enable profiling\n");
68    fprintf(stderr,"    -h    create wav file\n");
69    fprintf(stderr,"    -s    stereo\n");
70    fprintf(stderr,"    -q    resampler quality\n");
71    fprintf(stderr,"              dq  : default quality\n");
72    fprintf(stderr,"              lq  : low quality\n");
73    fprintf(stderr,"              mq  : medium quality\n");
74    fprintf(stderr,"              hq  : high quality\n");
75    fprintf(stderr,"              vhq : very high quality\n");
76    fprintf(stderr,"    -i    input file sample rate\n");
77    fprintf(stderr,"    -o    output file sample rate\n");
78    return -1;
79}
80
81int main(int argc, char* argv[]) {
82
83    const char* const progname = argv[0];
84    bool profiling = false;
85    bool writeHeader = false;
86    int channels = 1;
87    int input_freq = 0;
88    int output_freq = 0;
89    AudioResampler::src_quality quality = AudioResampler::DEFAULT_QUALITY;
90
91    int ch;
92    while ((ch = getopt(argc, argv, "phsq:i:o:")) != -1) {
93        switch (ch) {
94        case 'p':
95            profiling = true;
96            break;
97        case 'h':
98            writeHeader = true;
99            break;
100        case 's':
101            channels = 2;
102            break;
103        case 'q':
104            if (!strcmp(optarg, "dq"))
105                quality = AudioResampler::DEFAULT_QUALITY;
106            else if (!strcmp(optarg, "lq"))
107                quality = AudioResampler::LOW_QUALITY;
108            else if (!strcmp(optarg, "mq"))
109                quality = AudioResampler::MED_QUALITY;
110            else if (!strcmp(optarg, "hq"))
111                quality = AudioResampler::HIGH_QUALITY;
112            else if (!strcmp(optarg, "vhq"))
113                quality = AudioResampler::VERY_HIGH_QUALITY;
114            else {
115                usage(progname);
116                return -1;
117            }
118            break;
119        case 'i':
120            input_freq = atoi(optarg);
121            break;
122        case 'o':
123            output_freq = atoi(optarg);
124            break;
125        case '?':
126        default:
127            usage(progname);
128            return -1;
129        }
130    }
131    argc -= optind;
132    argv += optind;
133
134    const char* file_in = NULL;
135    const char* file_out = NULL;
136    if (argc == 1) {
137        file_out = argv[0];
138    } else if (argc == 2) {
139        file_in = argv[0];
140        file_out = argv[1];
141    } else {
142        usage(progname);
143        return -1;
144    }
145
146    // ----------------------------------------------------------
147
148    size_t input_size;
149    void* input_vaddr;
150    if (argc == 2) {
151        struct stat st;
152        if (stat(file_in, &st) < 0) {
153            fprintf(stderr, "stat: %s\n", strerror(errno));
154            return -1;
155        }
156
157        int input_fd = open(file_in, O_RDONLY);
158        if (input_fd < 0) {
159            fprintf(stderr, "open: %s\n", strerror(errno));
160            return -1;
161        }
162
163        input_size = st.st_size;
164        input_vaddr = mmap(0, input_size, PROT_READ, MAP_PRIVATE, input_fd, 0);
165        if (input_vaddr == MAP_FAILED ) {
166            fprintf(stderr, "mmap: %s\n", strerror(errno));
167            return -1;
168        }
169    } else {
170        double k = 1000; // Hz / s
171        double time = (input_freq / 2) / k;
172        size_t input_frames = size_t(input_freq * time);
173        input_size = channels * sizeof(int16_t) * input_frames;
174        input_vaddr = malloc(input_size);
175        int16_t* in = (int16_t*)input_vaddr;
176        for (size_t i=0 ; i<input_frames ; i++) {
177            double t = double(i) / input_freq;
178            double y = sin(M_PI * k * t * t);
179            int16_t yi = floor(y * 32767.0 + 0.5);
180            for (size_t j=0 ; j<(size_t)channels ; j++) {
181                in[i*channels + j] = yi / (1+j);
182            }
183        }
184    }
185
186    // ----------------------------------------------------------
187
188    class Provider: public AudioBufferProvider {
189        int16_t* mAddr;
190        size_t mNumFrames;
191    public:
192        Provider(const void* addr, size_t size, int channels) {
193            mAddr = (int16_t*) addr;
194            mNumFrames = size / (channels*sizeof(int16_t));
195        }
196        virtual status_t getNextBuffer(Buffer* buffer,
197                int64_t pts = kInvalidPTS) {
198            buffer->frameCount = mNumFrames;
199            buffer->i16 = mAddr;
200            return NO_ERROR;
201        }
202        virtual void releaseBuffer(Buffer* buffer) {
203        }
204    } provider(input_vaddr, input_size, channels);
205
206    size_t input_frames = input_size / (channels * sizeof(int16_t));
207    size_t output_size = 2 * 4 * ((int64_t) input_frames * output_freq) / input_freq;
208    output_size &= ~7; // always stereo, 32-bits
209
210    void* output_vaddr = malloc(output_size);
211
212    if (profiling) {
213        AudioResampler* resampler = AudioResampler::create(16, channels,
214                output_freq, quality);
215
216        size_t out_frames = output_size/8;
217        resampler->setSampleRate(input_freq);
218        resampler->setVolume(0x1000, 0x1000);
219
220        memset(output_vaddr, 0, output_size);
221        timespec start, end;
222        clock_gettime(CLOCK_MONOTONIC_HR, &start);
223        resampler->resample((int*) output_vaddr, out_frames, &provider);
224        resampler->resample((int*) output_vaddr, out_frames, &provider);
225        resampler->resample((int*) output_vaddr, out_frames, &provider);
226        resampler->resample((int*) output_vaddr, out_frames, &provider);
227        clock_gettime(CLOCK_MONOTONIC_HR, &end);
228        int64_t start_ns = start.tv_sec * 1000000000LL + start.tv_nsec;
229        int64_t end_ns = end.tv_sec * 1000000000LL + end.tv_nsec;
230        int64_t time = (end_ns - start_ns)/4;
231        printf("%f Mspl/s\n", out_frames/(time/1e9)/1e6);
232
233        delete resampler;
234    }
235
236    AudioResampler* resampler = AudioResampler::create(16, channels,
237            output_freq, quality);
238    size_t out_frames = output_size/8;
239    resampler->setSampleRate(input_freq);
240    resampler->setVolume(0x1000, 0x1000);
241
242    memset(output_vaddr, 0, output_size);
243    resampler->resample((int*) output_vaddr, out_frames, &provider);
244
245    // down-mix (we just truncate and keep the left channel)
246    int32_t* out = (int32_t*) output_vaddr;
247    int16_t* convert = (int16_t*) malloc(out_frames * channels * sizeof(int16_t));
248    for (size_t i = 0; i < out_frames; i++) {
249        for (int j=0 ; j<channels ; j++) {
250            int32_t s = out[i * 2 + j] >> 12;
251            if (s > 32767)       s =  32767;
252            else if (s < -32768) s = -32768;
253            convert[i * channels + j] = int16_t(s);
254        }
255    }
256
257    // write output to disk
258    int output_fd = open(file_out, O_WRONLY | O_CREAT | O_TRUNC,
259            S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
260    if (output_fd < 0) {
261        fprintf(stderr, "open: %s\n", strerror(errno));
262        return -1;
263    }
264
265    if (writeHeader) {
266        HeaderWav wav(out_frames * channels * sizeof(int16_t), channels, output_freq, 16);
267        write(output_fd, &wav, sizeof(wav));
268    }
269
270    write(output_fd, convert, out_frames * channels * sizeof(int16_t));
271    close(output_fd);
272
273    return 0;
274}
275