Update Samples (#52)

samples/jpegDecodeMultiThreads/jpegdecodemultithreads.cpp

@@ -23,7 +23,8 @@ THE SOFTWARE.
 #include "../rocjpeg_samples_utils.h"
 
 void ThreadFunction(std::vector<std::string>& jpegFiles, RocJpegHandle rocjpeg_handle, RocJpegStreamHandle rocjpeg_stream, RocJpegUtils rocjpeg_util, RocJpegImage *output_image, std::mutex &mutex,
-    RocJpegDecodeParams &decode_params, bool save_images, std::string &output_file_path, uint64_t *num_decoded_images, double *image_size_in_mpixels) {
+    RocJpegDecodeParams &decode_params, bool save_images, std::string &output_file_path, uint64_t *num_decoded_images, double *image_size_in_mpixels, uint64_t *num_bad_jpegs, uint64_t *num_jpegs_with_411_subsampling,
+    uint64_t *num_jpegs_with_unknown_subsampling, uint64_t *num_jpegs_with_unsupported_resolution) {
 
     bool is_roi_valid = false;
     uint32_t roi_width;
@@ -75,22 +76,32 @@ void ThreadFunction(std::vector<std::string>& jpegFiles, RocJpegHandle rocjpeg_h
             return;
         }
 
-        CHECK_ROCJPEG(rocJpegStreamParse(reinterpret_cast<uint8_t *>(file_data.data()), file_size, rocjpeg_stream));
+        RocJpegStatus rocjpeg_status = rocJpegStreamParse(reinterpret_cast<uint8_t *>(file_data.data()), file_size, rocjpeg_stream);
+        if (rocjpeg_status != ROCJPEG_STATUS_SUCCESS) {
+            std::cerr << "Skipping decoding input file: " << file_path << std::endl;
+            *num_bad_jpegs += 1;
+            continue;
+        }
+
         CHECK_ROCJPEG(rocJpegGetImageInfo(rocjpeg_handle, rocjpeg_stream, &num_components, &subsampling, widths, heights));
         if (roi_width > 0 && roi_height > 0 && roi_width <= widths[0] && roi_height <= heights[0]) {
             is_roi_valid = true; 
         }
 
         if (widths[0] < 64 || heights[0] < 64) {
-            std::cerr << "The image resolution is not supported by VCN Hardware" << std::endl;
-            std::cout << "Skipping decoding file " << base_file_name << std::endl;
-            return;
+            *num_jpegs_with_unsupported_resolution += 1;
+            continue;
         }
 
         if (subsampling == ROCJPEG_CSS_411 || subsampling == ROCJPEG_CSS_UNKNOWN) {
-            std::cerr << "The chroma sub-sampling is not supported by VCN Hardware" << std::endl;
-            std::cout << "Skipping decoding file " << base_file_name << std::endl;
-            return;
+            if (subsampling == ROCJPEG_CSS_411) {
+                *num_jpegs_with_411_subsampling += 1;
+            }
+            if (subsampling == ROCJPEG_CSS_UNKNOWN) {
+                *num_jpegs_with_unknown_subsampling += 1;
+            }
+
+            continue;
         }
 
         if (rocjpeg_util.GetChannelPitchAndSizes(decode_params, subsampling, widths, heights, num_channels, *output_image, channel_sizes)) {
@@ -150,6 +161,10 @@ int main(int argc, char **argv) {
     std::vector<RocJpegImage> rocjpeg_images;
     RocJpegUtils rocjpeg_utils;
     std::vector<std::thread> threads;
+    std::vector<uint64_t> num_bad_jpegs;
+    std::vector<uint64_t> num_jpegs_with_411_subsampling;
+    std::vector<uint64_t> num_jpegs_with_unknown_subsampling;
+    std::vector<uint64_t> num_jpegs_with_unsupported_resolution;
 
     RocJpegUtils::ParseCommandLine(input_path, output_file_path, save_images, device_id, rocjpeg_backend, decode_params, &num_threads, nullptr, argc, argv);
     if (!RocJpegUtils::GetFilePaths(input_path, file_paths, is_dir, is_file)) {
@@ -177,12 +192,16 @@ int main(int argc, char **argv) {
     num_decoded_images_per_thread.resize(num_threads, 0);
     image_size_in_mpixels_per_thread.resize(num_threads, 0);
     rocjpeg_images.resize(num_threads, {0});
+    num_bad_jpegs.resize(num_threads, 0);
+    num_jpegs_with_411_subsampling.resize(num_threads, 0);
+    num_jpegs_with_unknown_subsampling.resize(num_threads, 0);
+    num_jpegs_with_unsupported_resolution.resize(num_threads, 0);
 
     std::cout << "Decoding started with " << num_threads << " threads, please wait!" << std::endl;
     auto start_time = std::chrono::high_resolution_clock::now();
     for (int i = 0; i < num_threads; ++i) {
         threads.emplace_back(ThreadFunction, std::ref(file_paths), rocjpeg_handles[i], rocjpeg_streams[i], rocjpeg_utils, &rocjpeg_images[i], std::ref(mutex), std::ref(decode_params), save_images, std::ref(output_file_path),
-            &num_decoded_images_per_thread[i], &image_size_in_mpixels_per_thread[i]);
+            &num_decoded_images_per_thread[i], &image_size_in_mpixels_per_thread[i], &num_bad_jpegs[i], &num_jpegs_with_411_subsampling[i], &num_jpegs_with_unknown_subsampling[i], &num_jpegs_with_unsupported_resolution[i]);
     }
     for (auto& thread : threads) {
         thread.join();
@@ -192,9 +211,18 @@ int main(int argc, char **argv) {
 
     uint64_t total_decoded_images = 0;
     double total_image_size_in_mpixels = 0;
+    uint64_t total_num_bad_jpegs = 0;
+    uint64_t total_num_jpegs_with_411_subsampling = 0;
+    uint64_t total_num_jpegs_with_unknown_subsampling = 0;
+    uint64_t total_num_jpegs_with_unsupported_resolution = 0;
+
     for (auto i = 0 ; i < num_threads; i++) {
         total_decoded_images += num_decoded_images_per_thread[i];
         total_image_size_in_mpixels += image_size_in_mpixels_per_thread[i];
+        total_num_bad_jpegs += num_bad_jpegs[i];
+        total_num_jpegs_with_411_subsampling += num_jpegs_with_411_subsampling[i];
+        total_num_jpegs_with_unknown_subsampling += num_jpegs_with_unknown_subsampling[i];
+        total_num_jpegs_with_unsupported_resolution += num_jpegs_with_unsupported_resolution[i];
         for (int j = 0; j < ROCJPEG_MAX_COMPONENT; j++) {
             if (rocjpeg_images[i].channel[j] != nullptr) {
                 CHECK_HIP(hipFree((void *)rocjpeg_images[i].channel[j]));
@@ -208,9 +236,28 @@ int main(int argc, char **argv) {
     double avg_image_size_in_mpixels_per_sec = total_image_size_in_mpixels * avg_images_per_sec / total_decoded_images;
     std::cout << "Total elapsed time (ms): " << total_time_in_milli_sec << std::endl;
     std::cout << "Total decoded images: " << total_decoded_images << std::endl;
-    std::cout << "Average processing time per image (ms): " << average_decoding_time_in_milli_sec << std::endl;
-    std::cout << "Average decoded images per sec (Images/Sec): " << avg_images_per_sec << std::endl;
-    std::cout << "Average decoded images size (Mpixels/Sec): " << avg_image_size_in_mpixels_per_sec << std::endl;
+    if (total_num_bad_jpegs || total_num_jpegs_with_411_subsampling || total_num_jpegs_with_unknown_subsampling || total_num_jpegs_with_unsupported_resolution) {
+        std::cout << "Total skipped images: " << total_num_bad_jpegs + total_num_jpegs_with_411_subsampling + total_num_jpegs_with_unknown_subsampling + total_num_jpegs_with_unsupported_resolution;
+        if (total_num_bad_jpegs) {
+            std::cout << " ,total images that cannot be parsed: " << total_num_bad_jpegs;
+        }
+        if (total_num_jpegs_with_411_subsampling) {
+            std::cout << " ,total images with YUV 4:1:1 chroam subsampling: " << total_num_jpegs_with_411_subsampling;
+        }
+        if (total_num_jpegs_with_unknown_subsampling) {
+            std::cout << " ,total images with unknwon chroam subsampling: " << total_num_jpegs_with_unknown_subsampling;
+        }
+        if (total_num_jpegs_with_unsupported_resolution) {
+            std::cout << " ,total images with unsupported_resolution: " << total_num_jpegs_with_unsupported_resolution;
+        }
+        std::cout << std::endl;
+    }
+
+    if (total_decoded_images > 0) {
+        std::cout << "Average processing time per image (ms): " << average_decoding_time_in_milli_sec << std::endl;
+        std::cout << "Average decoded images per sec (Images/Sec): " << avg_images_per_sec << std::endl;
+        std::cout << "Average decoded images size (Mpixels/Sec): " << avg_image_size_in_mpixels_per_sec << std::endl;
+    }
 
     for (auto& handle : rocjpeg_handles) {
         CHECK_ROCJPEG(rocJpegDestroy(handle));