title: What do the parameters of stb_png_to_mem mean?
body: <p>I am using the stb libraries to load textures on the fly for OpenGL. I'm trying to use the function from stb_image_write.h. I cannot find any documentation on how to properly use the function <code>stbi_write_png_to_mem</code> my code looks like the following</p>
  
  <pre><code>#ifndef STB_IMAGE_WRITE_IMPLEMENTATION
  #define STB_IMAGE_WRITE_IMPLEMENTATION
  #include &lt;stb/stb_image_write.h&gt; 
  
  int main(  )
  {
      // data is filled in later in program
      int size , width , height ; 
      unsigned char* data = ( unsigned char* ) malloc( width * height ) ;
  
      ...
      ...
      ...
  
  
      // this is where the issue lies
      stbi_write_png_to_mem(  ) ; 
  
  }
  
  </code></pre>
  
  <p>I've looked on github and through the source itself. I cannot find anything on google. I am not sure what the inputs to this function is needing as nothing is clear what anything means. the source to the function is </p>
  
  <pre><code>STBIWDEF unsigned char *stbi_write_png_to_mem(const unsigned char *pixels, int stride_bytes, int x, int y, int n, int *out_len)
  {
     int force_filter = stbi_write_force_png_filter;
     int ctype[5] = { -1, 0, 4, 2, 6 };
     unsigned char sig[8] = { 137,80,78,71,13,10,26,10 };
     unsigned char *out,*o, *filt, *zlib;
     signed char *line_buffer;
     int j,zlen;
  
     if (stride_bytes == 0)
        stride_bytes = x * n;
  
     if (force_filter &gt;= 5) {
        force_filter = -1;
     }
  
     filt = (unsigned char *) STBIW_MALLOC((x*n+1) * y); if (!filt) return 0;
     line_buffer = (signed char *) STBIW_MALLOC(x * n); if (!line_buffer) { STBIW_FREE(filt); return 0; }
     for (j=0; j &lt; y; ++j) {
        int filter_type;
        if (force_filter &gt; -1) {
           filter_type = force_filter;
           stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, force_filter, line_buffer);
        } else { // Estimate the best filter by running through all of them:
           int best_filter = 0, best_filter_val = 0x7fffffff, est, i;
           for (filter_type = 0; filter_type &lt; 5; filter_type++) {
              stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, filter_type, line_buffer);
  
              // Estimate the entropy of the line using this filter; the less, the better.
              est = 0;
              for (i = 0; i &lt; x*n; ++i) {
                 est += abs((signed char) line_buffer[i]);
              }
              if (est &lt; best_filter_val) {
                 best_filter_val = est;
                 best_filter = filter_type;
              }
           }
           if (filter_type != best_filter) {  // If the last iteration already got us the best filter, don't redo it
              stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, best_filter, line_buffer);
              filter_type = best_filter;
           }
        }
        // when we get here, filter_type contains the filter type, and line_buffer contains the data
        filt[j*(x*n+1)] = (unsigned char) filter_type;
        STBIW_MEMMOVE(filt+j*(x*n+1)+1, line_buffer, x*n);
     }
     STBIW_FREE(line_buffer);
     zlib = stbi_zlib_compress(filt, y*( x*n+1), &amp;zlen, stbi_write_png_compression_level);
     STBIW_FREE(filt);
     if (!zlib) return 0;
  
     // each tag requires 12 bytes of overhead
     out = (unsigned char *) STBIW_MALLOC(8 + 12+13 + 12+zlen + 12);
     if (!out) return 0;
     *out_len = 8 + 12+13 + 12+zlen + 12;
  
     o=out;
     STBIW_MEMMOVE(o,sig,8); o+= 8;
     stbiw__wp32(o, 13); // header length
     stbiw__wptag(o, "IHDR");
     stbiw__wp32(o, x);
     stbiw__wp32(o, y);
     *o++ = 8;
     *o++ = STBIW_UCHAR(ctype[n]);
     *o++ = 0;
     *o++ = 0;
     *o++ = 0;
     stbiw__wpcrc(&amp;o,13);
  
     stbiw__wp32(o, zlen);
     stbiw__wptag(o, "IDAT");
     STBIW_MEMMOVE(o, zlib, zlen);
     o += zlen;
     STBIW_FREE(zlib);
     stbiw__wpcrc(&amp;o, zlen);
  
     stbiw__wp32(o,0);
     stbiw__wptag(o, "IEND");
     stbiw__wpcrc(&amp;o,0);
  
     STBIW_ASSERT(o == out + *out_len);
  
     return out;
  }
  </code></pre>
  
  <p>My goal is to essentially output my picture data to a png in memory, not a file, so I can use it elsewhere in my program formatted like a png would be.</p>