Я не могу преобразовать PNG (RGBA) в JPEG

#include <stdio.h>
#include <stdlib.h>
extern "C" {
  #include "png.h"
  #include "jpeglib.h"
}
 
typedef struct { int w, h, d, t, ps, ts; unsigned char pl[256][3]; unsigned char tr[256]; unsigned char * p; } image_info;
 
int LoadPNG(char * szImage, image_info * pImgInfo)
{
  FILE * f;
  int res = 0;
  pImgInfo->p = 0;
 
  if ((f = fopen(szImage, "rb")) != 0)
  {
    png_structp     png_ptr;
    png_infop       info_ptr;
    png_bytepp      row_ptr = NULL;
    png_uint_32     width, height, i, rowbytes;
    int             depth, coltype, itype;
    unsigned char   sig[8];
 
    if (fread(sig, 1, 8, f) == 8 && png_sig_cmp(sig, 0, 8) == 0)
    {
      png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
 
      if (png_ptr != NULL)
      {
        info_ptr = png_create_info_struct(png_ptr);
 
        if (info_ptr != NULL) 
        {
          if (setjmp(png_jmpbuf(png_ptr)) == 0)
          {
            png_init_io(png_ptr, f);
            png_set_sig_bytes(png_ptr, 8);
            png_read_info(png_ptr, info_ptr);
            png_get_IHDR(png_ptr, info_ptr, &width, &height, &depth, &coltype, &itype, NULL, NULL);
            pImgInfo->w = width;
            pImgInfo->h = height;
            pImgInfo->d = depth;
            pImgInfo->t = coltype;
 
            if (png_get_valid(png_ptr, info_ptr, PNG_INFO_PLTE))
            {
              png_colorp     palette;
 
              png_get_PLTE(png_ptr, info_ptr, &palette, &pImgInfo->ps);
              memcpy(pImgInfo->pl, palette, pImgInfo->ps * 3);
            }
            else
              pImgInfo->ps = 0;
 
            if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
            {
              png_color_16p  trans_color;
              png_bytep      trans_alpha;
 
              png_get_tRNS(png_ptr, info_ptr, &trans_alpha, &pImgInfo->ts, &trans_color);
 
              if (coltype == PNG_COLOR_TYPE_GRAY || coltype == PNG_COLOR_TYPE_RGB)
                memcpy(pImgInfo->tr, trans_color, pImgInfo->ts);
              else
                memcpy(pImgInfo->tr, trans_alpha, pImgInfo->ts);
            }
            else
              pImgInfo->ts = 0;
 
            rowbytes = png_get_rowbytes(png_ptr, info_ptr);
 
            if ((pImgInfo->p = (unsigned char *)malloc(rowbytes*height)) != NULL)
            {
              if ((row_ptr = (png_bytepp)malloc(height * sizeof(png_bytep))) != NULL)
              {
                for (i=0; i<height; i++)
                  row_ptr[i] = pImgInfo->p + i*rowbytes;
 
                png_read_image(png_ptr, row_ptr);
                free(row_ptr);
                png_read_end(png_ptr, NULL);
              }
              else
              {
                res = 7;
                free(pImgInfo->p);
              }
            }
            else
              res = 6;
          }
          else
            res = 5;
 
          png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
        }
        else
        {
          png_destroy_read_struct(&png_ptr, NULL, NULL);
          res = 4;
        }
      }
      else
        res = 3;
    }
    else
      res = 2;
 
    fclose(f);
  }
  else
    res = 1;
 
  return res;
}
 
void SaveJPG(char * szImage, image_info * pImgInfo){
  int i,x,y,a;
  unsigned char * buffer = NULL;
  buffer = (unsigned char *)malloc(pImgInfo->w * pImgInfo->h * 3);
 
  for(x=0;x<pImgInfo->w;x++)
  for(y=0;y<pImgInfo->h;y++)
  {
    a = (x * pImgInfo->h + y)*3;
    buffer[a+0] = pImgInfo->p[a+0];
    buffer[a+1] = pImgInfo->p[a+1];
    buffer[a+2] = pImgInfo->p[a+2];
  }
 
  FILE * f1;
  f1 = fopen(szImage,"wb");
 
  struct jpeg_compress_struct cinfo;
  struct jpeg_error_mgr jerr;
  cinfo.err = jpeg_std_error(&jerr);
  cinfo.image_width = pImgInfo->w;
  cinfo.image_height = pImgInfo->h;
  cinfo.input_components = 3;
  cinfo.in_color_space = JCS_RGB;
  jpeg_create_compress(&cinfo);
  jpeg_stdio_dest(&cinfo, f1);
  jpeg_set_defaults(&cinfo);
  cinfo.comp_info[0].h_samp_factor = 2;
  cinfo.comp_info[0].v_samp_factor = 2;
  cinfo.comp_info[1].h_samp_factor = 1;
  cinfo.comp_info[1].v_samp_factor = 1;
  cinfo.comp_info[2].h_samp_factor = 1;
  cinfo.comp_info[2].v_samp_factor = 1;
  jpeg_set_quality(&cinfo,100,true);
  jpeg_start_compress(&cinfo, TRUE);
 
  JSAMPROW row_pointer[1];
  int row_stride;
  row_stride = pImgInfo->w * 3;
  while (cinfo.next_scanline < cinfo.image_height) {
    row_pointer[0] = & buffer[cinfo.next_scanline * row_stride];
    jpeg_write_scanlines(&cinfo, row_pointer, 1);
  }
  jpeg_finish_compress(&cinfo);
  jpeg_destroy_compress(&cinfo);
  fclose(f1);
  free(buffer);
}
 
void main (int argc, char ** argv) {
  char        * szIn;
  char        * szOut;
  int           res;
  image_info    img1;
 
  szIn  = argv[1];
  szOut = argv[2];
 
  LoadPNG(szIn,&img1);
  SaveJPG(szOut,&img1);
}

getch();

int main(int argc, char ** argv)
...
return 0;