1 /*
2  * Copyright (C) 2016 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 #ifndef ANDROID_AUDIO_BUFLOG_H
18 #define ANDROID_AUDIO_BUFLOG_H
19 
20 /*
21  * BUFLOG creates up to BUFLOG_MAXSTREAMS simultaneous streams [0:15] of audio buffer data
22  * and saves them to disk. The files are stored in the path specified in BUFLOG_BASE_PATH and
23  * are named following this format:
24  *   YYYYMMDDHHMMSS_id_format_channels_samplingrate.raw
25  *
26  * Normally we strip BUFLOG dumps from release builds.
27  * You can modify this (for example with "#define BUFLOG_NDEBUG 0"
28  * at the top of your source file) to change that behavior.
29  *
30  * usage:
31  * - Add this to the top of the source file you want to debug:
32  *   #define BUFLOG_NDEBUG 0
33  *   #include "BufLog.h"
34  *
35  * - dump an audio buffer
36  *  BUFLOG(buff_id, buff_tag, format, channels, sampling_rate, max_bytes, buff_pointer, buff_size);
37  *
38  *  buff_id:   int [0:15]   buffer id. If a buffer doesn't exist, it is created the first time.
39  *  buff_tag:  char*        string tag used on stream filename and logs
40  *  format:    int          Audio format (audio_format_t see audio.h)
41  *  channels:  int          Channel Count
42  *  sampling_rate:  int     Sampling rate in Hz. e.g. 8000, 16000, 44100, 48000, etc
43  *  max_bytes: int [0 or positive number]
44  *                          Maximum size of the file (in bytes) to be output.
45  *                          If the value is 0, no limit.
46  *  buff_pointer: void *    Pointer to audio buffer.
47  *  buff_size:  int         Size (in bytes) of the current audio buffer to be stored.
48  *
49  *
50  *  Example usage:
51  *    int format       = mConfig.outputCfg.format;
52  *    int channels     = audio_channel_count_from_out_mask(mConfig.outputCfg.channels);
53  *    int samplingRate = mConfig.outputCfg.samplingRate;
54  *    int frameCount   = mConfig.outputCfg.buffer.frameCount;
55  *    int frameSize    = audio_bytes_per_sample((audio_format_t)format) * channels;
56  *    int buffSize     = frameCount * frameSize;
57  *    long maxBytes = 10 * samplingRate * frameSize; //10 seconds max
58  *  BUFLOG(11, "loudnes_enhancer_out", format, channels, samplingRate, maxBytes,
59  *                               mConfig.outputCfg.buffer.raw, buffSize);
60  *
61  *  Other macros:
62  *  BUFLOG_EXISTS       returns true if there is an instance of BufLog
63  *
64  *  BUFLOG_RESET        If an instance of BufLog exists, it stops the capture and closes all
65  *                      streams.
66  *                      If a new call to BUFLOG(..) is done, new streams are created.
67  */
68 
69 #ifndef BUFLOG_NDEBUG
70 #ifdef NDEBUG
71 #define BUFLOG_NDEBUG 1
72 #else
73 #define BUFLOG_NDEBUG 0
74 #endif
75 #endif
76 
77 /*
78  * Simplified macro to send a buffer.
79  */
80 #ifndef BUFLOG
81 #define __BUFLOG(STREAMID, TAG, FORMAT, CHANNELS, SAMPLINGRATE, MAXBYTES, BUF, SIZE) \
82     BufLogSingleton::instance()->write(STREAMID, TAG, FORMAT, CHANNELS, SAMPLINGRATE, MAXBYTES, \
83             BUF, SIZE)
84 #if BUFLOG_NDEBUG
85 #define BUFLOG(STREAMID, TAG, FORMAT, CHANNELS, SAMPLINGRATE, MAXBYTES, BUF, SIZE) \
86     do { if (0) {  } } while (0)
87 #else
88 #define BUFLOG(STREAMID, TAG, FORMAT, CHANNELS, SAMPLINGRATE, MAXBYTES, BUF, SIZE) \
89     __BUFLOG(STREAMID, TAG, FORMAT, CHANNELS, SAMPLINGRATE, MAXBYTES, BUF, SIZE)
90 #endif
91 #endif
92 
93 #ifndef BUFLOG_EXISTS
94 #define BUFLOG_EXISTS BufLogSingleton::instanceExists()
95 #endif
96 
97 #ifndef BUFLOG_RESET
98 #define BUFLOG_RESET do { if (BufLogSingleton::instanceExists()) { \
99     BufLogSingleton::instance()->reset(); } } while (0)
100 #endif
101 
102 
103 #include <stdint.h>
104 #include <stdio.h>
105 #include <sys/types.h>
106 #include <utils/Mutex.h>
107 
108 //BufLog configuration
109 #define BUFLOGSTREAM_MAX_TAGSIZE    32
110 #define BUFLOG_BASE_PATH            "/data/misc/audioserver"
111 #define BUFLOG_MAX_PATH_SIZE        300
112 
113 class BufLogStream {
114 public:
115     BufLogStream(unsigned int id,
116             const char *tag,
117             unsigned int format,
118             unsigned int channels,
119             unsigned int samplingRate,
120             size_t maxBytes);
121     ~BufLogStream();
122 
123     // write buffer to stream
124     //  buf:  pointer to buffer
125     //  size: number of bytes to write
126     size_t          write(const void *buf, size_t size);
127 
128     // pause/resume stream
129     //  pause: true = paused, false = not paused
130     //  return value: previous state of stream (paused or not).
131     bool            setPause(bool pause);
132 
133     // will stop the stream and close any open file
134     // the stream can't be reopen. Instead, a new stream (and file) should be created.
135     void            finalize();
136 
137 private:
138     bool                mPaused;
139     const unsigned int  mId;
140     char                mTag[BUFLOGSTREAM_MAX_TAGSIZE + 1];
141     const unsigned int  mFormat;
142     const unsigned int  mChannels;
143     const unsigned int  mSamplingRate;
144     const size_t        mMaxBytes;
145     size_t              mByteCount;
146     FILE                *mFile;
147     mutable android::Mutex mLock;
148 
149     void            closeStream_l();
150 };
151 
152 
153 class BufLog {
154 public:
155     BufLog();
156     ~BufLog();
BufLog(BufLog const &)157     BufLog(BufLog const&) {};
158 
159     //  streamid:      int [0:BUFLOG_MAXSTREAMS-1]   buffer id.
160     //                  If a buffer doesn't exist, it is created the first time is referenced
161     //  tag:           char*  string tag used on stream filename and logs
162     //  format:        int Audio format (audio_format_t see audio.h)
163     //  channels:      int          Channel Count
164     //  samplingRate:  int Sampling rate in Hz. e.g. 8000, 16000, 44100, 48000, etc
165     //  maxBytes:      int [0 or positive number]
166     //                  Maximum size of the file (in bytes) to be output.
167     //                  If the value is 0, no limit.
168     //  size:          int Size (in bytes) of the current audio buffer to be written.
169     //  buf:           void *    Pointer to audio buffer.
170     size_t          write(int streamid,
171                         const char *tag,
172                         int format,
173                         int channels,
174                         int samplingRate,
175                         size_t maxBytes,
176                         const void *buf,
177                         size_t size);
178 
179     // reset will stop and close all active streams, thus finalizing any open file.
180     //  New streams will be created if write() is called again.
181     void            reset();
182 
183 protected:
184     static const unsigned int BUFLOG_MAXSTREAMS = 16;
185     BufLogStream    *mStreams[BUFLOG_MAXSTREAMS];
186     mutable android::Mutex mLock;
187 };
188 
189 class BufLogSingleton {
190 public:
191     static BufLog   *instance();
192     static bool     instanceExists();
193 
194 private:
195     static void     initOnce();
196     static BufLog   *mInstance;
197 };
198 
199 #endif //ANDROID_AUDIO_BUFLOG_H
200