diff --git a/lib/include/ultrahdr/editorhelper.h b/lib/include/ultrahdr/editorhelper.h
index 610e93df..1dd904a3 100644
--- a/lib/include/ultrahdr/editorhelper.h
+++ b/lib/include/ultrahdr/editorhelper.h
@@ -27,21 +27,17 @@ typedef enum {
 } ultrahdr_mirroring_direction;
 
 status_t crop(jr_uncompressed_ptr const in_img,
-              int left, int right, int top, int bottom, jr_uncompressed_ptr out_img,
-              ultrahdr_pixel_format pix_fmt = ultrahdr_pixel_format::ULTRAHDR_PIX_FMT_YUV420);
+              int left, int right, int top, int bottom, jr_uncompressed_ptr out_img);
 
 status_t mirror(jr_uncompressed_ptr const in_img,
                 ultrahdr_mirroring_direction mirror_dir,
-                jr_uncompressed_ptr out_img,
-                ultrahdr_pixel_format pix_fmt = ultrahdr_pixel_format::ULTRAHDR_PIX_FMT_YUV420);
+                jr_uncompressed_ptr out_img);
 
 status_t rotate(jr_uncompressed_ptr const in_img, int clockwise_degree,
-                jr_uncompressed_ptr out_img,
-                ultrahdr_pixel_format pix_fmt = ultrahdr_pixel_format::ULTRAHDR_PIX_FMT_YUV420);
+                jr_uncompressed_ptr out_img);
 
 status_t resize(jr_uncompressed_ptr const in_img, int out_width, int out_height,
-                jr_uncompressed_ptr out_img,
-                ultrahdr_pixel_format pix_fmt = ultrahdr_pixel_format::ULTRAHDR_PIX_FMT_YUV420);
+                jr_uncompressed_ptr out_img);
 
 }  // namespace ultrahdr
 
