Here is the sequence of operations to be used for Webrtc_AGC:

1. Create AGC: `WebRtcAgc_Create`
2. Initialize AGC:  `WebRtcAgc_Init`
3. Set Config: `WebRtcAgc_set_config`
4. Initialize `capture_level = 0`
5. For `kAgcModeAdaptiveDigital`, invoke VirtualMic: `WebRtcAgc_VirtualMic`
6. Process Buffer with `capture_level`: `WebRtcAgc_Process`
7. Get the out capture level returned from `WebRtcAgc_Process` and set it to `capture_level`
8. Repeat 5 to 7 for the `audio buffers`
9. Destroy the AGC: `WebRtcAgc_Free`

Check webrtc/modules/audio_processing/gain_control_impl.cc for reference. 

Try this:&lt;br&gt;
&lt;pre&gt;

    agcConfig.compressionGaindB = 9;
    agcConfig.limiterEnable = 1;
    agcConfig.targetLevelDbfs = 9;   /* 9dB below full scale */
    
    WebRtcAgc_Create(&amp;agc);
    WebRtcAgc_Init(&amp;agc, minLevel, maxLevel, kAgcModeFixedDigital, 8000);
    WebRtcAgc_set_config(&amp;agc, &amp;agcConfig);

&lt;/pre&gt;


in Matlab I do this:

    &gt;&gt; E = [];
    &gt;&gt; A = [1 2 3 4 5; 10 20 30 40 50];
    &gt;&gt; E = [E ; A]
    
    E =
    
         1     2     3     4     5
        10    20    30    40    50

Now I want the same thing in Numpy but I have problems, look at this:

    &gt;&gt;&gt; E = array([],dtype=int)
    &gt;&gt;&gt; E
    array([], dtype=int64)
    &gt;&gt;&gt; A = array([[1,2,3,4,5],[10,20,30,40,50]])

    &gt;&gt;&gt; E = vstack((E,A))
    Traceback (most recent call last):
      File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
      File &quot;/System/Library/Frameworks/Python.framework/Versions/2.7/Extras/lib/python/numpy/core/shape_base.py&quot;, line 226, in vstack
        return _nx.concatenate(map(atleast_2d,tup),0)
    ValueError: array dimensions must agree except for d_0

I have a similar situation when I do this with:

    &gt;&gt;&gt; E = concatenate((E,A),axis=0)
    Traceback (most recent call last):
      File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
    ValueError: arrays must have same number of dimensions

Or:

    &gt;&gt;&gt; E = append([E],[A],axis=0)
    Traceback (most recent call last):
      File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
      File &quot;/System/Library/Frameworks/Python.framework/Versions/2.7/Extras/lib/python/numpy/lib/function_base.py&quot;, line 3577, in append
        return concatenate((arr, values), axis=axis)
    ValueError: arrays must have same number of dimensions


Concatenating empty array in Numpy

Suppose I have two interfaces:

    public interface I1
    {
        default String getGreeting() {
            return &quot;Good Morning!&quot;;
        }
    }

    public interface I2
    {
        default String getGreeting() {
            return &quot;Good Afternoon!&quot;;
        }
    }

If I want to implement both of them, what implementation will be used?

    public class C1 implements I1, I2
    {
        public static void main(String[] args)
        {
            System.out.println(new C1().getGreeting());
        }
    }


Implementing two interfaces with two default methods of the same signature in Java 8

I am testing the WebRTC AGC but I must be doing something wrong because the signal just passes through unmodified.

Here&#39;s how I create and initialize the AGC:

    agcConfig.compressionGaindB = 9;
    agcConfig.limiterEnable = 1;
    agcConfig.targetLevelDbfs = 9;   /* 9dB below full scale */

    WebRtcAgc_Create(&amp;agc);
    WebRtcAgc_Init(agc, minLevel, maxLevel, kAgcModeFixedDigital, 8000);
    WebRtcAgc_set_config(agc, agcConfig);

And then for each 10ms sample block I do the following:

    WebRtcAgc_Process(agc, micData, NULL, 80, micData, NULL, micLevelIn, &amp;micLevelOut, 0, &amp;saturationWarning);

Where `micLevelIn` is set to 0. 

Can somebody tell me what I&#39;m doing wrong? 

I expected that a full scale sine tone would be attenuated to the target DBFS level; and a low level sine tone (i.e. -30dBFS) would be amplified to match the target DBFS level. But that&#39;s not what I&#39;m seeing.

WebRTC AGC (Automatic Gain Control)

I am testing the WebRTC AGC but I must be doing something wrong because the signal just passes through unmodified.
Here's how I create and initialize the AGC:
<pre><code class="hljs language-ini">agcConfig.compressionGaindB = 9;
agcConfig.limiterEnable = 1;
agcConfig.targetLevelDbfs = 9; /* 9dB below full scale */

