From fb64fbfef421ec8c339f2bef4086379be8dd3ff0 Mon Sep 17 00:00:00 2001 From: pschatzmann Date: Wed, 25 Oct 2023 15:18:06 +0000 Subject: [PATCH] =?UTF-8?q?Deploying=20to=20doxygen=20from=20@=20pschatzma?= =?UTF-8?q?nn/arduino-audio-tools@e9d6580db3f474d24df70d65ea6f79254b62e660?= =?UTF-8?q?=20=F0=9F=9A=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- _i2_s_config_std_8h_source.html | 72 +++-- _i2_s_r_p2040_8h_source.html | 549 ++++++++++++++++---------------- 2 files changed, 313 insertions(+), 308 deletions(-) diff --git a/_i2_s_config_std_8h_source.html b/_i2_s_config_std_8h_source.html index 4ed3936490..dd04a52ac2 100644 --- a/_i2_s_config_std_8h_source.html +++ b/_i2_s_config_std_8h_source.html @@ -122,40 +122,44 @@
60  int buffer_count = I2S_BUFFER_COUNT;
61  int buffer_size = I2S_BUFFER_SIZE;
62 
-
63 #if defined(USE_ALT_PIN_SUPPORT)
-
64  bool is_arduino_pin_numbers = true;
-
65 #endif
-
66 
-
67  void logInfo(const char* source=nullptr) {
-
68  AudioInfo::logInfo(source);
-
69  LOGI("rx/tx mode: %s", RxTxModeNames[rx_tx_mode]);
-
70  //LOGI("port_no: %d", port_no);
-
71  LOGI("is_master: %s", is_master ? "Master":"Slave");
-
72  LOGI("sample rate: %d", sample_rate);
-
73  LOGI("bits per sample: %d", bits_per_sample);
-
74  LOGI("number of channels: %d", channels);
-
75  LOGI("i2s_format: %s", i2s_formats[i2s_format]);
-
76  LOGI("buffer_count:%d",buffer_count);
-
77  LOGI("buffer_size:%d",buffer_size);
-
78  if (pin_mck!=-1)
-
79  LOGI("pin_mck: %d", pin_mck);
-
80  if (pin_bck!=-1)
-
81  LOGI("pin_bck: %d", pin_bck);
-
82  if (pin_ws!=-1)
-
83  LOGI("pin_ws: %d", pin_ws);
-
84  if (pin_data!=-1)
-
85  LOGI("pin_data: %d", pin_data);
-
86  if (pin_data_rx!=-1 && rx_tx_mode==RXTX_MODE){
-
87  LOGI("pin_data_rx: %d", pin_data_rx);
-
88  }
-
89  }
-
90 
-
91 };
-
92 
-
93 using I2SConfig = I2SConfigStd;
-
94 
-
95 }
-
96 
+
63 #if defined(RP2040_HOWER)
+
65  int mck_multiplier = 64;
+
66 #endif
+
67 
+
68 #if defined(USE_ALT_PIN_SUPPORT)
+
69  bool is_arduino_pin_numbers = true;
+
70 #endif
+
71 
+
72  void logInfo(const char* source=nullptr) {
+
73  AudioInfo::logInfo(source);
+
74  LOGI("rx/tx mode: %s", RxTxModeNames[rx_tx_mode]);
+
75  //LOGI("port_no: %d", port_no);
+
76  LOGI("is_master: %s", is_master ? "Master":"Slave");
+
77  LOGI("sample rate: %d", sample_rate);
+
78  LOGI("bits per sample: %d", bits_per_sample);
+
79  LOGI("number of channels: %d", channels);
+
80  LOGI("i2s_format: %s", i2s_formats[i2s_format]);
+
81  LOGI("buffer_count:%d",buffer_count);
+
82  LOGI("buffer_size:%d",buffer_size);
+
83  if (pin_mck!=-1)
+
84  LOGI("pin_mck: %d", pin_mck);
+
85  if (pin_bck!=-1)
+
86  LOGI("pin_bck: %d", pin_bck);
+
87  if (pin_ws!=-1)
+
88  LOGI("pin_ws: %d", pin_ws);
+
89  if (pin_data!=-1)
+
90  LOGI("pin_data: %d", pin_data);
+
91  if (pin_data_rx!=-1 && rx_tx_mode==RXTX_MODE){
+
92  LOGI("pin_data_rx: %d", pin_data_rx);
+
93  }
+
94  }
+
95 
+
96 };
+
97 
+
98 using I2SConfig = I2SConfigStd;
+
99 
+
100 }
+
101 
audio_tools::I2SConfigStd
Configuration for i2s.
Definition: I2SConfigStd.h:17
audio_tools::I2SConfigStd::rx_tx_mode
RxTxMode rx_tx_mode
public settings
Definition: I2SConfigStd.h:50
audio_tools::I2SConfigStd::I2SConfigStd
I2SConfigStd(const I2SConfigStd &cfg)=default
Default Copy Constructor.
diff --git a/_i2_s_r_p2040_8h_source.html b/_i2_s_r_p2040_8h_source.html index ff2d473318..dbcb01c26e 100644 --- a/_i2_s_r_p2040_8h_source.html +++ b/_i2_s_r_p2040_8h_source.html @@ -130,282 +130,283 @@
69  return false;
70  }
71  if (cfg.pin_mck != -1){
-
72  if (!i2s.setMCLK(cfg.pin_mck)){
-
73  LOGE("Could not set data pin: %d", cfg.pin_mck);
-
74  return false;
-
75  }
-
76  }
-
77 
-
78  if (cfg.bits_per_sample==8 || !i2s.setBitsPerSample(cfg.bits_per_sample)){
-
79  LOGE("Could not set bits per sample: %d", cfg.bits_per_sample);
-
80  return false;
-
81  }
-
82 
-
83  if (!i2s.setBuffers(cfg.buffer_count, cfg.buffer_size)){
-
84  LOGE("Could not set buffers: Count: '%d', size: '%d'", cfg.buffer_count, cfg.buffer_size);
-
85  return false;
-
86  }
-
87 
-
88  // setup format
-
89  if(cfg.i2s_format == I2S_STD_FORMAT || cfg.i2s_format == I2S_PHILIPS_FORMAT){
-
90  // default setting: do nothing
-
91  } else if(cfg.i2s_format == I2S_LEFT_JUSTIFIED_FORMAT || cfg.i2s_format==I2S_LSB_FORMAT){
-
92  if(!i2s.setLSBJFormat()){
-
93  LOGE("Could not set LSB Format")
-
94  return false;
-
95  }
-
96  } else {
-
97  LOGE("Unsupported I2S format");
-
98  return false;
-
99  }
-
100 
-
101  if (cfg.channels < 1 || cfg.channels > 2 ){
-
102  LOGE("Unsupported channels: '%d'", cfg.channels);
-
103  return false;
-
104  }
-
105 
-
106  if (!i2s.begin(cfg.sample_rate)){
-
107  LOGE("Could not start I2S");
-
108  return false;
-
109  }
-
110  return true;
-
111  }
-
112 
-
114  void end() {
-
115  flush();
-
116  i2s.end();
-
117  }
-
118 
-
120  I2SConfigStd config() {
-
121  return cfg;
-
122  }
-
123 
-
125  size_t writeBytes(const void *src, size_t size_bytes) {
-
126  LOGD("writeBytes(%d)", size_bytes);
-
127  size_t result = 0;
-
128 
-
129  if (cfg.channels==1){
-
130  result = writeExpandChannel(src, size_bytes);
-
131  } else if (cfg.channels==2){
-
132  const uint8_t *p = (const uint8_t*) src;
-
133  while(size_bytes >= sizeof(int32_t)){
-
134  bool justWritten = i2s.write(*(int32_t*)p,true); //I2S::write(int32,bool) actually only returns 0 or 1
-
135  if(justWritten){
-
136  size_bytes -= sizeof(int32_t);
-
137  p += sizeof(int32_t);
-
138  result += sizeof(int32_t);
-
139  } else return result;
-
140  }
-
141  }
-
142  return result;
-
143  }
-
144 
-
145  size_t readBytes(void *dest, size_t size_bytes) {
-
146  TRACED();
-
147  switch(cfg.channels){
-
148  case 1:
-
149  return read1Channel(dest, size_bytes);
-
150  case 2:
-
151  return read2Channels(dest, size_bytes);
-
152  }
-
153  return 0;
-
154  }
-
155 
-
156  int availableForWrite() {
-
157  if (cfg.channels == 1){
-
158  return cfg.buffer_size;
-
159  } else {
-
160  return i2s.availableForWrite();
-
161  }
-
162  }
-
163 
-
164  int available() {
-
165  return min(i2s.available(), cfg.buffer_size);
-
166  }
-
167 
-
168  void flush() {
-
169  i2s.flush();
-
170  }
-
171 
-
172  protected:
-
173  I2SConfigStd cfg;
-
174  I2S i2s;
-
175  bool has_input[2];
-
176 
-
178  //returns amount of bytes written from src to i2s
-
179  size_t writeExpandChannel(const void *src, size_t size_bytes) {
-
180  switch(cfg.bits_per_sample){
-
181  // case 8: {
-
182  // int8_t *pt8 = (int8_t*) src;
-
183  // int16_t sample16 = static_cast<int16_t>(*pt8) << 8;
-
184  // for (int j=0;j<size_bytes;j++){
-
185  // // 8 bit does not work
-
186  // i2s.write8(pt8[j], pt8[j]);
-
187  // //LOGI("%d", pt8[j]);
-
188  // }
-
189  // } break;
-
190  case 16: {
-
191  int16_t *pt16 = (int16_t*) src;
-
192  for (int j=0;j<size_bytes/sizeof(int16_t);j++){
-
193  i2s.write16(pt16[j], pt16[j]);
-
194  }
-
195  } break;
-
196  case 24: {
-
197  int32_t *pt24 = (int32_t*) src;
-
198  for (int j=0;j<size_bytes/sizeof(int32_t);j++){
-
199  i2s.write24(pt24[j], pt24[j]);
-
200  }
-
201  } break;
-
202  case 32:{
-
203  int32_t *pt32 = (int32_t*) src;
-
204  for (int j=0;j<size_bytes/sizeof(int32_t);j++){
-
205  i2s.write32(pt32[j], pt32[j]);
-
206  }
-
207  } break;
-
208  }
-
209  return size_bytes;
-
210  }
-
211 
-
213  size_t read2Channels(void *dest, size_t size_bytes) {
-
214  TRACED();
-
215  size_t result = 0;
-
216  switch(cfg.bits_per_sample){
-
217  // case 8:{
-
218  // int8_t *data = (int8_t*)dest;
-
219  // for (int j=0;j<size_bytes;j+=2){
-
220  // if (i2s.read8(data+j, data+j+1)){
-
221  // result+=2;;
-
222  // } else {
-
223  // return result;
-
224  // }
-
225  // }
-
226  // }break;
-
227 
-
228  case 16:{
-
229  int16_t *data = (int16_t *)dest;
-
230  for (int j=0;j<size_bytes/sizeof(int16_t);j+=2){
-
231  if (i2s.read16(data+j, data+j+1)){
-
232  result+=4;
-
233  } else {
-
234  return result;
-
235  }
-
236  }
-
237  }break;
-
238 
-
239  case 24:{
-
240  int32_t *data = (int32_t *)dest;
-
241  for (int j=0;j<size_bytes/sizeof(int32_t);j+=2){
-
242  if (i2s.read24(data+j, data+j+1)){
-
243  result+=8;
-
244  } else {
-
245  return result;
-
246  }
-
247  }
-
248  }break;
-
249 
-
250  case 32:{
-
251  int32_t *data = (int32_t *)dest;
-
252  for (int j=0;j<size_bytes/sizeof(int32_t);j+=2){
-
253  if (i2s.read32(data+j, data+j+1)){
-
254  result+=8;
-
255  } else {
-
256  return result;
-
257  }
-
258  }
-
259 
-
260  }break;
-
261  }
-
262  return result;
-
263  }
-
264 
-
266  size_t read1Channel(void *dest, size_t size_bytes) {
-
267  TRACED();
-
268  size_t result = 0;
-
269  switch(cfg.bits_per_sample){
-
270  // case 8:{
-
271  // int8_t tmp[2];
-
272  // int8_t *data = (int8_t*)dest;
-
273  // for (int j=0;j<size_bytes;j++){
-
274  // if (i2s.read8(tmp, tmp+1)){
-
275  // data[j] = mix(tmp[0], tmp[1]);
-
276  // result++;;
-
277  // } else {
-
278  // return result;
-
279  // }
-
280  // }
-
281  // }break;
-
282 
-
283  case 16:{
-
284  int16_t tmp[2];
-
285  int16_t *data = (int16_t*)dest;
-
286  for (int j=0;j<size_bytes/sizeof(int16_t);j++){
-
287  if (i2s.read16(tmp, tmp+1)){
-
288  data[j] = mix(tmp[0], tmp[1]);
-
289  result+=2;
-
290  } else {
-
291  return result;
-
292  }
-
293  }
-
294  }break;
-
295 
-
296  case 24:{
-
297  int32_t tmp[2];
-
298  int32_t *data = (int32_t*)dest;
-
299  for (int j=0;j<size_bytes/sizeof(int32_t);j++){
-
300  if (i2s.read24(tmp, tmp+1)){
-
301  data[j] = mix(tmp[0],tmp[1]);
-
302  result+=4;
-
303  } else {
-
304  return result;
-
305  }
-
306  }
-
307  }break;
-
308 
-
309  case 32:{
-
310  int32_t tmp[2];
-
311  int32_t *data = (int32_t*)dest;
-
312  for (int j=0;j<size_bytes/sizeof(int32_t);j++){
-
313  if (i2s.read32(tmp, tmp+1)){
-
314  data[j] = mix(tmp[0],tmp[1]);
-
315  result+=4;
-
316  } else {
-
317  return result;
-
318  }
-
319  }
-
320  }break;
-
321  }
-
322  return result;
-
323  }
-
324 
-
325  // we just provide the avg of both samples
-
326  template <class T>
-
327  T mix (T left, T right) {
-
328  if (left!=0) has_input[0]=true;
-
329  if (right!=0) has_input[1]=true;
-
330 
-
331  // if right is always empty we return left
-
332  if (has_input[0]&&!has_input[1]){
-
333  return left;
-
334  }
-
335 
-
336  // if left is always empty we return right
-
337  if (!has_input[0]&&has_input[1]){
-
338  return right;
-
339  }
-
340 
-
341  return (left/2) + (right/2);
-
342 
-
343  }
-
344 
+
72  i2s.setMCLKmult(cfg.mck_multiplier);
+
73  if (!i2s.setMCLK(cfg.pin_mck)){
+
74  LOGE("Could not set data pin: %d", cfg.pin_mck);
+
75  return false;
+
76  }
+
77  }
+
78 
+
79  if (cfg.bits_per_sample==8 || !i2s.setBitsPerSample(cfg.bits_per_sample)){
+
80  LOGE("Could not set bits per sample: %d", cfg.bits_per_sample);
+
81  return false;
+
82  }
+
83 
+
84  if (!i2s.setBuffers(cfg.buffer_count, cfg.buffer_size)){
+
85  LOGE("Could not set buffers: Count: '%d', size: '%d'", cfg.buffer_count, cfg.buffer_size);
+
86  return false;
+
87  }
+
88 
+
89  // setup format
+
90  if(cfg.i2s_format == I2S_STD_FORMAT || cfg.i2s_format == I2S_PHILIPS_FORMAT){
+
91  // default setting: do nothing
+
92  } else if(cfg.i2s_format == I2S_LEFT_JUSTIFIED_FORMAT || cfg.i2s_format==I2S_LSB_FORMAT){
+
93  if(!i2s.setLSBJFormat()){
+
94  LOGE("Could not set LSB Format")
+
95  return false;
+
96  }
+
97  } else {
+
98  LOGE("Unsupported I2S format");
+
99  return false;
+
100  }
+
101 
+
102  if (cfg.channels < 1 || cfg.channels > 2 ){
+
103  LOGE("Unsupported channels: '%d'", cfg.channels);
+
104  return false;
+
105  }
+
106 
+
107  if (!i2s.begin(cfg.sample_rate)){
+
108  LOGE("Could not start I2S");
+
109  return false;
+
110  }
+
111  return true;
+
112  }
+
113 
+
115  void end() {
+
116  flush();
+
117  i2s.end();
+
118  }
+
119 
+
121  I2SConfigStd config() {
+
122  return cfg;
+
123  }
+
124 
+
126  size_t writeBytes(const void *src, size_t size_bytes) {
+
127  LOGD("writeBytes(%d)", size_bytes);
+
128  size_t result = 0;
+
129 
+
130  if (cfg.channels==1){
+
131  result = writeExpandChannel(src, size_bytes);
+
132  } else if (cfg.channels==2){
+
133  const uint8_t *p = (const uint8_t*) src;
+
134  while(size_bytes >= sizeof(int32_t)){
+
135  bool justWritten = i2s.write(*(int32_t*)p,true); //I2S::write(int32,bool) actually only returns 0 or 1
+
136  if(justWritten){
+
137  size_bytes -= sizeof(int32_t);
+
138  p += sizeof(int32_t);
+
139  result += sizeof(int32_t);
+
140  } else return result;
+
141  }
+
142  }
+
143  return result;
+
144  }
+
145 
+
146  size_t readBytes(void *dest, size_t size_bytes) {
+
147  TRACED();
+
148  switch(cfg.channels){
+
149  case 1:
+
150  return read1Channel(dest, size_bytes);
+
151  case 2:
+
152  return read2Channels(dest, size_bytes);
+
153  }
+
154  return 0;
+
155  }
+
156 
+
157  int availableForWrite() {
+
158  if (cfg.channels == 1){
+
159  return cfg.buffer_size;
+
160  } else {
+
161  return i2s.availableForWrite();
+
162  }
+
163  }
+
164 
+
165  int available() {
+
166  return min(i2s.available(), cfg.buffer_size);
+
167  }
+
168 
+
169  void flush() {
+
170  i2s.flush();
+
171  }
+
172 
+
173  protected:
+
174  I2SConfigStd cfg;
+
175  I2S i2s;
+
176  bool has_input[2];
+
177 
+
179  //returns amount of bytes written from src to i2s
+
180  size_t writeExpandChannel(const void *src, size_t size_bytes) {
+
181  switch(cfg.bits_per_sample){
+
182  // case 8: {
+
183  // int8_t *pt8 = (int8_t*) src;
+
184  // int16_t sample16 = static_cast<int16_t>(*pt8) << 8;
+
185  // for (int j=0;j<size_bytes;j++){
+
186  // // 8 bit does not work
+
187  // i2s.write8(pt8[j], pt8[j]);
+
188  // //LOGI("%d", pt8[j]);
+
189  // }
+
190  // } break;
+
191  case 16: {
+
192  int16_t *pt16 = (int16_t*) src;
+
193  for (int j=0;j<size_bytes/sizeof(int16_t);j++){
+
194  i2s.write16(pt16[j], pt16[j]);
+
195  }
+
196  } break;
+
197  case 24: {
+
198  int32_t *pt24 = (int32_t*) src;
+
199  for (int j=0;j<size_bytes/sizeof(int32_t);j++){
+
200  i2s.write24(pt24[j], pt24[j]);
+
201  }
+
202  } break;
+
203  case 32:{
+
204  int32_t *pt32 = (int32_t*) src;
+
205  for (int j=0;j<size_bytes/sizeof(int32_t);j++){
+
206  i2s.write32(pt32[j], pt32[j]);
+
207  }
+
208  } break;
+
209  }
+
210  return size_bytes;
+
211  }
+
212 
+
214  size_t read2Channels(void *dest, size_t size_bytes) {
+
215  TRACED();
+
216  size_t result = 0;
+
217  switch(cfg.bits_per_sample){
+
218  // case 8:{
+
219  // int8_t *data = (int8_t*)dest;
+
220  // for (int j=0;j<size_bytes;j+=2){
+
221  // if (i2s.read8(data+j, data+j+1)){
+
222  // result+=2;;
+
223  // } else {
+
224  // return result;
+
225  // }
+
226  // }
+
227  // }break;
+
228 
+
229  case 16:{
+
230  int16_t *data = (int16_t *)dest;
+
231  for (int j=0;j<size_bytes/sizeof(int16_t);j+=2){
+
232  if (i2s.read16(data+j, data+j+1)){
+
233  result+=4;
+
234  } else {
+
235  return result;
+
236  }
+
237  }
+
238  }break;
+
239 
+
240  case 24:{
+
241  int32_t *data = (int32_t *)dest;
+
242  for (int j=0;j<size_bytes/sizeof(int32_t);j+=2){
+
243  if (i2s.read24(data+j, data+j+1)){
+
244  result+=8;
+
245  } else {
+
246  return result;
+
247  }
+
248  }
+
249  }break;
+
250 
+
251  case 32:{
+
252  int32_t *data = (int32_t *)dest;
+
253  for (int j=0;j<size_bytes/sizeof(int32_t);j+=2){
+
254  if (i2s.read32(data+j, data+j+1)){
+
255  result+=8;
+
256  } else {
+
257  return result;
+
258  }
+
259  }
+
260 
+
261  }break;
+
262  }
+
263  return result;
+
264  }
+
265 
+
267  size_t read1Channel(void *dest, size_t size_bytes) {
+
268  TRACED();
+
269  size_t result = 0;
+
270  switch(cfg.bits_per_sample){
+
271  // case 8:{
+
272  // int8_t tmp[2];
+
273  // int8_t *data = (int8_t*)dest;
+
274  // for (int j=0;j<size_bytes;j++){
+
275  // if (i2s.read8(tmp, tmp+1)){
+
276  // data[j] = mix(tmp[0], tmp[1]);
+
277  // result++;;
+
278  // } else {
+
279  // return result;
+
280  // }
+
281  // }
+
282  // }break;
+
283 
+
284  case 16:{
+
285  int16_t tmp[2];
+
286  int16_t *data = (int16_t*)dest;
+
287  for (int j=0;j<size_bytes/sizeof(int16_t);j++){
+
288  if (i2s.read16(tmp, tmp+1)){
+
289  data[j] = mix(tmp[0], tmp[1]);
+
290  result+=2;
+
291  } else {
+
292  return result;
+
293  }
+
294  }
+
295  }break;
+
296 
+
297  case 24:{
+
298  int32_t tmp[2];
+
299  int32_t *data = (int32_t*)dest;
+
300  for (int j=0;j<size_bytes/sizeof(int32_t);j++){
+
301  if (i2s.read24(tmp, tmp+1)){
+
302  data[j] = mix(tmp[0],tmp[1]);
+
303  result+=4;
+
304  } else {
+
305  return result;
+
306  }
+
307  }
+
308  }break;
+
309 
+
310  case 32:{
+
311  int32_t tmp[2];
+
312  int32_t *data = (int32_t*)dest;
+
313  for (int j=0;j<size_bytes/sizeof(int32_t);j++){
+
314  if (i2s.read32(tmp, tmp+1)){
+
315  data[j] = mix(tmp[0],tmp[1]);
+
316  result+=4;
+
317  } else {
+
318  return result;
+
319  }
+
320  }
+
321  }break;
+
322  }
+
323  return result;
+
324  }
+
325 
+
326  // we just provide the avg of both samples
+
327  template <class T>
+
328  T mix (T left, T right) {
+
329  if (left!=0) has_input[0]=true;
+
330  if (right!=0) has_input[1]=true;
+
331 
+
332  // if right is always empty we return left
+
333  if (has_input[0]&&!has_input[1]){
+
334  return left;
+
335  }
+
336 
+
337  // if left is always empty we return right
+
338  if (!has_input[0]&&has_input[1]){
+
339  return right;
+
340  }
+
341 
+
342  return (left/2) + (right/2);
+
343 
+
344  }
345 
-
346 };
-
347 
-
348 using I2SDriver = I2SDriverRP2040;
-
349 
+
346 
+
347 };
+
348 
+
349 using I2SDriver = I2SDriverRP2040;
350 
-
351 }
-
352 
-
353 #endif
+
351 
+
352 }
+
353 
+
354 #endif
audio_tools::RxTxMode
RxTxMode
Audio Source (TX_MODE) or Audio Sink (RX_MODE). RXTX_MODE is Source and Sink at the same time!
Definition: AudioTypes.h:24
audio_tools
Generic Implementation of sound input and output for desktop environments using portaudio.
Definition: AnalogAudio.h:10