diff --git a/lib/include/ultrahdr/jpegr.h b/lib/include/ultrahdr/jpegr.h
index 2435b9d7..40dc56b6 100644
--- a/lib/include/ultrahdr/jpegr.h
+++ b/lib/include/ultrahdr/jpegr.h
@@ -103,6 +103,8 @@ struct jpegr_uncompressed_struct {
   ultrahdr_color_gamut colorGamut;
 
   // Values below are optional
+  // Pixel format.
+  ultrahdr_pixel_format pixelFormat = ULTRAHDR_PIX_FMT_UNSPECIFIED;
   // Pointer to chroma data, if it's NULL, chroma plane is considered to be immediately
   // after the luma plane.
   void* chroma_data = nullptr;
diff --git a/lib/src/editorhelper.cpp b/lib/src/editorhelper.cpp
index e20f50a2..cdbd84e7 100644
--- a/lib/src/editorhelper.cpp
+++ b/lib/src/editorhelper.cpp
@@ -28,8 +28,7 @@ using namespace std;
 namespace ultrahdr {
 status_t crop(jr_uncompressed_ptr const in_img,
               int left, int right, int top, int bottom,
-              jr_uncompressed_ptr out_img,
-              ultrahdr_pixel_format pix_fmt) {
+              jr_uncompressed_ptr out_img) {
   if (in_img == nullptr || in_img->data == nullptr ||
       out_img == nullptr || out_img->data == nullptr) {
     return ERROR_JPEGR_BAD_PTR;
@@ -37,11 +36,13 @@ status_t crop(jr_uncompressed_ptr const in_img,
   if (left < 0 || right >= in_img->width || top < 0 || bottom >= in_img->height) {
     return ERROR_JPEGR_INVALID_CROPPING_PARAMETERS;
   }
-  if (pix_fmt != ULTRAHDR_PIX_FMT_YUV420 && pix_fmt != ULTRAHDR_PIX_FMT_MONOCHROME) {
+  if (in_img->pixelFormat != ULTRAHDR_PIX_FMT_YUV420 &&
+          in_img->pixelFormat != ULTRAHDR_PIX_FMT_MONOCHROME) {
     return ERROR_JPEGR_UNSUPPORTED_FEATURE;
   }
 
   out_img->colorGamut = in_img->colorGamut;
+  out_img->pixelFormat = in_img->pixelFormat;
 
   int in_luma_stride = in_img->luma_stride != 0 ? in_img->luma_stride : in_img->width;
   out_img->width = right - left + 1;
@@ -54,7 +55,7 @@ status_t crop(jr_uncompressed_ptr const in_img,
     memcpy(dest + i * out_img->luma_stride, src + i * in_luma_stride, out_img->width);
   }
 
-  if (pix_fmt == ULTRAHDR_PIX_FMT_MONOCHROME) {
+  if (in_img->pixelFormat == ULTRAHDR_PIX_FMT_MONOCHROME) {
     return JPEGR_NO_ERROR;
   }
 
@@ -79,17 +80,18 @@ status_t crop(jr_uncompressed_ptr const in_img,
 
 status_t mirror(jr_uncompressed_ptr const in_img,
                 ultrahdr_mirroring_direction mirror_dir,
-                jr_uncompressed_ptr out_img,
-                ultrahdr_pixel_format pix_fmt) {
+                jr_uncompressed_ptr out_img) {
   if (in_img == nullptr || in_img->data == nullptr ||
       out_img == nullptr || out_img->data == nullptr) {
     return ERROR_JPEGR_BAD_PTR;
   }
-  if (pix_fmt != ULTRAHDR_PIX_FMT_YUV420 && pix_fmt != ULTRAHDR_PIX_FMT_MONOCHROME) {
+  if (in_img->pixelFormat != ULTRAHDR_PIX_FMT_YUV420 &&
+          in_img->pixelFormat != ULTRAHDR_PIX_FMT_MONOCHROME) {
     return ERROR_JPEGR_UNSUPPORTED_FEATURE;
   }
 
   out_img->colorGamut = in_img->colorGamut;
+  out_img->pixelFormat = in_img->pixelFormat;
 
   int in_luma_stride = in_img->luma_stride != 0 ? in_img->luma_stride : in_img->width;
   out_img->width = in_img->width;
@@ -113,7 +115,7 @@ status_t mirror(jr_uncompressed_ptr const in_img,
     }
   }
 
-  if (pix_fmt == ULTRAHDR_PIX_FMT_MONOCHROME) {
+  if (in_img->pixelFormat == ULTRAHDR_PIX_FMT_MONOCHROME) {
     return JPEGR_NO_ERROR;
   }
 
@@ -171,7 +173,7 @@ status_t mirror(jr_uncompressed_ptr const in_img,
 }
 
 status_t rotate(jr_uncompressed_ptr const in_img, int clockwise_degree,
-                jr_uncompressed_ptr out_img, ultrahdr_pixel_format pix_fmt) {
+                jr_uncompressed_ptr out_img) {
   if (in_img == nullptr || in_img->data == nullptr ||
       out_img == nullptr || out_img->data == nullptr) {
     return ERROR_JPEGR_BAD_PTR;
@@ -179,11 +181,13 @@ status_t rotate(jr_uncompressed_ptr const in_img, int clockwise_degree,
   if (clockwise_degree != 90 && clockwise_degree != 180 && clockwise_degree != 270) {
     return ERROR_JPEGR_INVALID_CROPPING_PARAMETERS;
   }
-  if (pix_fmt != ULTRAHDR_PIX_FMT_YUV420 && pix_fmt != ULTRAHDR_PIX_FMT_MONOCHROME) {
+  if (in_img->pixelFormat != ULTRAHDR_PIX_FMT_YUV420 &&
+          in_img->pixelFormat != ULTRAHDR_PIX_FMT_MONOCHROME) {
     return ERROR_JPEGR_UNSUPPORTED_FEATURE;
   }
 
   out_img->colorGamut = in_img->colorGamut;
+  out_img->pixelFormat = in_img->pixelFormat;
 
   int in_luma_stride = in_img->luma_stride != 0 ? in_img->luma_stride : in_img->width;
   if (clockwise_degree == 90) {
@@ -221,7 +225,7 @@ status_t rotate(jr_uncompressed_ptr const in_img, int clockwise_degree,
     }
   }
 
-  if (pix_fmt == ULTRAHDR_PIX_FMT_MONOCHROME) {
+  if (in_img->pixelFormat == ULTRAHDR_PIX_FMT_MONOCHROME) {
     return JPEGR_NO_ERROR;
   }
 
@@ -305,16 +309,18 @@ status_t rotate(jr_uncompressed_ptr const in_img, int clockwise_degree,
 }
 
 status_t resize(jr_uncompressed_ptr const in_img, int out_width, int out_height,
-                jr_uncompressed_ptr out_img, ultrahdr_pixel_format pix_fmt) {
+                jr_uncompressed_ptr out_img) {
   if (in_img == nullptr || in_img->data == nullptr ||
       out_img == nullptr || out_img->data == nullptr) {
     return ERROR_JPEGR_BAD_PTR;
   }
-  if (pix_fmt != ULTRAHDR_PIX_FMT_YUV420 && pix_fmt != ULTRAHDR_PIX_FMT_MONOCHROME) {
+  if (in_img->pixelFormat != ULTRAHDR_PIX_FMT_YUV420 &&
+          in_img->pixelFormat != ULTRAHDR_PIX_FMT_MONOCHROME) {
     return ERROR_JPEGR_UNSUPPORTED_FEATURE;
   }
 
   out_img->colorGamut = in_img->colorGamut;
+  out_img->pixelFormat = in_img->pixelFormat;
 
   int in_luma_stride = in_img->luma_stride != 0 ? in_img->luma_stride : in_img->width;
   out_img->width = out_width;
@@ -330,7 +336,7 @@ status_t resize(jr_uncompressed_ptr const in_img, int out_width, int out_height,
     }
   }
 
-  if (pix_fmt == ULTRAHDR_PIX_FMT_MONOCHROME) {
+  if (in_img->pixelFormat == ULTRAHDR_PIX_FMT_MONOCHROME) {
     return JPEGR_NO_ERROR;
   }
 
diff --git a/tests/editorhelper_test.cpp b/tests/editorhelper_test.cpp
index a7f3ec1f..7994ef4a 100644
--- a/tests/editorhelper_test.cpp
+++ b/tests/editorhelper_test.cpp
@@ -107,6 +107,7 @@ TEST_F(EditorHelperTest, croppingYuvImage) {
   in_img.width = IMAGE_WIDTH;
   in_img.height = IMAGE_HEIGHT;
   in_img.colorGamut = ultrahdr_color_gamut::ULTRAHDR_COLORGAMUT_BT709;
+  in_img.pixelFormat = ultrahdr_pixel_format::ULTRAHDR_PIX_FMT_YUV420;
 
   std::unique_ptr<uint8_t[]> out_img_data;
   int outSize = out_width * out_height * 3 / 2;
@@ -116,6 +117,7 @@ TEST_F(EditorHelperTest, croppingYuvImage) {
   EXPECT_TRUE(out_img.width = out_width);
   EXPECT_TRUE(out_img.height = out_height);
   EXPECT_TRUE(out_img.colorGamut == in_img.colorGamut);
+  EXPECT_TRUE(out_img.pixelFormat == in_img.pixelFormat);
 #ifdef DUMP_OUTPUT
   if (!writeFile("cropped.yuv", out_img.data, outSize)) {
     std::cerr << "unable to write output file" << std::endl;
@@ -136,15 +138,16 @@ TEST_F(EditorHelperTest, croppingGreyImage) {
   in_img.data = mGreyImage.buffer.get();
   in_img.width = IMAGE_WIDTH;
   in_img.height = IMAGE_HEIGHT;
+  in_img.pixelFormat = ultrahdr_pixel_format::ULTRAHDR_PIX_FMT_MONOCHROME;
 
   std::unique_ptr<uint8_t[]> out_img_data;
   int outSize = out_width * out_height;
   out_img_data.reset(new uint8_t[outSize]);
   out_img.data = out_img_data.get();
-  EXPECT_TRUE(crop(&in_img, left, right, top, bottom, &out_img,
-          ULTRAHDR_PIX_FMT_MONOCHROME)== JPEGR_NO_ERROR);
+  EXPECT_TRUE(crop(&in_img, left, right, top, bottom, &out_img)== JPEGR_NO_ERROR);
   EXPECT_TRUE(out_img.width = out_width);
   EXPECT_TRUE(out_img.height = out_height);
+  EXPECT_TRUE(out_img.pixelFormat == in_img.pixelFormat);
 #ifdef DUMP_OUTPUT
   if (!writeFile("cropped.y", out_img.data, outSize)) {
     std::cerr << "unable to write output file" << std::endl;
@@ -160,6 +163,7 @@ TEST_F(EditorHelperTest, mirroringYuvImageVertical) {
   in_img.width = IMAGE_WIDTH;
   in_img.height = IMAGE_HEIGHT;
   in_img.colorGamut = ultrahdr_color_gamut::ULTRAHDR_COLORGAMUT_BT709;
+  in_img.pixelFormat = ultrahdr_pixel_format::ULTRAHDR_PIX_FMT_YUV420;
 
   std::unique_ptr<uint8_t[]> out_img_data;
   int outSize = IMAGE_WIDTH * IMAGE_HEIGHT * 3 / 2;
@@ -169,6 +173,7 @@ TEST_F(EditorHelperTest, mirroringYuvImageVertical) {
   EXPECT_TRUE(out_img.width = IMAGE_WIDTH);
   EXPECT_TRUE(out_img.height = IMAGE_HEIGHT);
   EXPECT_TRUE(out_img.colorGamut == in_img.colorGamut);
+  EXPECT_TRUE(out_img.pixelFormat == in_img.pixelFormat);
 #ifdef DUMP_OUTPUT
   if (!writeFile("mirrored_vertical.yuv", out_img.data, outSize)) {
     std::cerr << "unable to write output file" << std::endl;
@@ -184,6 +189,7 @@ TEST_F(EditorHelperTest, mirroringYuvImageHorizontal) {
   in_img.width = IMAGE_WIDTH;
   in_img.height = IMAGE_HEIGHT;
   in_img.colorGamut = ultrahdr_color_gamut::ULTRAHDR_COLORGAMUT_BT709;
+  in_img.pixelFormat = ultrahdr_pixel_format::ULTRAHDR_PIX_FMT_YUV420;
 
   std::unique_ptr<uint8_t[]> out_img_data;
   int outSize = IMAGE_WIDTH * IMAGE_HEIGHT * 3 / 2;
@@ -193,6 +199,7 @@ TEST_F(EditorHelperTest, mirroringYuvImageHorizontal) {
   EXPECT_TRUE(out_img.width = IMAGE_WIDTH);
   EXPECT_TRUE(out_img.height = IMAGE_HEIGHT);
   EXPECT_TRUE(out_img.colorGamut == in_img.colorGamut);
+  EXPECT_TRUE(out_img.pixelFormat == in_img.pixelFormat);
 #ifdef DUMP_OUTPUT
   if (!writeFile("mirrored_horizontal.yuv", out_img.data, outSize)) {
     std::cerr << "unable to write output file" << std::endl;
@@ -207,15 +214,16 @@ TEST_F(EditorHelperTest, mirroringGreyImageVertical) {
   in_img.data = mGreyImage.buffer.get();
   in_img.width = IMAGE_WIDTH;
   in_img.height = IMAGE_HEIGHT;
+  in_img.pixelFormat = ultrahdr_pixel_format::ULTRAHDR_PIX_FMT_MONOCHROME;
 
   std::unique_ptr<uint8_t[]> out_img_data;
   int outSize = IMAGE_WIDTH * IMAGE_HEIGHT;
   out_img_data.reset(new uint8_t[outSize]);
   out_img.data = out_img_data.get();
-  EXPECT_TRUE(mirror(&in_img, ULTRAHDR_MIRROR_VERTICAL, &out_img,
-          ULTRAHDR_PIX_FMT_MONOCHROME)== JPEGR_NO_ERROR);
+  EXPECT_TRUE(mirror(&in_img, ULTRAHDR_MIRROR_VERTICAL, &out_img)== JPEGR_NO_ERROR);
   EXPECT_TRUE(out_img.width = IMAGE_WIDTH);
   EXPECT_TRUE(out_img.height = IMAGE_HEIGHT);
+  EXPECT_TRUE(out_img.pixelFormat == in_img.pixelFormat);
 #ifdef DUMP_OUTPUT
   if (!writeFile("mirrored_vertical.y", out_img.data, outSize)) {
     std::cerr << "unable to write output file" << std::endl;
@@ -230,15 +238,16 @@ TEST_F(EditorHelperTest, mirroringGreyImageHorizontal) {
   in_img.data = mGreyImage.buffer.get();
   in_img.width = IMAGE_WIDTH;
   in_img.height = IMAGE_HEIGHT;
+  in_img.pixelFormat = ultrahdr_pixel_format::ULTRAHDR_PIX_FMT_MONOCHROME;
 
   std::unique_ptr<uint8_t[]> out_img_data;
   int outSize = IMAGE_WIDTH * IMAGE_HEIGHT;
   out_img_data.reset(new uint8_t[outSize]);
   out_img.data = out_img_data.get();
-  EXPECT_TRUE(mirror(&in_img, ULTRAHDR_MIRROR_HORIZONTAL, &out_img,
-          ULTRAHDR_PIX_FMT_MONOCHROME)== JPEGR_NO_ERROR);
+  EXPECT_TRUE(mirror(&in_img, ULTRAHDR_MIRROR_HORIZONTAL, &out_img)== JPEGR_NO_ERROR);
   EXPECT_TRUE(out_img.width = IMAGE_WIDTH);
   EXPECT_TRUE(out_img.height = IMAGE_HEIGHT);
+  EXPECT_TRUE(out_img.pixelFormat == in_img.pixelFormat);
 #ifdef DUMP_OUTPUT
   if (!writeFile("mirrored_horizontal.y", out_img.data, outSize)) {
     std::cerr << "unable to write output file" << std::endl;
@@ -254,6 +263,7 @@ TEST_F(EditorHelperTest, rotatingYuvImage90) {
   in_img.width = IMAGE_WIDTH;
   in_img.height = IMAGE_HEIGHT;
   in_img.colorGamut = ultrahdr_color_gamut::ULTRAHDR_COLORGAMUT_BT709;
+  in_img.pixelFormat = ultrahdr_pixel_format::ULTRAHDR_PIX_FMT_YUV420;
 
   std::unique_ptr<uint8_t[]> out_img_data;
   int outSize = IMAGE_WIDTH * IMAGE_HEIGHT * 3 / 2;
@@ -263,6 +273,7 @@ TEST_F(EditorHelperTest, rotatingYuvImage90) {
   EXPECT_TRUE(out_img.width = IMAGE_HEIGHT);
   EXPECT_TRUE(out_img.height = IMAGE_WIDTH);
   EXPECT_TRUE(out_img.colorGamut == in_img.colorGamut);
+  EXPECT_TRUE(out_img.pixelFormat == in_img.pixelFormat);
 #ifdef DUMP_OUTPUT
   if (!writeFile("rotated_90.yuv", out_img.data, outSize)) {
     std::cerr << "unable to write output file" << std::endl;
@@ -278,6 +289,7 @@ TEST_F(EditorHelperTest, rotatingYuvImage180) {
   in_img.width = IMAGE_WIDTH;
   in_img.height = IMAGE_HEIGHT;
   in_img.colorGamut = ultrahdr_color_gamut::ULTRAHDR_COLORGAMUT_BT709;
+  in_img.pixelFormat = ultrahdr_pixel_format::ULTRAHDR_PIX_FMT_YUV420;
 
   std::unique_ptr<uint8_t[]> out_img_data;
   int outSize = IMAGE_WIDTH * IMAGE_HEIGHT * 3 / 2;
@@ -287,6 +299,7 @@ TEST_F(EditorHelperTest, rotatingYuvImage180) {
   EXPECT_TRUE(out_img.width = IMAGE_WIDTH);
   EXPECT_TRUE(out_img.height = IMAGE_HEIGHT);
   EXPECT_TRUE(out_img.colorGamut == in_img.colorGamut);
+  EXPECT_TRUE(out_img.pixelFormat == in_img.pixelFormat);
 #ifdef DUMP_OUTPUT
   if (!writeFile("rotated_180.yuv", out_img.data, outSize)) {
     std::cerr << "unable to write output file" << std::endl;
@@ -302,6 +315,7 @@ TEST_F(EditorHelperTest, rotatingYuvImage270) {
   in_img.width = IMAGE_WIDTH;
   in_img.height = IMAGE_HEIGHT;
   in_img.colorGamut = ultrahdr_color_gamut::ULTRAHDR_COLORGAMUT_BT709;
+  in_img.pixelFormat = ultrahdr_pixel_format::ULTRAHDR_PIX_FMT_YUV420;
 
   std::unique_ptr<uint8_t[]> out_img_data;
   int outSize = IMAGE_WIDTH * IMAGE_HEIGHT * 3 / 2;
@@ -311,6 +325,7 @@ TEST_F(EditorHelperTest, rotatingYuvImage270) {
   EXPECT_TRUE(out_img.width = IMAGE_HEIGHT);
   EXPECT_TRUE(out_img.height = IMAGE_WIDTH);
   EXPECT_TRUE(out_img.colorGamut == in_img.colorGamut);
+  EXPECT_TRUE(out_img.pixelFormat == in_img.pixelFormat);
 #ifdef DUMP_OUTPUT
   if (!writeFile("rotated_270.yuv", out_img.data, outSize)) {
     std::cerr << "unable to write output file" << std::endl;
@@ -325,14 +340,16 @@ TEST_F(EditorHelperTest, rotatingGreyImage90) {
   in_img.data = mGreyImage.buffer.get();
   in_img.width = IMAGE_WIDTH;
   in_img.height = IMAGE_HEIGHT;
+  in_img.pixelFormat = ultrahdr_pixel_format::ULTRAHDR_PIX_FMT_MONOCHROME;
 
   std::unique_ptr<uint8_t[]> out_img_data;
   int outSize = IMAGE_WIDTH * IMAGE_HEIGHT;
   out_img_data.reset(new uint8_t[outSize]);
   out_img.data = out_img_data.get();
-  EXPECT_TRUE(rotate(&in_img, 90, &out_img, ULTRAHDR_PIX_FMT_MONOCHROME)== JPEGR_NO_ERROR);
+  EXPECT_TRUE(rotate(&in_img, 90, &out_img)== JPEGR_NO_ERROR);
   EXPECT_TRUE(out_img.width = IMAGE_HEIGHT);
   EXPECT_TRUE(out_img.height = IMAGE_WIDTH);
+  EXPECT_TRUE(out_img.pixelFormat == in_img.pixelFormat);
 #ifdef DUMP_OUTPUT
   if (!writeFile("rotated_90.y", out_img.data, outSize)) {
     std::cerr << "unable to write output file" << std::endl;
@@ -347,14 +364,16 @@ TEST_F(EditorHelperTest, rotatingGreyImage180) {
   in_img.data = mGreyImage.buffer.get();
   in_img.width = IMAGE_WIDTH;
   in_img.height = IMAGE_HEIGHT;
+  in_img.pixelFormat = ultrahdr_pixel_format::ULTRAHDR_PIX_FMT_MONOCHROME;
 
   std::unique_ptr<uint8_t[]> out_img_data;
   int outSize = IMAGE_WIDTH * IMAGE_HEIGHT;
   out_img_data.reset(new uint8_t[outSize]);
   out_img.data = out_img_data.get();
-  EXPECT_TRUE(rotate(&in_img, 180, &out_img, ULTRAHDR_PIX_FMT_MONOCHROME)== JPEGR_NO_ERROR);
+  EXPECT_TRUE(rotate(&in_img, 180, &out_img)== JPEGR_NO_ERROR);
   EXPECT_TRUE(out_img.width = IMAGE_WIDTH);
   EXPECT_TRUE(out_img.height = IMAGE_HEIGHT);
+  EXPECT_TRUE(out_img.pixelFormat == in_img.pixelFormat);
 #ifdef DUMP_OUTPUT
   if (!writeFile("rotated_180.y", out_img.data, outSize)) {
     std::cerr << "unable to write output file" << std::endl;
@@ -369,14 +388,16 @@ TEST_F(EditorHelperTest, rotatingGreyImage270) {
   in_img.data = mGreyImage.buffer.get();
   in_img.width = IMAGE_WIDTH;
   in_img.height = IMAGE_HEIGHT;
+  in_img.pixelFormat = ultrahdr_pixel_format::ULTRAHDR_PIX_FMT_MONOCHROME;
 
   std::unique_ptr<uint8_t[]> out_img_data;
   int outSize = IMAGE_WIDTH * IMAGE_HEIGHT;
   out_img_data.reset(new uint8_t[outSize]);
   out_img.data = out_img_data.get();
-  EXPECT_TRUE(rotate(&in_img, 270, &out_img, ULTRAHDR_PIX_FMT_MONOCHROME)== JPEGR_NO_ERROR);
+  EXPECT_TRUE(rotate(&in_img, 270, &out_img)== JPEGR_NO_ERROR);
   EXPECT_TRUE(out_img.width = IMAGE_HEIGHT);
   EXPECT_TRUE(out_img.height = IMAGE_WIDTH);
+  EXPECT_TRUE(out_img.pixelFormat == in_img.pixelFormat);
 #ifdef DUMP_OUTPUT
   if (!writeFile("rotated_270.y", out_img.data, outSize)) {
     std::cerr << "unable to write output file" << std::endl;
@@ -391,6 +412,8 @@ TEST_F(EditorHelperTest, resizeYuvImageUp) {
   in_img.data = mYuvImage.buffer.get();
   in_img.width = IMAGE_WIDTH;
   in_img.height = IMAGE_HEIGHT;
+  in_img.colorGamut = ultrahdr_color_gamut::ULTRAHDR_COLORGAMUT_BT709;
+  in_img.pixelFormat = ultrahdr_pixel_format::ULTRAHDR_PIX_FMT_YUV420;
 
   std::unique_ptr<uint8_t[]> out_img_data;
   int out_width = IMAGE_WIDTH * 3 / 2;
@@ -401,6 +424,8 @@ TEST_F(EditorHelperTest, resizeYuvImageUp) {
   EXPECT_TRUE(resize(&in_img, out_width, out_height, &out_img)== JPEGR_NO_ERROR);
   EXPECT_TRUE(out_img.width = out_width);
   EXPECT_TRUE(out_img.height = out_height);
+  EXPECT_TRUE(out_img.colorGamut == in_img.colorGamut);
+  EXPECT_TRUE(out_img.pixelFormat == in_img.pixelFormat);
 #ifdef DUMP_OUTPUT
   if (!writeFile("resize_up.yuv", out_img.data, outSize)) {
     std::cerr << "unable to write output file" << std::endl;
@@ -415,6 +440,8 @@ TEST_F(EditorHelperTest, resizeYuvImageDown) {
   in_img.data = mYuvImage.buffer.get();
   in_img.width = IMAGE_WIDTH;
   in_img.height = IMAGE_HEIGHT;
+  in_img.colorGamut = ultrahdr_color_gamut::ULTRAHDR_COLORGAMUT_BT709;
+  in_img.pixelFormat = ultrahdr_pixel_format::ULTRAHDR_PIX_FMT_YUV420;
 
   std::unique_ptr<uint8_t[]> out_img_data;
   int out_width = IMAGE_WIDTH * 2 / 3;
@@ -425,6 +452,7 @@ TEST_F(EditorHelperTest, resizeYuvImageDown) {
   EXPECT_TRUE(resize(&in_img, out_width, out_height, &out_img)== JPEGR_NO_ERROR);
   EXPECT_TRUE(out_img.width = out_width);
   EXPECT_TRUE(out_img.height = out_height);
+  EXPECT_TRUE(out_img.pixelFormat == in_img.pixelFormat);
 #ifdef DUMP_OUTPUT
   if (!writeFile("resize_down.yuv", out_img.data, outSize)) {
     std::cerr << "unable to write output file" << std::endl;
@@ -439,6 +467,7 @@ TEST_F(EditorHelperTest, resizeGreyImageUp) {
   in_img.data = mGreyImage.buffer.get();
   in_img.width = IMAGE_WIDTH;
   in_img.height = IMAGE_HEIGHT;
+  in_img.pixelFormat = ultrahdr_pixel_format::ULTRAHDR_PIX_FMT_MONOCHROME;
 
   std::unique_ptr<uint8_t[]> out_img_data;
   int out_width = IMAGE_WIDTH * 3 / 2;
@@ -446,10 +475,10 @@ TEST_F(EditorHelperTest, resizeGreyImageUp) {
   int outSize = out_width * out_height;
   out_img_data.reset(new uint8_t[outSize]);
   out_img.data = out_img_data.get();
-  EXPECT_TRUE(resize(&in_img, out_width, out_height, &out_img,
-          ULTRAHDR_PIX_FMT_MONOCHROME)== JPEGR_NO_ERROR);
+  EXPECT_TRUE(resize(&in_img, out_width, out_height, &out_img)== JPEGR_NO_ERROR);
   EXPECT_TRUE(out_img.width = out_width);
   EXPECT_TRUE(out_img.height = out_height);
+  EXPECT_TRUE(out_img.pixelFormat == in_img.pixelFormat);
 #ifdef DUMP_OUTPUT
   if (!writeFile("resize_up.y", out_img.data, outSize)) {
     std::cerr << "unable to write output file" << std::endl;
@@ -464,6 +493,7 @@ TEST_F(EditorHelperTest, resizeGreyImageDown) {
   in_img.data = mGreyImage.buffer.get();
   in_img.width = IMAGE_WIDTH;
   in_img.height = IMAGE_HEIGHT;
+  in_img.pixelFormat = ultrahdr_pixel_format::ULTRAHDR_PIX_FMT_MONOCHROME;
 
   std::unique_ptr<uint8_t[]> out_img_data;
   int out_width = IMAGE_WIDTH * 2 / 3;
@@ -471,10 +501,10 @@ TEST_F(EditorHelperTest, resizeGreyImageDown) {
   int outSize = out_width * out_height;
   out_img_data.reset(new uint8_t[outSize]);
   out_img.data = out_img_data.get();
-  EXPECT_TRUE(resize(&in_img, out_width, out_height, &out_img,
-          ULTRAHDR_PIX_FMT_MONOCHROME)== JPEGR_NO_ERROR);
+  EXPECT_TRUE(resize(&in_img, out_width, out_height, &out_img)== JPEGR_NO_ERROR);
   EXPECT_TRUE(out_img.width = out_width);
   EXPECT_TRUE(out_img.height = out_height);
+  EXPECT_TRUE(out_img.pixelFormat == in_img.pixelFormat);
 #ifdef DUMP_OUTPUT
   if (!writeFile("resize_down.y", out_img.data, outSize)) {
     std::cerr << "unable to write output file" << std::endl;