WebRtcAgc_Create(&#x26;agc);
WebRtcAgc_Init(agc, minLevel, maxLevel, kAgcModeFixedDigital, 8000);
WebRtcAgc_set_config(agc, agcConfig);
</code></pre>
And then for each 10ms sample block I do the following:
<pre><code class="hljs language-arduino">WebRtcAgc_Process(agc, micData, NULL, 80, micData, NULL, micLevelIn, &#x26;micLevelOut, 0, &#x26;saturationWarning);
</code></pre>
Where <code>micLevelIn</code> is set to 0.
Can somebody tell me what I'm doing wrong?
I expected that a full scale sine tone would be attenuated to the target DBFS level; and a low level sine tone (i.e. -30dBFS) would be amplified to match the target DBFS level. But that's not what I'm seeing.

I&#39;m trying to load a PNG image using SDL but the program doesn&#39;t work and this error appears in the console

&gt; libpng warning: iCCP: known incorrect sRGB profile

Why does this warning appear? What should I do to solve this problem?

libpng warning: iCCP: known incorrect sRGB profile

I wrote a &#39;simple&#39; (it took me 30 minutes) program that converts decimal number to binary. I am SURE that there&#39;s a lot simpler way so can you show me?
Here&#39;s the code:

    #include &lt;iostream&gt;
    #include &lt;stdlib.h&gt;
    
    using namespace std;
    int a1, a2, remainder;
    int tab = 0;
    int maxtab = 0;
    int table[0];
    int main()
    {
        system(&quot;clear&quot;);
        cout &lt;&lt; &quot;Enter a decimal number: &quot;;
        cin &gt;&gt; a1;
        a2 = a1; //we need our number for later on so we save it in another variable
    
        while (a1!=0) //dividing by two until we hit 0
        {
            remainder = a1%2; //getting a remainder - decimal number(1 or 0)
            a1 = a1/2; //dividing our number by two
            maxtab++; //+1 to max elements of the table
        }
    
        maxtab--; //-1 to max elements of the table (when dividing finishes it adds 1 additional elemnt that we don&#39;t want and it&#39;s equal to 0)
        a1 = a2; //we must do calculations one more time so we&#39;re gatting back our original number
        table[0] = table[maxtab]; //we set the number of elements in our table to maxtab (we don&#39;t get 10&#39;s of 0&#39;s)
    
        while (a1!=0) //same calculations 2nd time but adding every 1 or 0 (remainder) to separate element in table
        {
            remainder = a1%2; //getting a remainder
            a1 = a1/2; //dividing by 2
            table[tab] = remainder; //adding 0 or 1 to an element
            tab++; //tab (element count) increases by 1 so next remainder is saved in another element
        }
    
        tab--; //same as with maxtab--
        cout &lt;&lt; &quot;Your binary number: &quot;;
    
        while (tab&gt;=0) //until we get to the 0 (1st) element of the table
        {
            cout &lt;&lt; table[tab] &lt;&lt; &quot; &quot;; //write the value of an element (0 or 1)
            tab--; //decreasing by 1 so we show 0&#39;s and 1&#39;s FROM THE BACK (correct way)
        }
    
        cout &lt;&lt; endl;
        return 0;
    }

By the way it&#39;s complicated but I tried my best.

**edit - Here is the solution I ended up using:**

    std::string toBinary(int n)
    {
        std::string r;
        while(n!=0) {r=(n%2==0 ?&quot;0&quot;:&quot;1&quot;)+r; n/=2;}
        return r;
    }

C++ - Decimal to binary converting

I&#39;m running Windows 7 French and I&#39;m trying to compile this really basic program, but Visual Studio is being stubborn and refuses to comply. I also tried compiling it with both GCC 4.7 and Clang trunk on [Coliru](http://coliru.stacked-crooked.net) and I get more or less the same errors (output is below the code), though I think Coliru runs on an English OS so I wouldn&#39;t expect it to work anyway.

What am I doing wrong? And how can I fix it?


### Code

    #inclure &lt;iostream&gt;
    
    ent principal(ent argn, ent** argm)  // entier, nombre d&#39;arguments, valeur des arguments
    {
       std::cendehors &lt;&lt; &quot;Bonjour le monde!\n&quot;;
       renvoi SORTIE_SUCC&#200;S;
    }

### Output

    principal.cpp:1:6: erreur: pr&#233;traitement de la directive invalide #inclure
         #inclure &lt;iostream&gt;
          ^
    principal.cpp:6:8: erreur: &#39;\303&#39; &#233;gar&#233; dans le programme
            renvoi SORTIE_SUCC&#200;S;
            ^
    principal.cpp:6:8: erreur: &#39;\210&#39; &#233;gar&#233; dans le programme
    principal.cpp:3:5: erreur: &#171;ent&#187; ne d&#233;signe pas un type
         ent principal(ent argn, ent** argm)  // entier, nombre d&#39;arguments, value des arguments
         ^

Why can&#39;t my program compile under Windows 7 in French?

We have recently purchased some new servers and are experiencing poor memcpy performance. The memcpy performance is 3x slower on the servers compared to our laptops.

**Server Specs**

 - Chassis and Mobo: SUPER MICRO 1027GR-TRF
 - CPU: 2x Intel Xeon E5-2680 @ 2.70 Ghz
 - Memory: 8x 16GB DDR3 1600MHz

Edit: I am also testing on another server with slightly higher specs and seeing the same results as the above server

**Server 2 Specs**

 - Chassis and Mobo: SUPER MICRO 10227GR-TRFT
 - CPU: 2x Intel Xeon E5-2650 v2 @ 2.6 Ghz
 - Memory: 8x 16GB DDR3 1866MHz

**Laptop Specs**

 - Chassis: Lenovo W530
 - CPU: 1x Intel Core i7 i7-3720QM @ 2.6Ghz
 - Memory: 4x 4GB DDR3 1600MHz

**Operating System**

    $ cat /etc/redhat-release
    Scientific Linux release 6.5 (Carbon) 
    $ uname -a                      
    Linux r113 2.6.32-431.1.2.el6.x86_64 #1 SMP Thu Dec 12 13:59:19 CST 2013 x86_64 x86_64 x86_64 GNU/Linux

**Compiler (on all systems)**

    $ gcc --version
    gcc (GCC) 4.6.1

Also tested with gcc 4.8.2 based on a suggestion from @stefan. There was no performance difference between compilers.


**Test Code**
The test code below is a canned test to duplicate the problem i am seeing in our production code. I know this benchmark is simplistic but it was able to exploit and identify our problem. The code creates two 1GB buffers and memcpys between them, timing the memcpy call. You can specify alternate buffer sizes on the command line using: ./big_memcpy_test [SIZE_BYTES]

    #include &lt;chrono&gt;
    #include &lt;cstring&gt;
    #include &lt;iostream&gt;
    #include &lt;cstdint&gt;
    
    class Timer
    {
     public:
      Timer()
          : mStart(),
            mStop()
      {
        update();
      }
    
      void update()
      {
        mStart = std::chrono::high_resolution_clock::now();
        mStop  = mStart;
      }
    
      double elapsedMs()
      {
        mStop = std::chrono::high_resolution_clock::now();
        std::chrono::milliseconds elapsed_ms =
            std::chrono::duration_cast&lt;std::chrono::milliseconds&gt;(mStop - mStart);
        return elapsed_ms.count();
      }
    
     private:
      std::chrono::high_resolution_clock::time_point mStart;
      std::chrono::high_resolution_clock::time_point mStop;
    };
    
    std::string formatBytes(std::uint64_t bytes)
    {
      static const int num_suffix = 5;
      static const char* suffix[num_suffix] = { &quot;B&quot;, &quot;KB&quot;, &quot;MB&quot;, &quot;GB&quot;, &quot;TB&quot; };
      double dbl_s_byte = bytes;
      int i = 0;
      for (; (int)(bytes / 1024.) &gt; 0 &amp;&amp; i &lt; num_suffix;
           ++i, bytes /= 1024.)
      {
        dbl_s_byte = bytes / 1024.0;
      }
    
      const int buf_len = 64;
      char buf[buf_len];
    
      // use snprintf so there is no buffer overrun
      int res = snprintf(buf, buf_len,&quot;%0.2f%s&quot;, dbl_s_byte, suffix[i]);
      
      // snprintf returns number of characters that would have been written if n had
      //       been sufficiently large, not counting the terminating null character.
      //       if an encoding error occurs, a negative number is returned.
      if (res &gt;= 0)
      {
        return std::string(buf);
      }
      return std::string();
    }
    
    void doMemmove(void* pDest, const void* pSource, std::size_t sizeBytes)
    {
      memmove(pDest, pSource, sizeBytes);
    }
    
    int main(int argc, char* argv[])
    {
      std::uint64_t SIZE_BYTES = 1073741824; // 1GB
      
      if (argc &gt; 1)
      {
        SIZE_BYTES = std::stoull(argv[1]);
        std::cout &lt;&lt; &quot;Using buffer size from command line: &quot; &lt;&lt; formatBytes(SIZE_BYTES)
                  &lt;&lt; std::endl;
      }
      else
      {
        std::cout &lt;&lt; &quot;To specify a custom buffer size: big_memcpy_test [SIZE_BYTES] \n&quot;
                  &lt;&lt; &quot;Using built in buffer size: &quot; &lt;&lt; formatBytes(SIZE_BYTES)
                  &lt;&lt; std::endl;
      }
      
    
      // big array to use for testing
      char* p_big_array = NULL;
    
      /////////////
      // malloc 
      {
        Timer timer;
      
        p_big_array = (char*)malloc(SIZE_BYTES * sizeof(char));
        if (p_big_array == NULL)
        {
          std::cerr &lt;&lt; &quot;ERROR: malloc of &quot; &lt;&lt; SIZE_BYTES &lt;&lt; &quot; returned NULL!&quot;
                    &lt;&lt; std::endl;
          return 1;
        }
        
        std::cout &lt;&lt; &quot;malloc for &quot; &lt;&lt; formatBytes(SIZE_BYTES) &lt;&lt; &quot; took &quot;
                  &lt;&lt; timer.elapsedMs() &lt;&lt; &quot;ms&quot;
                  &lt;&lt; std::endl;
      }
      
      /////////////
      // memset
      {
        Timer timer;
    
        // set all data in p_big_array to 0
        memset(p_big_array, 0xF, SIZE_BYTES * sizeof(char));
    
        double elapsed_ms = timer.elapsedMs();
        std::cout &lt;&lt; &quot;memset for &quot; &lt;&lt; formatBytes(SIZE_BYTES) &lt;&lt; &quot; took &quot;
                  &lt;&lt; elapsed_ms &lt;&lt; &quot;ms &quot;
                  &lt;&lt; &quot;(&quot; &lt;&lt; formatBytes(SIZE_BYTES / (elapsed_ms / 1.0e3)) &lt;&lt; &quot; bytes/sec)&quot;
                  &lt;&lt; std::endl;
      }
    
      /////////////
      // memcpy 
      {
        char* p_dest_array = (char*)malloc(SIZE_BYTES);
        if (p_dest_array == NULL)
        {
          std::cerr &lt;&lt; &quot;ERROR: malloc of &quot; &lt;&lt; SIZE_BYTES &lt;&lt; &quot; for memcpy test&quot;
                    &lt;&lt; &quot; returned NULL!&quot;
                    &lt;&lt; std::endl;
          return 1;
        }
        memset(p_dest_array, 0xF, SIZE_BYTES * sizeof(char));
    
        // time only the memcpy FROM p_big_array TO p_dest_array
        Timer timer;
    
        memcpy(p_dest_array, p_big_array, SIZE_BYTES * sizeof(char));
        
        double elapsed_ms = timer.elapsedMs();
        std::cout &lt;&lt; &quot;memcpy for &quot; &lt;&lt; formatBytes(SIZE_BYTES) &lt;&lt; &quot; took &quot;
                  &lt;&lt; elapsed_ms &lt;&lt; &quot;ms &quot;
                  &lt;&lt; &quot;(&quot; &lt;&lt; formatBytes(SIZE_BYTES / (elapsed_ms / 1.0e3)) &lt;&lt; &quot; bytes/sec)&quot;
                  &lt;&lt; std::endl;
    
        // cleanup p_dest_array
        free(p_dest_array);
        p_dest_array = NULL;
      }
    
      /////////////
      // memmove
      {
        char* p_dest_array = (char*)malloc(SIZE_BYTES);
        if (p_dest_array == NULL)
        {
          std::cerr &lt;&lt; &quot;ERROR: malloc of &quot; &lt;&lt; SIZE_BYTES &lt;&lt; &quot; for memmove test&quot;
                    &lt;&lt; &quot; returned NULL!&quot;
                    &lt;&lt; std::endl;
          return 1;
        }
        memset(p_dest_array, 0xF, SIZE_BYTES * sizeof(char));
    
        // time only the memmove FROM p_big_array TO p_dest_array
        Timer timer;
    
        // memmove(p_dest_array, p_big_array, SIZE_BYTES * sizeof(char));
        doMemmove(p_dest_array, p_big_array, SIZE_BYTES * sizeof(char));
        
        double elapsed_ms = timer.elapsedMs();
        std::cout &lt;&lt; &quot;memmove for &quot; &lt;&lt; formatBytes(SIZE_BYTES) &lt;&lt; &quot; took &quot;
                  &lt;&lt; elapsed_ms &lt;&lt; &quot;ms &quot;
                  &lt;&lt; &quot;(&quot; &lt;&lt; formatBytes(SIZE_BYTES / (elapsed_ms / 1.0e3)) &lt;&lt; &quot; bytes/sec)&quot;
                  &lt;&lt; std::endl;
    
        // cleanup p_dest_array
        free(p_dest_array);
        p_dest_array = NULL;
      }
    
    
      // cleanup
      free(p_big_array);
      p_big_array = NULL;
      
      return 0;
    }


**CMake File to Build**

    project(big_memcpy_test)
    cmake_minimum_required(VERSION 2.4.0)
    
    include_directories(${CMAKE_CURRENT_SOURCE_DIR})
    
    # create verbose makefiles that show each command line as it is issued
    set( CMAKE_VERBOSE_MAKEFILE ON CACHE BOOL &quot;Verbose&quot; FORCE )
    # release mode
    set( CMAKE_BUILD_TYPE Release )
    # grab in CXXFLAGS environment variable and append C++11 and -Wall options
    set( CMAKE_CXX_FLAGS &quot;${CMAKE_CXX_FLAGS} -std=c++0x -Wall -march=native -mtune=native&quot; )
    message( INFO &quot;CMAKE_CXX_FLAGS = ${CMAKE_CXX_FLAGS}&quot; )
    
    # sources to build
    set(big_memcpy_test_SRCS
      main.cpp
    )
    
    # create an executable file named &quot;big_memcpy_test&quot; from
    # the source files in the variable &quot;big_memcpy_test_SRCS&quot;.
    add_executable(big_memcpy_test ${big_memcpy_test_SRCS})


**Test Results**

    Buffer Size: 1GB | malloc (ms) | memset (ms) | memcpy (ms) | NUMA nodes (numactl --hardware)
    ---------------------------------------------------------------------------------------------
    Laptop 1         | 0           | 127         | 113         | 1
    Laptop 2         | 0           | 180         | 120         | 1
    Server 1         | 0           | 306         | 301         | 2
    Server 2         | 0           | 352         | 325         | 2

As you can see the memcpys and memsets on our servers is much slower than the memcpys and memsets on our laptops.

**Varying buffer sizes**

I have tried buffers from 100MB to 5GB all with similar results (servers slower than laptop)


**NUMA Affinity**

I read about people having performance issues with NUMA so i tried setting CPU and memory affinity using numactl but the results remained the same.

Server NUMA Hardware

    $ numactl --hardware                                                            
    available: 2 nodes (0-1)                                                                     
    node 0 cpus: 0 1 2 3 4 5 6 7 16 17 18 19 20 21 22 23                                         
    node 0 size: 65501 MB                                                                        
    node 0 free: 62608 MB                                                                        
    node 1 cpus: 8 9 10 11 12 13 14 15 24 25 26 27 28 29 30 31                                   
    node 1 size: 65536 MB                                                                        
    node 1 free: 63837 MB                                                                        
    node distances:                                                                              
    node   0   1                                                                                 
      0:  10  21                                                                                 
      1:  21  10 


Laptop NUMA Hardware

    $ numactl --hardware
    available: 1 nodes (0)
    node 0 cpus: 0 1 2 3 4 5 6 7
    node 0 size: 16018 MB
    node 0 free: 6622 MB
    node distances:
    node   0 
      0:  10

Setting NUMA Affinity

    $ numactl --cpunodebind=0 --membind=0 ./big_memcpy_test


Any help resolving this is greatly appreciated.

**Edit: GCC Options**

Based on comments i have tried compiling with different GCC options:

Compiling with -march and -mtune set to native

    g++ -std=c++0x -Wall -march=native -mtune=native -O3 -DNDEBUG -o big_memcpy_test main.cpp 

Result: Exact same performance (no improvement)

Compiling with -O2 instead of -O3

    g++ -std=c++0x -Wall -march=native -mtune=native -O2 -DNDEBUG -o big_memcpy_test main.cpp

Result: Exact same performance (no improvement)

**Edit: Changed memset to write 0xF instead of 0 to avoid NULL page (@SteveCox)**

No improvement when memsetting with a value other than 0 (used 0xF in this case).

**Edit: Cachebench results**

In order to rule out that my test program is too simplistic i downloaded a real benchmarking program LLCacheBench (http://icl.cs.utk.edu/projects/llcbench/cachebench.html)

I built the benchmark on each machine separately to avoid architecture issues. Below are my results.

![laptop vs server memcpy performance][1]

Notice the VERY large difference is performance on the larger buffer sizes. The last size tested (16777216) performed at 18849.29 MB/sec on the laptop and 6710.40 on the server. That&#39;s about a 3x difference in performance. You can also notice that the performance dropoff of the server is much steeper than on the laptop.

**Edit: memmove() is 2x FASTER than memcpy() on the server**

Based on some experimentation i have tried using memmove() instead of memcpy() in my test case and have found a 2x improvement on the server. Memmove() on the laptop runs slower than memcpy() but oddly enough runs at the same speed as the memmove() on the server. This begs the question, why is memcpy so slow?

Updated Code to test memmove along with memcpy. I had to wrap the memmove() inside a function because if i left it inline GCC optimized it and performed the exact same as memcpy() (i assume gcc optimized it to memcpy because it knew the locations didn&#39;t overlap).

Updated Results

    Buffer Size: 1GB | malloc (ms) | memset (ms) | memcpy (ms) | memmove() | NUMA nodes (numactl --hardware)
    ---------------------------------------------------------------------------------------------------------
    Laptop 1         | 0           | 127         | 113         | 161       | 1
    Laptop 2         | 0           | 180         | 120         | 160       | 1
    Server 1         | 0           | 306         | 301         | 159       | 2
    Server 2         | 0           | 352         | 325         | 159       | 2

**Edit: Naive Memcpy**

Based on suggestion from @Salgar i have implemented my own naive memcpy function and tested it.

Naive Memcpy Source

    void naiveMemcpy(void* pDest, const void* pSource, std::size_t sizeBytes)
    {
      char* p_dest = (char*)pDest;
      const char* p_source = (const char*)pSource;
      for (std::size_t i = 0; i &lt; sizeBytes; ++i)
      {
        *p_dest++ = *p_source++;
      }
    }

Naive Memcpy Results Compared to memcpy()

    Buffer Size: 1GB | memcpy (ms) | memmove(ms) | naiveMemcpy()
    ------------------------------------------------------------
    Laptop 1         | 113         | 161         | 160
    Server 1         | 301         | 159         | 159
    Server 2         | 325         | 159         | 159

**Edit: Assembly Output**

Simple memcpy source

    #include &lt;cstring&gt;
    #include &lt;cstdlib&gt;
    
    int main(int argc, char* argv[])
    {
      size_t SIZE_BYTES = 1073741824; // 1GB
      
      char* p_big_array  = (char*)malloc(SIZE_BYTES * sizeof(char));
      char* p_dest_array = (char*)malloc(SIZE_BYTES * sizeof(char));
      
      memset(p_big_array,  0xA, SIZE_BYTES * sizeof(char));
      memset(p_dest_array, 0xF, SIZE_BYTES * sizeof(char));
        
      memcpy(p_dest_array, p_big_array, SIZE_BYTES * sizeof(char));
        
      free(p_dest_array);
      free(p_big_array);
      
      return 0;
    }

Assembly Output: This is the exact same on both the server and the laptop. I&#39;m saving space and not pasting both.

            .file   &quot;main_memcpy.cpp&quot;
            .section        .text.startup,&quot;ax&quot;,@progbits
            .p2align 4,,15
            .globl  main
            .type   main, @function
    main:
    .LFB25:
            .cfi_startproc
            pushq   %rbp
            .cfi_def_cfa_offset 16
            .cfi_offset 6, -16
            movl    $1073741824, %edi
            pushq   %rbx
            .cfi_def_cfa_offset 24
            .cfi_offset 3, -24
            subq    $8, %rsp
            .cfi_def_cfa_offset 32
            call    malloc
            movl    $1073741824, %edi
            movq    %rax, %rbx
            call    malloc
            movl    $1073741824, %edx
            movq    %rax, %rbp
            movl    $10, %esi
            movq    %rbx, %rdi
            call    memset
            movl    $1073741824, %edx
            movl    $15, %esi
            movq    %rbp, %rdi
            call    memset
            movl    $1073741824, %edx
            movq    %rbx, %rsi
            movq    %rbp, %rdi
            call    memcpy
            movq    %rbp, %rdi
            call    free
            movq    %rbx, %rdi
            call    free
            addq    $8, %rsp
            .cfi_def_cfa_offset 24
            xorl    %eax, %eax
            popq    %rbx
            .cfi_def_cfa_offset 16
            popq    %rbp
            .cfi_def_cfa_offset 8
            ret
            .cfi_endproc
    .LFE25:
            .size   main, .-main
            .ident  &quot;GCC: (GNU) 4.6.1&quot;
            .section        .note.GNU-stack,&quot;&quot;,@progbits


**PROGRESS!!!! asmlib**

Based on suggestion from @tbenson  i tried running with the [asmlib][2] version of memcpy. My results initially were poor but after changing SetMemcpyCacheLimit() to 1GB (size of my buffer) i was running at speed on par with my naive for loop!

Bad news is that the asmlib version of memmove is slower than the glibc version, it is now running at the 300ms mark (on par with the glibc version of memcpy). Weird thing is that on the laptop when i SetMemcpyCacheLimit() to a large number it hurts performance...

In the results below the lines marked with SetCache have SetMemcpyCacheLimit set to 1073741824. The results without SetCache do not call SetMemcpyCacheLimit()

Results using functions from asmlib:

    Buffer Size: 1GB  | memcpy (ms) | memmove(ms) | naiveMemcpy()
    ------------------------------------------------------------
    Laptop            | 136         | 132         | 161
    Laptop SetCache   | 182         | 137         | 161
    Server 1          | 305         | 302         | 164
    Server 1 SetCache | 162         | 303         | 164
    Server 2          | 300         | 299         | 166
    Server 2 SetCache | 166         | 301         | 166

Starting to lean towards cache issue, but what would cause this?

  [1]: http://i.stack.imgur.com/PTqZJ.png
  [2]: http://www.agner.org/optimize/asmlib.zip

Poor memcpy Performance on Linux

Is there a difference between these two code segments:

    void f() {
        thread_local vector&lt;int&gt; V;
        V.clear();
        ... // use V as a temporary variable
    }

and

    void f() {
        static thread_local vector&lt;int&gt; V;
        V.clear();
        ... // use V as a temporary variable
    }

Backstory: originally I had a STATIC vector&lt;int&gt; V (for holding some intermediate values, it gets cleared every time I enter the function) and a single-threaded program. I want to turn the program into a multithreading one, so somehow I have to get rid of this static modifier. My idea is to turn every static into thread_local and not worry about anything else? Can this approach backfire?

Are C++11 thread_local variables automatically static?

I am trying to filter a noisy heart rate signal with python. Because heart rates should never be above about 220 beats per minute, I want to filter out all noise above 220 bpm. I converted 220/minute into 3.66666666 Hertz and then converted that Hertz to rad/s to get 23.0383461 rad/sec.

The sampling frequency of the chip that takes data is 30Hz so I converted that to rad/s to get 188.495559 rad/s.

After looking up some stuff online I found some functions for a bandpass filter that I wanted to make into a lowpass. [Here is the link the bandpass code][1], so I converted it to be this:

    from scipy.signal import butter, lfilter
    from scipy.signal import freqs
    
    def butter_lowpass(cutOff, fs, order=5):
        nyq = 0.5 * fs
        normalCutoff = cutOff / nyq
        b, a = butter(order, normalCutoff, btype=&#39;low&#39;, analog = True)
        return b, a
    
    def butter_lowpass_filter(data, cutOff, fs, order=4):
        b, a = butter_lowpass(cutOff, fs, order=order)
        y = lfilter(b, a, data)
        return y
    
    cutOff = 23.1 #cutoff frequency in rad/s
    fs = 188.495559 #sampling frequency in rad/s
    order = 20 #order of filter
    
    #print sticker_data.ps1_dxdt2
    
    y = butter_lowpass_filter(data, cutOff, fs, order)
    plt.plot(y)


I am very confused by this though because I am pretty sure the butter function takes in the cutoff and sampling frequency in rad/s but I seem to be getting a weird output. Is it actually in Hz?

Secondly, what is the purpose of these two lines:

        nyq = 0.5 * fs
        normalCutoff = cutOff / nyq

I know it&#39;s something about normalization but I thought the nyquist was 2 times the sampling requency, not one half. And why are you using the nyquist as a normalizer?

Can someone explain more about how to create filters with these functions?

I plotted the filter using:

    w, h = signal.freqs(b, a)
    plt.plot(w, 20 * np.log10(abs(h)))
    plt.xscale(&#39;log&#39;)
    plt.title(&#39;Butterworth filter frequency response&#39;)
    plt.xlabel(&#39;Frequency [radians / second]&#39;)
    plt.ylabel(&#39;Amplitude [dB]&#39;)
    plt.margins(0, 0.1)
    plt.grid(which=&#39;both&#39;, axis=&#39;both&#39;)
    plt.axvline(100, color=&#39;green&#39;) # cutoff frequency
    plt.show()

and got this which clearly does not cut-off at 23 rad/s:

![result][2]

  [1]: http://wiki.scipy.org/Cookbook/ButterworthBandpass
  [2]: http://i.imgur.com/weqB1sw.png

Creating lowpass filter in SciPy - understanding methods and units

Can anyone please clearly explain the difference between 1D, 2D, and 3D convolutions in convolutional neural networks (in deep learning) with the use of examples?

Intuitive understanding of 1D, 2D, and 3D convolutions in convolutional neural networks

How to use a &quot;custom&quot; video capturer to create a VideoTrack and provide frames?

The classic approach to create a VideoTrack is:

**1 - Get a VideoCapturer instance**

    VideoCapturer capturer = VideoCapturer.create(name);
**2 - Create a VideoSource**

    VideoSource videoSource = peerconnectionFactory.createVideoSource(capturer,	videoConstraints);

**3 - Create a VideoTrack using the video source**

    VideoTrack videoTrack = peerconnectionFactory.createVideoTrack(&quot;Label&quot;, videoSource);

**4 - Add the track to the MediaStream**
___

I was wondering if there is a way to change **step one**. Instead of using the native Capturer instance, use an Android one, and provide the frames to the VideoTrack using the callback:

    public void onPreviewFrame(byte[] data, Camera camera) {
       // provide the frames to the VideoTrack
    }

Any suggestions? 

Create a WebRTC VideoTrack with a &quot;custom&quot; Capturer on Android with libjingle

I am capturing audio data using `getUserMedia()` and I want to send it to my server so I can save it as a Blob in a MySQL field.

This is all I am trying to do. I have made several attempts to do this using WebRTC, but I don&#39;t even know at this point if this is right or even the best way to do this.

Can *anybody* help me?

Here is the code I am using to capture audio from the microphone:

	navigator.getUserMedia({
		video:false,
		audio:true,
	},function(mediaStream){
		
		// output mediaStream to speakers:
		var mediaStreamSource=audioContext.createMediaStreamSource(mediaStream);
		mediaStreamSource.connect(audioContext.destintion);
		
		// send mediaStream to server:
		
        // WebRTC code? not sure about this...
        var RTCconfig={};
        var conn=new RTCPeerConnection(RTCconfig);
        
		// ???
		
	},function(error){
		console.log(&#39;getUserMedia() fail.&#39;);
		console.log(error);
	});

How can I send this `mediaStream` up to the server?

After Googling around I&#39;ve been looking into `WebRTC`, *but this seems to be for just peer to peer communication* - actually, now I&#39;m looking into this more, I think this is the way to go. It seems to be the way to communicate from the client&#39;s browser up to the host webserver, but nothing I try even comes close to working.

I&#39;ve been going through [the W3C documentation][1] (which I am finding way too abstract), and I&#39;ve been going thru [this article on HTML5 Rocks][2] (which is bringing up more questions than answers). Apparently I need a signalling method, can anyone advise which signalling method is best for sending mediaStreams, XHR, XMPP, SIP, Socket.io or something else?

What will I need on the server to support the receiving of WebRTC? My web server is running a basic LAMP stack.

Also, is it best to wait until the `mediaStream` is finished recording before I send it up to the server, or is it better to send the `mediaStream` as its being recorded? I want to know if I am going about doing this the right way. I have written file uploaders in javascript and HTML5, but uploading one of these `mediaStreams` seems hellishly more complicated and I&#39;m not sure if I am approaching it right.

Any help on this would be greatly appreciated.

  [1]: http://www.w3.org/TR/webrtc/
  [2]: http://www.html5rocks.com/en/tutorials/webrtc/basics/


Sending a MediaStream to host Server with WebRTC after it is captured by getUserMedia

I am trying to figure out how to test whether a STUN/TURN server is alive and properly responding to connections. Ideally this test would be performed from an external machine, just in case the STUN/TURN machine is down for this case should also be reported by the connectivity test.

Has anyone looked into this case in the past? What solutions would be recommended?

STUN/TURN server connectivity test

&lt;h3&gt;Summary&lt;/h3&gt; 
We cannot access camera from an iOS11 (public release) home screen web app using either WebRTC or the file input, details below. How can our users continue to access the camera please?

We are serving the web app page over https.

_&lt;h3&gt;Update, April&lt;/h3&gt;_
The public release of iOS 11.3 seems to have fixed the issue and file input camera access is working again!

_&lt;h3&gt;Update, March&lt;/h3&gt;_

As people here have said the Apple docs advise web app camera function is returning in 11.3 along with service workers.  This is good but we are not sure yet if we want to everyone to to reinstall again until we can thoroughly test on 11.3GM.  

_&lt;h3&gt;Solution, November&lt;/h3&gt;_
We lost hope Apple want to fix this and moved forward.  Modified our web app to remove the iOS &quot;Add to home screen&quot; function and asked affected users to remove any previous home screen icon.


_&lt;h3&gt;Update, 6 December&lt;/h3&gt;_

iOS 11.2 and iOS 11.1.2 don&#39;t fix. 

_&lt;h3&gt;Workarounds, 21 September&lt;/h3&gt;_

Seems we could ask existing customers of the web app 

&lt;ul&gt;
&lt;li&gt;not upgrade to iOS11 - good luck with that :) &lt;/li&gt;
&lt;li&gt;take photos in iOS camera and then select them back in the web app&lt;/li&gt; 
&lt;li&gt;wait for next ios beta&lt;/li&gt; 
&lt;li&gt;reinstall as a Safari in-browser page (after we remove ATHS logic) &lt;/li&gt;
&lt;li&gt;switch to Android&lt;/li&gt; 
&lt;/ul&gt;

&lt;h3&gt;File Input&lt;/h3&gt;
Our current production code uses a file input which has worked fine for years with iOS 10 and older. On iOS11 it works as a Safari tab but not from the home screen app. In the latter case the camera is opened and only a black screen is shown, hence it is unusable.
 
       &lt;meta name=&quot;apple-mobile-web-app-capable&quot; content=&quot;yes&quot;&gt;
       ...
       &lt;input type=&quot;file&quot; accept=&quot;image/*&quot;&gt;


&lt;h3&gt;WebRTC&lt;/h3&gt;
Safari 11 on iOS11 offers [WebRTC media capture][1] which is great.  

We can capture a camera image to canvas on a normal web page on desktop and mobile using navigator.mediaDevices.getUserMedia per [the sample code linked here][2].  

When we add the page to iPad or iPhone home screen, &lt;code&gt;navigator.mediaDevices&lt;/code&gt; becomes &lt;code&gt;undefined&lt;/code&gt; and unusable. 

        &lt;meta name=&quot;apple-mobile-web-app-capable&quot; content=&quot;yes&quot;&gt;
        ...
        // for some reason safari on mac can debug ios safari page but not ios home screen web apps 
        var d = &#39;typeof navigator : &#39; + typeof navigator; //object
        d += &#39;typeof navigator.mediaDevices : &#39; + typeof navigator.mediaDevices; // undefined
        // try alternates
        d += &#39;typeof navigator.getUserMedia  : &#39; + typeof navigator.getUserMedia; // undefined
        d += &#39;typeof navigator.webkitGetUserMedia  : &#39; + typeof navigator.webkitGetUserMedia; // undefined
        status1.innerHTML = d;

  [1]: https://developer.apple.com/library/content/releasenotes/General/WhatsNewInSafari/Safari_11_0/Safari_11_0.html
  [2]: https://webrtc.github.io/samples/src/content/getusermedia/canvas/


Content Type	Original Author	Original Content on Stackoverflow
Question	user1884325	View Question on Stackoverflow
Solution 1 - C++	ssk	View Answer on Stackoverflow
Solution 2 - C++	Muhammad Faizan	View Answer on Stackoverflow

WebRTC AGC (Automatic Gain Control)

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Implementing two interfaces with two default methods of the same signature in Java 8

Concatenating empty array in Numpy

Attributions