Photoshop Elements does not allow batch process to resolution above 600 dpi

Android 

What is your purpose in outputting to 1200 ppi?  (Or do you mean dpi for printing?)

Nope, 600 ppi is it when resizing.   I even resized the resized ones, didn't matter. 

About resizing:   If your base images are garbage, all you are going to do in make garbage pictures, but larger.
72ppi image original resized to 1200 ppi will produce garbage, for example. 

Equate image resizing to streatching out a ball of dough- like what they do to make pizza crusts.  The original ball can only be stretched so big before something starts to give, in this case, the original image.

HOW IMAGES ARE RESIZED:   It all boils down to math.  When you increase the size of an image alogrythms are applied to image- IN SIMPLE TERMS: The math looks at a pixel, then creates near matches, or perfect matches of that original pixel. 

IN MORE GEEKY TERMS:  A common mathematical algorithm used to enlarge an image is called "bilinear interpolation," which calculates the value of a new pixel by taking a weighted average of the four nearest neighboring pixels in the original image, effectively creating a smoother transition between pixels when scaling up the image size. 

IN EXTREMELY GEEKY TERMS: Belows is a sample of the math that is done to enlarge a pixel based image.

import math

def bilinear_resize(image, height, width😞
  """
  `image` is a 2-D numpy array
  `height` and `width` are the desired spatial dimension of the new 2-D array.
  """
  img_height, img_width = image.shape[:2]

  resized = np.empty([height, width])

  x_ratio = float(img_width - 1) / (width - 1) if width > 1 else 0
  y_ratio = float(img_height - 1) / (height - 1) if height > 1 else 0

  for i in range(height😞
    for j in range(width😞

      x_l, y_l = math.floor(x_ratio * j), math.floor(y_ratio * i)
      x_h, y_h = math.ceil(x_ratio * j), math.ceil(y_ratio * i)

      x_weight = (x_ratio * j) - x_l
      y_weight = (y_ratio * i) - y_l

      a = image[y_l, x_l]
      b = image[y_l, x_h]
      c = image[y_h, x_l]
      d = image[y_h, x_h]

      pixel = a * (1 - x_weight) * (1 - y_weight) \ 
              + b * x_weight * (1 - y_weight) + \
              c * y_weight * (1 - x_weight) + \
              d * x_weight * y_weight

      resized[i][j] = pixel

  return resized

In order to get nice resizes you really need to have the biggest possible images possible.    I have one camera that takes a standard image of around 3400 x 5200- which is fine.  I can double the size, with no noticable difference. You take the height times the width.  the width-- in this case a little over 17MB- that's 17MB of data I have to work with, that I can enlarge.