AAX SDK  2.4.1
Avid Audio Extensions Development Kit
AAX_StringUtilities.hpp
Go to the documentation of this file.
1 /*================================================================================================*/
2 /*
3  * Copyright 2014-2017, 2019-2021 by Avid Technology, Inc.
4  * All rights reserved.
5  *
6  * CONFIDENTIAL: This document contains confidential information. Do not
7  * read or examine this document unless you are an Avid Technology employee
8  * or have signed a non-disclosure agreement with Avid Technology which protects
9  * the confidentiality of this document. DO NOT DISCLOSE ANY INFORMATION
10  * CONTAINED IN THIS DOCUMENT TO ANY THIRD-PARTY WITHOUT THE PRIOR WRITTEN CONSENT
11  * OF Avid Technology, INC.
12  */
13 /*================================================================================================*/
14 
15 #ifndef AAXLibrary_AAX_StringUtilities_hpp
16 #define AAXLibrary_AAX_StringUtilities_hpp
17 
18 #include "AAX_IString.h"
19 #include "AAX_Errors.h"
20 #include "AAX_Assert.h"
21 #include <stdlib.h>
22 
23 #include <algorithm>
24 #include <vector>
25 #include <string>
26 #include <cstring>
27 
28 //===========================================================================
29 //
30 // FloatToString: Convert the given floating point number to a pascal string.
31 //
32 //===========================================================================
33 /*
34 void FloatToString(float aNumber, StringPtr aString)
35 {
36  Str255 MantissaStr;
37  double aDouble;
38  StringPtr tempStr;
39  int32_t mantissa,tens,hundreds;
40  int16_t count;
41 
42  aDouble = (double) aNumber;
43  if (aNumber < 0.0) // take abs value
44  aDouble = -aDouble;
45 
46  aDouble += 0.005; // perform rounding by adding 1/2 of the hundreths digit
47 
48  mantissa = aDouble;
49  tens = (aDouble * 10.0) - (mantissa * 10.0);
50  hundreds = (aDouble * 100.0) - (mantissa * 100.0) - (tens * 10.0);
51 
52  NumToString(mantissa, MantissaStr);
53 
54  // set up string length
55  if (aNumber < 0.0)
56  *aString++ = (char) (1 + 3 + *MantissaStr);
57  else
58  *aString++ = (char) (3 + *MantissaStr);
59 
60  tempStr = MantissaStr;
61 
62  // copy mantissa first
63  count = *tempStr++;
64 
65  if (aNumber < 0.0)
66  *aString++ = '-';
67 
68  while (count--)
69  *aString++ = *tempStr++;
70 
71  *aString++ = '.';
72  *aString++ = (char) (tens + '0');
73  *aString++ = (char) (hundreds + '0');
74 }
75 */
76 
78 //
79 // GetCStringOfLength
80 //
81 // A routine for selecting a string based on the size passed in
82 // by the client. If none of the strings are short enough then
83 // the shortest string is truncated to fit.
84 //
85 // stringIn="A Very Nice String\nA String\nAStrng\nStr\n";
86 //
87 // Submitted from Erik Gavriluk of BombFactory (Free of Charge)
88 // Debugged and separator character changed by Frederick Umminger
89 //===============================================================
90 
91 void AAX::GetCStringOfLength(char *s_out, const char* s_in, int32_t aMaxChars)
92 {
93  AAX_ASSERT(0 < aMaxChars);
94 
95  const char kSeparator = '\n';
96 
97  if(s_in)
98  {
99  const char* s_begin = s_in;
100  const char* s_end = s_begin;
101  while(s_begin)
102  {
103  // Count characters in current substring
104  while((*s_end != kSeparator) && (*s_end != '\0'))
105  {
106  s_end++;
107  };
108 
109  // If substring is less than or equal to aMaxChars then use it.
110  if((s_end-s_begin <= aMaxChars) || (*s_end=='\0'))
111  {
112  break;
113  }
114 
115  s_begin = ++s_end;
116  }
117  // We don't use strncpy in order to make sure a '\0' gets put on the end of s_out
118  *s_out = '\0';
119  const int32_t length = int32_t(s_end-s_begin);
120  if (0 < length && 0 < aMaxChars)
121  {
122  std::strncat(s_out, s_begin, static_cast<std::size_t>(std::max<int32_t>(0, std::min<int32_t>(aMaxChars,length))));
123  }
124  }
125  else if (0 < aMaxChars)
126  {
127  strncpy(s_out, "", static_cast<size_t>(aMaxChars));
128  };
129 }
130 
131 int32_t AAX::Caseless_strcmp(const char* cs, const char* ct)
132 {
133  if(cs)
134  {
135  if(ct)
136  {
137  while(*cs && *ct)
138  {
139  int32_t cmp = toupper(*ct++) - toupper(*cs++);
140  if(cmp) return cmp;
141  };
142  if(*cs)
143  {
144  return -1;
145  }
146  else
147  {
148  if(*ct)
149  {
150  return 1;
151  }
152  else
153  {
154  return 0;
155  };
156  };
157  }
158  else
159  {
160  return -1;
161  };
162  }
163  else
164  {
165  if(ct)
166  return 1;
167  else
168  return 0;
169  }
170 
171 }
172 
173 
174 std::string AAX::Binary2String(uint32_t value, int32_t numBits)
175 {
176  std::string s;
177 
178  uint32_t currentBitMask = (static_cast<uint32_t>(0x1) << (numBits-1));
179 
180  while (currentBitMask != 0)
181  {
182  if (currentBitMask & value)
183  {
184  s += "1";
185  }
186  else
187  {
188  s += "0";
189  };
190  currentBitMask >>= 1;
191  }
192  return s;
193 }
194 
195 uint32_t AAX::String2Binary(const AAX_IString& s)
196 {
197  uint32_t value = 0;
198 
199  const char* const cS = s.Get();
200  int32_t length = int32_t(s.Length());
201  for(int32_t i = 0; i < length ; i++)
202  {
203  switch(cS[i])
204  {
205  case '0':
206  break;
207  case '1':
208  value |= (0x1 << (length-1-i));
209  break;
210  default:
211  AAX_ASSERT('0' == cS[i] || '1' == cS[i]);
212  };
213  };
214 
215  return value;
216 }
217 
218 bool AAX::IsASCII(char inChar)
219 {
220  return (0x20 <= inChar) && (0x7E >= inChar);
221 }
222 
223 bool AAX::IsFourCharASCII(uint32_t inFourChar)
224 {
225  const uint32_t oneCharMask = 0x000000FF;
226  const size_t oneCharNumBits = 8;
227 
228  bool result = true;
229  for (uint16_t i = 3; true == result /* i value checked within loop */; --i)
230  {
231  const char curChar = static_cast<const char>((inFourChar >> (i*oneCharNumBits)) & oneCharMask);
232  result = result && IsASCII(curChar);
233  if (0 == i) { break; }
234  }
235  return result;
236 }
237 
238 std::string AAX::AsStringFourChar(uint32_t inFourChar)
239 {
240  const uint32_t oneCharMask = 0x000000FF;
241  const int16_t oneCharNumBits = 8;
242  const std::string unknownChar = "(?)";
243 
244  std::string resultStr("");
245  for (int16_t i = 3; i >= 0; --i)
246  {
247  const char curChar = static_cast<char>((inFourChar >> (i*oneCharNumBits)) & oneCharMask);
248  resultStr += IsASCII(curChar) ? std::string(1, curChar) : unknownChar;
249  }
250  return resultStr;
251 }
252 
253 std::string AAX::AsStringPropertyValue(AAX_EProperty inProperty, AAX_CPropertyValue inPropertyValue)
254 {
255  // 63 characters should be plenty for any of the formats below, but
256  // increase this value if the formats are expanded in the future.
257  const size_t kBufferSize = 64;
258  char buffer[kBufferSize];
259 
260  // Attempt to infer a sensible way to print the property
261  if (AAX_eProperty_SampleRate == inProperty ||
262  AAX_eProperty_Constraint_Location == inProperty)
263  {
264  // Print specific properties' values as bitfield
265 
266  // We want the exact bits, so we memcpy to avoid any potential issues
267  // with casting from signed to unsigned
268  uint32_t bitfield;
269  memcpy(&bitfield, &inPropertyValue, sizeof(uint32_t));
270 
271  const int32_t maxNumBitsToShow = 8; // Currently there are no bitfield properties with more than 8 possible flags
272  sprintf(buffer, "%s", AAX::Binary2String(bitfield, maxNumBitsToShow).c_str());
273  }
274  else if (true == AAX::IsFourCharASCII(static_cast<uint32_t>(inPropertyValue)))
275  {
276  // Print values in ASCII range as four-char
277  sprintf(buffer, "'%s'", AAX::AsStringFourChar(static_cast<uint32_t>(inPropertyValue)).c_str());
278  }
279  else if (0x00FFFFFF < abs(inPropertyValue))
280  {
281  // Print values with most bits used as hex
282  sprintf(buffer, "%#x", inPropertyValue);
283  }
284  else
285  {
286  // Otherwise, print as simple decimal
287  sprintf(buffer, "%ld", (long int)inPropertyValue);
288  }
289 
290  buffer[kBufferSize-1] = '\0'; // Just in case
291  return std::string(buffer);
292 }
293 
294 std::string AAX::AsStringInt32(int32_t inInt32)
295 {
296  const size_t kBufferSize = 16;
297  char buffer[kBufferSize];
298  sprintf(buffer, "%ld", (long int)inInt32);
299  return std::string(buffer);
300 }
301 
302 std::string AAX::AsStringUInt32(uint32_t inUInt32)
303 {
304  const size_t kBufferSize = 16;
305  char buffer[kBufferSize];
306  sprintf(buffer, "%lu", (unsigned long)inUInt32);
307  return std::string(buffer);
308 }
309 
311 {
312  std::string result = "(";
313 
314  result += "man: '" + AAX::AsStringFourChar(inIDTriad.mManufacturerID) + "', ";
315  result += "prod: '" + AAX::AsStringFourChar(inIDTriad.mProductID) + "', ";
316  result += "type: '" + AAX::AsStringFourChar(inIDTriad.mPlugInID) + "'";
317 
318  result += ")";
319  return result;
320 }
321 
322 std::string AAX::AsStringStemFormat(AAX_EStemFormat inStemFormat, bool inAbbreviate)
323 {
324  switch (inStemFormat)
325  {
326  case AAX_eStemFormat_Mono: { return std::string("Mono"); break; }
327  case AAX_eStemFormat_Stereo: { return std::string(inAbbreviate ? "St" : "Stereo"); break; }
328  case AAX_eStemFormat_LCR: { return std::string("LCR"); break; }
329  case AAX_eStemFormat_LCRS: { return std::string("LCRS"); break; }
330  case AAX_eStemFormat_Quad: { return std::string("Quad"); break; }
331  case AAX_eStemFormat_5_0: { return std::string("5.0"); break; }
332  case AAX_eStemFormat_5_1: { return std::string("5.1"); break; }
333  case AAX_eStemFormat_6_0: { return std::string("6.0"); break; }
334  case AAX_eStemFormat_6_1: { return std::string("6.1"); break; }
335  case AAX_eStemFormat_7_0_SDDS: { return std::string(inAbbreviate ? "7.0 S" : "7.0 SDDS"); break; }
336  case AAX_eStemFormat_7_1_SDDS: { return std::string(inAbbreviate ? "7.1 S" : "7.1 SDDS"); break; }
337  case AAX_eStemFormat_7_0_DTS: { return std::string("7.0"); break; }
338  case AAX_eStemFormat_7_1_DTS: { return std::string("7.1"); break; }
339  case AAX_eStemFormat_7_0_2: {return std::string("7.0.2"); break; }
340  case AAX_eStemFormat_7_1_2: { return std::string("7.1.2"); break; }
341  case AAX_eStemFormat_Ambi_1_ACN: { return std::string(inAbbreviate ? "Amb1" : "Ambisonics (1st Order)"); break; }
342  case AAX_eStemFormat_Ambi_2_ACN: { return std::string(inAbbreviate ? "Amb2" : "Ambisonics (2nd Order)"); break; }
343  case AAX_eStemFormat_Ambi_3_ACN: { return std::string(inAbbreviate ? "Amb3" : "Ambisonics (3rd Order)"); break; }
344 
345  case AAX_eStemFormat_Reserved_1: { return std::string(inAbbreviate ? "Res1" : "Reserved (1)"); break; }
346  case AAX_eStemFormat_Reserved_2: { return std::string(inAbbreviate ? "Res2" : "Reserved (2)"); break; }
347  case AAX_eStemFormat_Reserved_3: { return std::string(inAbbreviate ? "Res3" : "Reserved (3)"); break; }
348 
349  case AAX_eStemFormat_None: { return std::string("None"); break; }
350  case AAX_eStemFormat_Any: { return std::string("Any"); break; }
351 
353  case AAX_eStemFormatNum:
354  default: { return std::string(inAbbreviate ? "unk" : "unknown stem format"); break; }
355  }
356 }
357 
358 std::string AAX::AsStringStemChannel(AAX_EStemFormat inStemFormat, uint32_t inChannelIndex, bool inAbbreviate)
359 {
360  switch (inStemFormat)
361  {
363  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "M" : "Audio"); }
364  break;
366  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "L" : "Left"); }
367  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "R" : "Right"); }
368  break;
369  case AAX_eStemFormat_LCR:
370  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "L" : "Left"); }
371  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "C" : "Center"); }
372  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "R" : "Right"); }
373  break;
375  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "L" : "Left"); }
376  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "C" : "Center"); }
377  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "R" : "Right"); }
378  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "S" : "Surround"); }
379  break;
381  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "L" : "Left"); }
382  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "R" : "Right"); }
383  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Ls" : "Left Surround"); }
384  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Rs" : "Right Surround"); }
385  break;
386  case AAX_eStemFormat_5_0:
387  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "L" : "Left"); }
388  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "C" : "Center"); }
389  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "R" : "Right"); }
390  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Ls" : "Left Surround"); }
391  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Rs" : "Right Surround"); }
392  break;
393  case AAX_eStemFormat_5_1:
394  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "L" : "Left"); }
395  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "C" : "Center"); }
396  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "R" : "Right"); }
397  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Ls" : "Left Surround"); }
398  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Rs" : "Right Surround"); }
399  if (0 == inChannelIndex--) { return std::string("LFE"); }
400  break;
401  case AAX_eStemFormat_6_0:
402  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "L" : "Left"); }
403  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "C" : "Center"); }
404  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "R" : "Right"); }
405  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Ls" : "Left Surround"); }
406  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Cs" : "Center Surround"); }
407  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Rs" : "Right Surround"); }
408  break;
409  case AAX_eStemFormat_6_1:
410  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "L" : "Left"); }
411  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "C" : "Center"); }
412  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "R" : "Right"); }
413  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Ls" : "Left Surround"); }
414  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Cs" : "Center Surround"); }
415  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Rs" : "Right Surround"); }
416  if (0 == inChannelIndex--) { return std::string("LFE"); }
417  break;
419  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "L" : "Left"); }
420  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Lc" : "Left Center"); }
421  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "C" : "Center"); }
422  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Rc" : "Right Center"); }
423  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "R" : "Right"); }
424  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Ls" : "Left Surround"); }
425  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Rs" : "Right Surround"); }
426  break;
428  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "L" : "Left"); }
429  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Lc" : "Left Center"); }
430  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "C" : "Center"); }
431  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Rc" : "Right Center"); }
432  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "R" : "Right"); }
433  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Ls" : "Left Surround"); }
434  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Rs" : "Right Surround"); }
435  if (0 == inChannelIndex--) { return std::string("LFE"); }
436  break;
438  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "L" : "Left"); }
439  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "C" : "Center"); }
440  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "R" : "Right"); }
441  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Lss" : "Left Surround Side"); }
442  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Rss" : "Right Surround Side"); }
443  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Lsr" : "Left Surround Rear"); }
444  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Rsr" : "Right Surround Rear"); }
445  break;
447  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "L" : "Left"); }
448  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "C" : "Center"); }
449  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "R" : "Right"); }
450  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Lss" : "Left Surround Side"); }
451  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Rss" : "Right Surround Side"); }
452  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Lsr" : "Left Surround Rear"); }
453  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Rsr" : "Right Surround Rear"); }
454  if (0 == inChannelIndex--) { return std::string("LFE"); }
455  break;
457  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "L" : "Left"); }
458  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "C" : "Center"); }
459  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "R" : "Right"); }
460  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Lss" : "Left Surround Side"); }
461  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Rss" : "Right Surround Side"); }
462  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Lsr" : "Left Surround Rear"); }
463  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Rsr" : "Right Surround Rear"); }
464  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "LTS" : "Left Top Surround"); }
465  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "RTS" : "Right Top Surround"); }
466  break;
468  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "L" : "Left"); }
469  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "C" : "Center"); }
470  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "R" : "Right"); }
471  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Lss" : "Left Surround Side"); }
472  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Rss" : "Right Surround Side"); }
473  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Lsr" : "Left Surround Rear"); }
474  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "Rsr" : "Right Surround Rear"); }
475  if (0 == inChannelIndex--) { return std::string("LFE"); }
476  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "LTS" : "Left Top Surround"); }
477  if (0 == inChannelIndex--) { return std::string(inAbbreviate ? "RTS" : "Right Top Surround"); }
478  break;
480  if (0 == inChannelIndex--) { return std::string("1"); }
481  if (0 == inChannelIndex--) { return std::string("2"); }
482  if (0 == inChannelIndex--) { return std::string("3"); }
483  if (0 == inChannelIndex--) { return std::string("4"); }
484  break;
486  if (0 == inChannelIndex--) { return std::string("1"); }
487  if (0 == inChannelIndex--) { return std::string("2"); }
488  if (0 == inChannelIndex--) { return std::string("3"); }
489  if (0 == inChannelIndex--) { return std::string("4"); }
490  if (0 == inChannelIndex--) { return std::string("5"); }
491  if (0 == inChannelIndex--) { return std::string("6"); }
492  if (0 == inChannelIndex--) { return std::string("7"); }
493  if (0 == inChannelIndex--) { return std::string("8"); }
494  if (0 == inChannelIndex--) { return std::string("9"); }
495  break;
497  if (0 == inChannelIndex--) { return std::string("1"); }
498  if (0 == inChannelIndex--) { return std::string("2"); }
499  if (0 == inChannelIndex--) { return std::string("3"); }
500  if (0 == inChannelIndex--) { return std::string("4"); }
501  if (0 == inChannelIndex--) { return std::string("5"); }
502  if (0 == inChannelIndex--) { return std::string("6"); }
503  if (0 == inChannelIndex--) { return std::string("7"); }
504  if (0 == inChannelIndex--) { return std::string("8"); }
505  if (0 == inChannelIndex--) { return std::string("9"); }
506  if (0 == inChannelIndex--) { return std::string("10"); }
507  if (0 == inChannelIndex--) { return std::string("11"); }
508  if (0 == inChannelIndex--) { return std::string("12"); }
509  if (0 == inChannelIndex--) { return std::string("13"); }
510  if (0 == inChannelIndex--) { return std::string("14"); }
511  if (0 == inChannelIndex--) { return std::string("15"); }
512  if (0 == inChannelIndex--) { return std::string("16"); }
513  break;
514 
516  break;
518  break;
520  break;
521 
523  break;
524  case AAX_eStemFormat_Any:
525  break;
526 
528  case AAX_eStemFormatNum:
529  default:
530  break;
531  }
532 
533  return std::string(inAbbreviate ? "?" : "unknown");
534 }
535 
536 std::string AAX::AsStringResult(AAX_Result inResult)
537 {
538 #ifdef DEFINE_AAX_ERROR_STRING
539 #undef DEFINE_AAX_ERROR_STRING
540 #endif
541 #define DEFINE_AAX_ERROR_STRING(X) if (X == inResult) { return std::string(#X); }
542 
590 
591  if (AAX_ERROR_PLUGIN_BEGIN >= inResult && AAX_ERROR_PLUGIN_END <= inResult)
592  return std::string("plug-in defined error");
593 
594  return std::string("<unknown error code>");
595 }
596 
597 #endif
int32_t AAX_Result
Definition: AAX.h:337
int32_t AAX_CPropertyValue
32-bit property values
Definition: AAX.h:338
Declarations for cross-platform AAX_ASSERT, AAX_TRACE and related facilities.
#define AAX_ASSERT(condition)
Asserts that a condition is true and logs an error if the condition is false.
Definition: AAX_Assert.h:268
AAX_EStemFormat
Stem format definitions.
Definition: AAX_Enums.h:232
@ AAX_eStemFormat_Mono
M.
Definition: AAX_Enums.h:234
@ AAX_eStemFormat_Ambi_3_ACN
Reserved for Ambisonics: third-order with ACN channel order and SN3D (AmbiX) normalization.
Definition: AAX_Enums.h:255
@ AAX_eStemFormat_INT32_MAX
Definition: AAX_Enums.h:267
@ AAX_eStemFormat_Ambi_1_ACN
Reserved for Ambisonics: first-order with ACN channel order and SN3D (AmbiX) normalization.
Definition: AAX_Enums.h:253
@ AAX_eStemFormat_7_0_DTS
L C R Lss Rss Lsr Rsr.
Definition: AAX_Enums.h:245
@ AAX_eStemFormat_7_0_SDDS
L Lc C Rc R Ls Rs.
Definition: AAX_Enums.h:243
@ AAX_eStemFormat_7_1_2
L C R Lss Rss Lsr Rsr LFE Lts Rts.
Definition: AAX_Enums.h:248
@ AAX_eStemFormat_Quad
L R Ls Rs.
Definition: AAX_Enums.h:238
@ AAX_eStemFormatNum
Definition: AAX_Enums.h:262
@ AAX_eStemFormat_Reserved_3
Reserved - do not use.
Definition: AAX_Enums.h:260
@ AAX_eStemFormat_None
Definition: AAX_Enums.h:264
@ AAX_eStemFormat_7_1_SDDS
L Lc C Rc R Ls Rs LFE.
Definition: AAX_Enums.h:244
@ AAX_eStemFormat_Stereo
L R.
Definition: AAX_Enums.h:235
@ AAX_eStemFormat_Reserved_1
Reserved - do not use.
Definition: AAX_Enums.h:258
@ AAX_eStemFormat_7_1_DTS
L C R Lss Rss Lsr Rsr LFE.
Definition: AAX_Enums.h:246
@ AAX_eStemFormat_LCR
L C R.
Definition: AAX_Enums.h:236
@ AAX_eStemFormat_Reserved_2
Reserved - do not use.
Definition: AAX_Enums.h:259
@ AAX_eStemFormat_5_1
L C R Ls Rs LFE.
Definition: AAX_Enums.h:240
@ AAX_eStemFormat_LCRS
L C R S.
Definition: AAX_Enums.h:237
@ AAX_eStemFormat_7_0_2
L C R Lss Rss Lsr Rsr Lts Rts.
Definition: AAX_Enums.h:247
@ AAX_eStemFormat_6_1
L C R Ls Cs Rs LFE.
Definition: AAX_Enums.h:242
@ AAX_eStemFormat_5_0
L C R Ls Rs.
Definition: AAX_Enums.h:239
@ AAX_eStemFormat_6_0
L C R Ls Cs Rs.
Definition: AAX_Enums.h:241
@ AAX_eStemFormat_Any
Definition: AAX_Enums.h:265
@ AAX_eStemFormat_Ambi_2_ACN
Reserved for Ambisonics: second-order with ACN channel order and SN3D (AmbiX) normalization.
Definition: AAX_Enums.h:254
Definitions of error codes used by AAX plug-ins.
@ AAX_RESULT_NEW_PACKET_POSTED
Definition: AAX_Errors.h:68
@ AAX_ERROR_CONTEXT_ALREADY_HAS_METERS
Definition: AAX_Errors.h:54
@ AAX_ERROR_INVALID_PARAMETER_ID
Definition: AAX_Errors.h:41
@ AAX_ERROR_NOTIFICATION_FAILED
Definition: AAX_Errors.h:71
@ AAX_ERROR_PORT_ID_OUT_OF_RANGE
Definition: AAX_Errors.h:56
@ AAX_ERROR_INVALID_CHUNK_ID
Definition: AAX_Errors.h:47
@ AAX_ERROR_PLUGIN_END
Custom plug-in error codes may be placed in the range ( AAX_ERROR_PLUGIN_END, AAX_ERROR_PLUGIN_BEGIN ...
Definition: AAX_Errors.h:95
@ AAX_RESULT_ADD_FIELD_UNSUPPORTED_FIELD_TYPE
Definition: AAX_Errors.h:63
@ AAX_ERROR_UNIMPLEMENTED
Definition: AAX_Errors.h:49
@ AAX_ERROR_PLUGIN_NULL_PARAMETER
Definition: AAX_Errors.h:70
@ AAX_RESULT_PACKET_STREAM_NOT_EMPTY
Definition: AAX_Errors.h:62
@ AAX_ERROR_UNKNOWN_EXCEPTION
An AAX plug-in should return this to the host if an unknown exception is caught. Exceptions should ne...
Definition: AAX_Errors.h:82
@ AAX_ERROR_MALFORMED_CHUNK
Definition: AAX_Errors.h:66
@ AAX_ERROR_EMPTY_EFFECT_NAME
Definition: AAX_Errors.h:77
@ AAX_ERROR_MIXER_THREAD_FALLING_BEHIND
Definition: AAX_Errors.h:64
@ AAX_ERROR_DIRECT_ACCESS_OUT_OF_BOUNDS
Definition: AAX_Errors.h:58
@ AAX_ERROR_INVALID_PATH
Definition: AAX_Errors.h:80
@ AAX_ERROR_SIGNED_INT_OVERFLOW
Definition: AAX_Errors.h:73
@ AAX_ERROR_FIFO_FULL
Definition: AAX_Errors.h:59
@ AAX_ERROR_NULL_OBJECT
Definition: AAX_Errors.h:44
@ AAX_ERROR_NULL_COMPONENT
Definition: AAX_Errors.h:55
@ AAX_ERROR_PLUGIN_BEGIN
Custom plug-in error codes may be placed in the range ( AAX_ERROR_PLUGIN_END, AAX_ERROR_PLUGIN_BEGIN ...
Definition: AAX_Errors.h:94
@ AAX_ERROR_INVALID_ARGUMENT
One or more input parameters are invalid; all output parameters are left unchanged.
Definition: AAX_Errors.h:83
@ AAX_ERROR_INVALID_METER_INDEX
Definition: AAX_Errors.h:43
@ AAX_ERROR_PLUGIN_NOT_AUTHORIZED
Definition: AAX_Errors.h:69
@ AAX_ERROR_UNKNOWN_PLUGIN
Definition: AAX_Errors.h:78
@ AAX_ERROR_INVALID_STRING_CONVERSION
Definition: AAX_Errors.h:42
@ AAX_ERROR_ACF_ERROR
Definition: AAX_Errors.h:52
@ AAX_ERROR_OLDER_VERSION
Definition: AAX_Errors.h:45
@ AAX_ERROR_INVALID_FIELD_INDEX
Definition: AAX_Errors.h:65
@ AAX_ERROR_NO_COMPONENTS
Definition: AAX_Errors.h:74
@ AAX_ERROR_POST_PACKET_FAILED
Definition: AAX_Errors.h:61
@ AAX_ERROR_INCORRECT_CHUNK_SIZE
Definition: AAX_Errors.h:48
@ AAX_ERROR_FIELD_TYPE_DOES_NOT_SUPPORT_DIRECT_ACCESS
Definition: AAX_Errors.h:57
@ AAX_ERROR_NULL_ARGUMENT
One or more required pointer arguments are null.
Definition: AAX_Errors.h:84
@ AAX_ERROR_PROPERTY_UNDEFINED
Definition: AAX_Errors.h:79
@ AAX_ERROR_DUPLICATE_TYPE_ID
Definition: AAX_Errors.h:76
@ AAX_ERROR_INVALID_VIEW_SIZE
Definition: AAX_Errors.h:72
@ AAX_ERROR_INVALID_PARAMETER_INDEX
Definition: AAX_Errors.h:50
@ AAX_ERROR_INITIALIZING_PACKET_STREAM_THREAD
Definition: AAX_Errors.h:60
@ AAX_ERROR_INVALID_METER_TYPE
Definition: AAX_Errors.h:53
@ AAX_ERROR_INVALID_CHUNK_INDEX
Definition: AAX_Errors.h:46
@ AAX_ERROR_UNKNOWN_ID
Definition: AAX_Errors.h:81
@ AAX_SUCCESS
Definition: AAX_Errors.h:39
@ AAX_ERROR_INVALID_INTERNAL_DATA
Some part of the internal data required by the method is invalid.
Definition: AAX_Errors.h:85
@ AAX_ERROR_NOT_INITIALIZED
Definition: AAX_Errors.h:51
@ AAX_ERROR_TOD_BEHIND
Definition: AAX_Errors.h:67
@ AAX_ERROR_ARGUMENT_BUFFER_OVERFLOW
A buffer argument was not large enough to hold the data which must be placed within it.
Definition: AAX_Errors.h:86
@ AAX_ERROR_DUPLICATE_EFFECT_ID
Definition: AAX_Errors.h:75
An AAX string interface.
AAX_EProperty
The list of properties that can be added to an AAX_IPropertyMap.
Definition: AAX_Properties.h:72
@ AAX_eProperty_Constraint_Location
Constraint on the algorithm's location, as a mask of AAX_EConstraintLocationMask.
Definition: AAX_Properties.h:720
@ AAX_eProperty_SampleRate
Specifies which sample rates the Effect supports. A mask of AAX_ESampleRateMask.
Definition: AAX_Properties.h:375
#define DEFINE_AAX_ERROR_STRING(X)
bool IsFourCharASCII(uint32_t inFourChar)
Definition: AAX_StringUtilities.hpp:223
std::string AsStringPropertyValue(AAX_EProperty inProperty, AAX_CPropertyValue inPropertyValue)
Definition: AAX_StringUtilities.hpp:253
std::string AsStringFourChar(uint32_t inFourChar)
Definition: AAX_StringUtilities.hpp:238
std::string AsStringStemFormat(AAX_EStemFormat inStemFormat, bool inAbbreviate=false)
Definition: AAX_StringUtilities.hpp:322
std::string AsStringResult(AAX_Result inResult)
Definition: AAX_StringUtilities.hpp:536
int32_t Caseless_strcmp(const char *cs, const char *ct)
Definition: AAX_StringUtilities.hpp:131
std::string Binary2String(uint32_t binaryValue, int32_t numBits)
Definition: AAX_StringUtilities.hpp:174
uint32_t String2Binary(const AAX_IString &s)
Definition: AAX_StringUtilities.hpp:195
std::string AsStringIDTriad(const AAX_SPlugInIdentifierTriad &inIDTriad)
Definition: AAX_StringUtilities.hpp:310
void GetCStringOfLength(char *stringOut, const char *stringIn, int32_t aMaxChars)
==============================================================
Definition: AAX_StringUtilities.hpp:91
bool IsASCII(char inChar)
Definition: AAX_StringUtilities.hpp:218
std::string AsStringInt32(int32_t inInt32)
Definition: AAX_StringUtilities.hpp:294
std::string AsStringUInt32(uint32_t inUInt32)
Definition: AAX_StringUtilities.hpp:302
std::string AsStringStemChannel(AAX_EStemFormat inStemFormat, uint32_t inChannelIndex, bool inAbbreviate)
Definition: AAX_StringUtilities.hpp:358
Plug-in Identifier Triad.
Definition: AAX.h:554
AAX_CTypeID mProductID
The Plug-In's product (Effect) ID.
Definition: AAX.h:556
AAX_CTypeID mPlugInID
The ID of a specific type in the product (Effect)
Definition: AAX.h:557
AAX_CTypeID mManufacturerID
The Plug-In's manufacturer ID.
Definition: AAX.h:555
A simple string container that can be passed across a binary boundary. This class,...
Definition: AAX_IString.h:41
virtual uint32_t Length() const =0
virtual const char * Get() const =0