diff --git a/tools/convexhull_framework/src/CalcBDRate.py b/tools/convexhull_framework/src/CalcBDRate.py
new file mode 100644
index 0000000..df5ff42
--- /dev/null
+++ b/tools/convexhull_framework/src/CalcBDRate.py
@@ -0,0 +1,88 @@
+#!/usr/bin/env python
+## Copyright (c) 2019, Alliance for Open Media. All rights reserved
+##
+## This source code is subject to the terms of the BSD 2 Clause License and
+## the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
+## was not distributed with this source code in the LICENSE file, you can
+## obtain it at www.aomedia.org/license/software. If the Alliance for Open
+## Media Patent License 1.0 was not distributed with this source code in the
+## PATENTS file, you can obtain it at www.aomedia.org/license/patent.
+##
+__author__ = "maggie.sun@intel.com, ryan.lei@intel.com"
+
+import numpy
+import math
+import scipy.interpolate
+import logging
+from Config import LoggerName
+
+subloggername = "CalcBDRate"
+loggername = LoggerName + '.' + '%s' % subloggername
+logger = logging.getLogger(loggername)
+
+# BJONTEGAARD    Bjontegaard metric
+# Calculation is adapted from Google implementation
+# PCHIP method - Piecewise Cubic Hermite Interpolating Polynomial interpolation
+def BD_RATE(br1, qtyMtrc1, br2, qtyMtrc2):
+    brqtypairs1 = [(br1[i], qtyMtrc1[i]) for i in range(min(len(qtyMtrc1), len(br1)))]
+    brqtypairs2 = [(br2[i], qtyMtrc2[i]) for i in range(min(len(qtyMtrc2), len(br2)))]
+
+    if not brqtypairs1 or not brqtypairs2:
+        logger.info("one of input lists is empty!")
+        return 0.0
+
+    # sort the pair based on quality metric values increasing order
+    brqtypairs1.sort(key=lambda tup: tup[1])
+    brqtypairs2.sort(key=lambda tup: tup[1])
+
+    logbr1 = [math.log(x[0]) for x in brqtypairs1]
+    qmetrics1 = [100.0 if x[1] == float('inf') else x[1] for x in brqtypairs1]
+    logbr2 = [math.log(x[0]) for x in brqtypairs2]
+    qmetrics2 = [100.0 if x[1] == float('inf') else x[1] for x in brqtypairs2]
+
+    # remove duplicated quality metric value
+    dup_idx = [i for i in range(1, len(qmetrics1)) if qmetrics1[i - 1] == qmetrics1[i]]
+    for idx in sorted(dup_idx, reverse=True):
+        del qmetrics1[idx]
+        del logbr1[idx]
+    dup_idx = [i for i in range(1, len(qmetrics2)) if qmetrics2[i - 1] == qmetrics2[i]]
+    for idx in sorted(dup_idx, reverse=True):
+        del qmetrics2[idx]
+        del logbr2[idx]
+
+    # find max and min of quality metrics
+    min_int = max(min(qmetrics1), min(qmetrics2))
+    max_int = min(max(qmetrics1), max(qmetrics2))
+    if min_int >= max_int:
+        logger.info("no overlap from input 2 lists of quality metrics!")
+        return 0.0
+
+    # generate samples between max and min of quality metrics
+    lin = numpy.linspace(min_int, max_int, num=100, retstep=True)
+    interval = lin[1]
+    samples = lin[0]
+
+    # interpolation
+    v1 = scipy.interpolate.pchip_interpolate(qmetrics1, logbr1, samples)
+    v2 = scipy.interpolate.pchip_interpolate(qmetrics2, logbr2, samples)
+
+    # Calculate the integral using the trapezoid method on the samples.
+    int1 = numpy.trapz(v1, dx=interval)
+    int2 = numpy.trapz(v2, dx=interval)
+
+    # find avg diff
+    avg_exp_diff = (int2 - int1) / (max_int - min_int)
+    avg_diff = (math.exp(avg_exp_diff) - 1) * 100
+
+    return avg_diff
+
+'''
+if __name__ == "__main__":
+    brs1 = [64052.664, 6468.096, 4673.424, 3179.4, 2298.384, 1361.184]
+    qtys1 = [1, 1, 0.99999, 0.99998, 0.99996, 0.99992]
+    brs2 = [68461.896, 7554.96, 4827.432, 3294.024, 2380.128, 1401.744]
+    qtys2 = [1, 1, 0.99999, 0.99998, 0.99996, 0.99992]
+
+    bdrate = BD_RATE(brs1, qtys1, brs2, qtys2)
+    print("bdrate calculated is %3.3f%%" % bdrate)
+'''
diff --git a/tools/convexhull_framework/src/Config.py b/tools/convexhull_framework/src/Config.py
index 5a6ebb0..53281f3 100644
--- a/tools/convexhull_framework/src/Config.py
+++ b/tools/convexhull_framework/src/Config.py
@@ -19,7 +19,7 @@
 BinPath = os.path.join(RootPath, 'bin')
 WorkPath = os.path.join(RootPath, 'test')
 SMOKE_TEST = False  # override some parameters to do a quick smoke test
-FrameNum = 60
+FrameNum = 10
 
 if SMOKE_TEST:
     FrameNum = 2
@@ -34,8 +34,9 @@
 #    basename           class      width   height  framerate   bitdepth    fmt
     #"CrowdRun":         ["ClassB",  1920,   1080,   30,     8,      "yuv420p"],
     #"BasketballDrive":  ["ClassB",  1920,   1080,   30,     8,      "yuv420p"],
-    "NetflixCrosswalk_1920x1080_60fps_8bit_420_60f":    ["ClassB",  1920,   1080,
-     30,         8,          "yuv420p"],
+    #"NetflixCrosswalk_1920x1080_60fps_8bit_420_60f":    ["ClassB",  1920,   1080,
+    #30,         8,          "yuv420p"],
+    "CrowdRun_1920x1080":    ["ClassB",  1920,   1080,   30,  8,    "yuv420p"],
 }
 '''
     "aspen_1080p_60f":  ["ClassB",  1920,   1080,   30,         8,
@@ -85,10 +86,10 @@
 '''
 ############## Scaling settings ############################################
 # down scaling ratio
-DnScaleRatio = [1.0, 1.5, 2.0, 3.0, 4.0] #, 6.0]  # downscale ratio
+DnScaleRatio = [1.0, 1.5, 2.0, 2.5, 3.0, 4.0] #, 6.0]  # downscale ratio
 #down and up scaling algorithm, the 2 lists should be of same size
-DnScalingAlgos = ['bicubic', 'bilinear', 'gauss', 'lanczos', 'sinc']
-UpScalingAlgos = ['bicubic', 'bilinear', 'gauss', 'lanczos', 'sinc']
+DnScalingAlgos = ['lanczos'] #['bicubic', 'bilinear', 'gauss', 'lanczos', 'sinc']
+UpScalingAlgos = ['lanczos'] #['bicubic', 'bilinear', 'gauss', 'lanczos', 'sinc']
 
 if SMOKE_TEST:
     DnScalingAlgos = ['bicubic', 'lanczos', 'sinc']
@@ -115,6 +116,7 @@
                       'HDRTools']
 VMAF = os.path.join(BinPath, 'vmafossexec.exe')
 HDRTool = os.path.join(BinPath, 'HDRMetrics.exe')
+CalcBDRateInExcel = False
 
 ######################## config for exporting data to excel  #################
 #https://xlsxwriter.readthedocs.io/working_with_colors.html#colors
@@ -122,6 +124,10 @@
 LineColors = ['blue', 'red', 'green', 'orange', 'pink', 'yellow']
 ConvexHullColor = 'white'
 
+# find out QP/Resolution with specified qty metrics
+TargetQtyMetrics = {'VMAF_Y': [60, 70, 80, 90],
+                    'PSNR_Y': [30, 35, 38, 40, 41]}
+
 # format for exported excel of convexhull test
 # if to modify below 3 variables, need to modify function
 # SaveConvexHullResultsToExcel accordingly
@@ -131,6 +137,12 @@
 CvxH_WtRows = [CvxH_startRow + i for i in range(len(QPs))]
 CvxH_WtLastCol = CvxH_WtCols[-1] + len(QualityList)
 CvxH_WtLastRow = CvxH_WtRows[-1]
+
+# format for writing convexhull curve data
+CvxHDataStartRow = CvxH_WtRows[-1] + 2; CvxHDataStartCol = 0
+CvxHDataNum = 5  # qty, bitrate, qp, resolution, 1 empty row as internal
+CvxHDataRows = [CvxHDataStartRow + 1 + CvxHDataNum * i for i in range(len(QualityList))]
+
 ######################## post analysis #########################################
 PostAnalysis_Path = os.path.join(RootPath, 'analysis')
 Path_RDResults = os.path.join(PostAnalysis_Path, 'rdresult')
diff --git a/tools/convexhull_framework/src/ConvexHullBDRate.py b/tools/convexhull_framework/src/ConvexHullBDRate.py
index 26bc858..04fb1f9 100644
--- a/tools/convexhull_framework/src/ConvexHullBDRate.py
+++ b/tools/convexhull_framework/src/ConvexHullBDRate.py
@@ -14,19 +14,23 @@
 import xlsxwriter
 import xlrd
 import argparse
-from Config import VbaBinFile, QualityList
+from Config import VbaBinFile, QualityList, CalcBDRateInExcel
+from CalcBDRate import BD_RATE
+
 
 class ConvexHullData:
     ContentName = ""
     ContentClass = ""
     NumRDPoints = 0
     RDPoints = {}
+
     def __init__(self, Name="", Class="", num=0):
         self.ContentName = Name
         self.ContentClass = Class
         self.NumRDPoints = num
         self.RDPoints = {}
 
+
 def ParseArguments(raw_args):
     parser = argparse.ArgumentParser(prog='ConvexHullBDRate.py',
                                      usage='%(prog)s [options]', description='')
@@ -50,6 +54,7 @@
     InputTarget = args.Input2
     Output = args.Output
 
+
 def read_cell_as_str(sht, row, col):
     cell_val = sht.cell(row, col).value
     if cell_val == '':
@@ -57,6 +62,7 @@
     else:
         return str(cell_val)
 
+
 def read_cell_as_float(sht, row, col):
     cell_val = sht.cell(row, col).value
     if cell_val == '':
@@ -64,6 +70,7 @@
     else:
         return float(cell_val)
 
+
 def read_cell_as_int(sht, row, col):
     cell_val = sht.cell(row, col).value
     if cell_val == '':
@@ -71,67 +78,73 @@
     else:
         return int(cell_val)
 
+
 def ParseConvexHullRD(xls):
     wb = xlrd.open_workbook(xls)
     shts = wb.sheet_names()   #list of sheet names
     data = {}   #dict of data, key is the sheet name
 
+    cols = [3 + i * 4 for i in range(len(QualityList))]
     for sht_name in shts:
         sht = wb.sheet_by_name(sht_name)
         #skip the title row
         rows = sht.nrows
-        cols = sht.ncols
         start_row = 1
         while start_row < rows:
             row = start_row
             cls = read_cell_as_str(sht, row, 0)
             name = read_cell_as_str(sht, row, 1)
             num = read_cell_as_int(sht, row, 2)
-            if (cls == '' or name == '' or num == ''):
+            if cls == '' or name == '' or num == '':
                 print("Error: read empty cells")
                 exit()
 
             point = ConvexHullData(name, cls, num)
-
             rd_data = {}
             for row in range(num):
-                col = 3
-                for qty in QualityList:
-                    br = read_cell_as_float(sht, start_row+row, col)
-                    q = read_cell_as_float(sht, start_row+row, col + 1)
-                    if (br != '' and q != ''):
-                        if (qty in rd_data.keys()):
-                            rd_data[qty].append((br, q))
+                for qty, col in zip(QualityList, cols):
+                    res = read_cell_as_str(sht, start_row+row, col)         #Resolution
+                    qp  = read_cell_as_int(sht, start_row+row, col + 1)     #QP
+                    br  = read_cell_as_float(sht, start_row+row, col + 2)   #Bitrate
+                    q   = read_cell_as_float(sht, start_row+row, col + 3)   #Quality
+                    if br != '' and q != '':
+                        if qty in rd_data:
+                            rd_data[qty].append((res, qp, br, q))
                         else:
-                            rd_data.update({qty:[(br, q)]})
-                    col += 2
+                            rd_data.update({qty: [(res, qp, br, q)]})
+
             start_row += num
             point.RDPoints = rd_data
-            if (sht_name in data.keys()):
+            if sht_name in data:
                 data[sht_name].append(point)
             else:
                 data.update({sht_name: [point]})
 
-    #wb.close()
     return shts, data
 
+
 def WriteOutputHeaderRow(sht):
     sht.write(0, 0, 'Content Class')
     sht.write(0, 1, 'Content Name')
     sht.write(0, 2, 'Num RD Points')
     col = 3
     for qty in QualityList:
-        sht.write(0, col, 'Bitrate(kbps)')
-        sht.write(0, col + 1, qty)
-        col += 2
+        sht.write(0, col, 'Resolution')
+        sht.write(0, col + 1, 'QP')
+        sht.write(0, col + 2, 'Bitrate(kbps)')
+        sht.write(0, col + 3, qty)
+        col += 4
     col += 1
     for qty in QualityList:
-        sht.write(0, col, 'Bitrate(kbps)')
-        sht.write(0, col + 1, qty)
-        col += 2
+        sht.write(0, col, 'Resolution')
+        sht.write(0, col + 1, 'QP')
+        sht.write(0, col + 2, 'Bitrate(kbps)')
+        sht.write(0, col + 3, qty)
+        col += 4
     col += 1
     for (idx, qty) in zip(range(len(QualityList)), QualityList):
-        sht.write(0, col + idx, "BDRATE-%s"%qty)
+        sht.write(0, col + idx, "BDRATE-%s" % qty)
+
 
 def WriteRDData(sht, rd_data, start_row, start_col, format):
     col = start_col
@@ -140,12 +153,15 @@
         row = start_row
         for (line, point) in zip(range(len(rd_data.RDPoints[qty])),
                                  rd_data.RDPoints[qty]):
-            sht.write_number(row + line, col, point[0], format)
-            sht.write_number(row + line, col + 1, point[1], format)
-        col += 2
+            sht.write_string(row + line, col, point[0])                #Resolution
+            sht.write_number(row + line, col + 1, point[1])            #QP
+            sht.write_number(row + line, col + 2, point[2], format)    #Bitrate
+            sht.write_number(row + line, col + 3, point[3], format)    #Quality
+        col += 4
         max_rows = max(max_rows, len(rd_data.RDPoints[qty]))
     return max_rows
 
+
 def WriteRDRecord(sht, base_data, target_data, start_row, bdrate_fmt, float_fmt):
     sht.write(start_row, 0, base_data.ContentClass)
     sht.write(start_row, 1, base_data.ContentName)
@@ -156,39 +172,48 @@
                                 float_fmt)
 
     #write target data
-    target_start_col = base_start_col + 2 * len(QualityList) + 1
+    target_start_col = base_start_col + 4 * len(QualityList) + 1
     target_max_rows = WriteRDData(sht, target_data, start_row, target_start_col,
                                   float_fmt)
 
     #write bdrate formula
-    bdrate_start_col = target_start_col + 2 * len(QualityList) + 1
+    bdrate_start_col = target_start_col + 4 * len(QualityList) + 1
     total_rows = max(base_max_rows, target_max_rows)
     sht.write(start_row, 2, total_rows)
     for (qty, col) in zip(QualityList, range(len(QualityList))):
-        refbr_b = xlrd.cellnameabs(start_row, base_start_col + col * 2)
-        refbr_e = xlrd.cellnameabs(start_row + total_rows - 1,
-                                   base_start_col + col * 2)
-        refq_b = xlrd.cellnameabs(start_row, base_start_col + col * 2 + 1)
-        refq_e = xlrd.cellnameabs(start_row + total_rows - 1,
-                                  base_start_col + col * 2 + 1)
+        if CalcBDRateInExcel:
+            refbr_b = xlrd.cellnameabs(start_row, base_start_col + col * 4 + 2)
+            refbr_e = xlrd.cellnameabs(start_row + total_rows - 1,
+                                       base_start_col + col * 4 + 2)
+            refq_b = xlrd.cellnameabs(start_row, base_start_col + col * 4 + 3)
+            refq_e = xlrd.cellnameabs(start_row + total_rows - 1,
+                                      base_start_col + col * 4 + 3)
 
-        testbr_b = xlrd.cellnameabs(start_row, target_start_col + col * 2)
-        testbr_e = xlrd.cellnameabs(start_row + total_rows - 1,
-                                    target_start_col + col * 2)
-        testq_b = xlrd.cellnameabs(start_row, target_start_col + col * 2 + 1)
-        testq_e = xlrd.cellnameabs(start_row + total_rows - 1,
-                                   target_start_col + col * 2 + 1)
+            testbr_b = xlrd.cellnameabs(start_row, target_start_col + col * 4 + 2)
+            testbr_e = xlrd.cellnameabs(start_row + total_rows - 1,
+                                        target_start_col + col * 4 + 2)
+            testq_b = xlrd.cellnameabs(start_row, target_start_col + col * 4 + 3)
+            testq_e = xlrd.cellnameabs(start_row + total_rows - 1,
+                                       target_start_col + col * 4 + 3)
 
-        # formula = '=-bdrate(%s:%s,%s:%s,%s:%s,%s:%s)' % (
-        # refbr_b, refbr_e, refq_b, refq_e, testbr_b, testbr_e, testq_b, testq_e)
-        formula = '=bdRateExtend(%s:%s,%s:%s,%s:%s,%s:%s)'\
-            % (refbr_b, refbr_e, refq_b, refq_e, testbr_b, testbr_e, testq_b, testq_e)
-        sht.write_formula(start_row, bdrate_start_col + col, formula, bdrate_fmt)
+            # formula = '=-bdrate(%s:%s,%s:%s,%s:%s,%s:%s)' % (
+            # refbr_b, refbr_e, refq_b, refq_e, testbr_b, testbr_e, testq_b, testq_e)
+            formula = '=bdRateExtend(%s:%s,%s:%s,%s:%s,%s:%s)'\
+                % (refbr_b, refbr_e, refq_b, refq_e, testbr_b, testbr_e, testq_b, testq_e)
+            sht.write_formula(start_row, bdrate_start_col + col, formula, bdrate_fmt)
+        else:
+            refbrs   = [base_data.RDPoints[qty][i][2] for i in range(len(base_data.RDPoints[qty]))]
+            refqtys  = [base_data.RDPoints[qty][i][3] for i in range(len(base_data.RDPoints[qty]))]
+            testbrs  = [target_data.RDPoints[qty][i][2] for i in range(len(target_data.RDPoints[qty]))]
+            testqtys = [target_data.RDPoints[qty][i][3] for i in range(len(target_data.RDPoints[qty]))]
+            bdrate = BD_RATE(refbrs, refqtys, testbrs, testqtys) / 100.0
+            sht.write_number(start_row, bdrate_start_col + col, bdrate, bdrate_fmt)
     return total_rows
 
+
 def FindContent(name, rd_data):
     for data in rd_data:
-        if (name == data.ContentName):
+        if name == data.ContentName:
             return data
     return ''
 
@@ -196,9 +221,9 @@
 # main
 ######################################
 if __name__ == "__main__":
-    sys.argv = ["","-i1","ConvexHullRD_ScaleAlgosNum_5_ffmpeg_hevc_medium.xlsx",
-     "-i2","ConvexHullRD_ScaleAlgosNum_5_ffmpeg_hevc_veryslow.xlsx",
-     "-o","ConvexHullBDRate.xlsm"]
+    #sys.argv = ["","-i1","ConvexHullData_ScaleAlgosNum_6_aom_av1_1.xlsx",
+    #"-i2","ConvexHullData_ScaleAlgosNum_6_aom_av1_6.xlsx",
+    #"-o","ConvexHullBDRate.xlsm"]
     ParseArguments(sys.argv)
 
     base_shts, base_rd_data = ParseConvexHullRD(InputBase)
@@ -220,8 +245,9 @@
             for base_data in base_rd_data[sht_name]:
                 ContentName = base_data.ContentName
                 target_data = FindContent(ContentName, target_rd_data[sht_name])
-                if (target_data != ''):
+                if target_data != '':
                     total_rows = WriteRDRecord(sht, base_data, target_data,
                                                start_row, bdrate_fmt, float_fmt)
                     start_row += total_rows
+
     output_wb.close()
diff --git a/tools/convexhull_framework/src/ConvexHullTest.py b/tools/convexhull_framework/src/ConvexHullTest.py
index 327249b..3c3e4c3 100644
--- a/tools/convexhull_framework/src/ConvexHullTest.py
+++ b/tools/convexhull_framework/src/ConvexHullTest.py
@@ -21,14 +21,15 @@
      AddSeriesToChart_Scatter, InsertChartsToSheet, CreateNewSubfolder,\
      GetContents, SetupLogging, UpdateChart, AddSeriesToChart_Scatter_Rows,\
      Cleanfolder
-from PostAnalysis_Summary import GenerateSummaryExcelFile,\
+from PostAnalysis_Summary import GenerateSummaryRDDataExcelFile,\
      GenerateSummaryConvexHullExcelFile
 from ScalingTest import Run_Scaling_Test, SaveScalingResultsToExcel
 import Utils
 from Config import LogLevels, FrameNum, DnScaleRatio, QPs, CvxH_WtCols,\
      CvxH_WtRows, QualityList, LineColors, DnScalingAlgos, UpScalingAlgos,\
      ContentPath, SummaryOutPath, WorkPath, Path_RDResults, Clips, \
-     ConvexHullColor, EncodeMethods, CodecNames, LoggerName, LogCmdOnly
+     ConvexHullColor, EncodeMethods, CodecNames, LoggerName, LogCmdOnly, \
+     TargetQtyMetrics, CvxHDataRows, CvxHDataStartRow, CvxHDataStartCol, CvxHDataNum
 
 ###############################################################################
 ##### Helper Functions ########################################################
@@ -105,58 +106,79 @@
 
     return lower, upper
 
-def AddConvexHullCurveToCharts(sht, startrow, startcol, charts, rdPoints,
-                               dnScaledRes, sum_sht, sum_start_row):
-    shtname = sht.get_name()
-    sht.write(startrow, startcol, "ConvexHull Data")
-    numitems = 5  # qty, bitrate, qp, resolution, 1 empty row as internal
-    rows = [startrow + 1 + numitems * i for i in range(len(QualityList))]
 
-    hull = {}
+def LookUpQPAndResolutionInConvexHull(qtyvals, qtyhull, qtycvhQPs, qtycvhRes):
+    cvhqtys = [h[1] for h in qtyhull]
+    qtyQPs = []; qtyRes = []
+    for val in qtyvals:
+        closest_idx = min(range(len(cvhqtys)), key=lambda i: abs(cvhqtys[i] - val))
+        if (closest_idx == 0 and val > cvhqtys[0]) or (closest_idx == (len(qtyvals) - 1) and val < cvhqtys[-1]):
+            Utils.Logger.info("the give value of quality metric is out of range of convex hull test quality values.")
+
+        qtyQPs.append(qtycvhQPs[closest_idx])
+        qtyRes.append(qtycvhRes[closest_idx])
+
+    return qtyQPs, qtyRes
+
+
+def AddConvexHullCurveToCharts(sht, charts, rdPoints, dnScaledRes, tgtqmetrics):
+    shtname = sht.get_name()
+    sht.write(CvxHDataStartRow, CvxHDataStartCol, "ConvexHull Data")
+
+    hull = {}; cvh_QPs = {}; cvh_Res_txt = {}
     max_len = 0
 
-    for qty, idx, row in zip(QualityList, range(len(QualityList)), rows):
+    for qty, idx, row in zip(QualityList, range(len(QualityList)), CvxHDataRows):
         lower, upper = convex_hull(rdPoints[idx])
         hull[qty] = upper
         max_len = max(max_len, len(upper))
-        sht.write(row, startcol, qty)
-        sht.write(row + 1, startcol, "Bitrate(kbps)")
-        sht.write(row + 2, startcol, "QP")
-        sht.write(row + 3, startcol, 'Resolution')
+        sht.write(row, CvxHDataStartCol, qty)
+        sht.write(row + 1, CvxHDataStartCol, "Bitrate(kbps)")
+        sht.write(row + 2, CvxHDataStartCol, "QP")
+        sht.write(row + 3, CvxHDataStartCol, 'Resolution')
 
         brts = [h[0] for h in hull[qty]]
         qtys = [h[1] for h in hull[qty]]
-        sht.write_row(row, startcol + 1, qtys)
-        sht.write_row(row + 1, startcol + 1, brts)
+        sht.write_row(row, CvxHDataStartCol + 1, qtys)
+        sht.write_row(row + 1, CvxHDataStartCol + 1, brts)
 
-        rdpnts_qtys = [rd[1] for rd in rdPoints[idx]]
-        cvh_qidxs = [rdpnts_qtys.index(qty) for qty in qtys]
-        cvh_QPs = [QPs[i % len(QPs)] for i in cvh_qidxs]
-        cvh_Res = [dnScaledRes[i // len(QPs)] for i in cvh_qidxs]
-        cvh_Res_txt = ["%sx%s" % (x, y) for (x, y) in cvh_Res]
-        sht.write_row(row + 2, startcol + 1, cvh_QPs)
-        sht.write_row(row + 3, startcol + 1, cvh_Res_txt)
+        cvh_idxs = [rdPoints[idx].index((brt, qty)) for brt, qty in zip(brts, qtys)]
+        cvh_QPs[qty] = [QPs[i % len(QPs)] for i in cvh_idxs]
+        cvh_Res = [dnScaledRes[i // len(QPs)] for i in cvh_idxs]
+        cvh_Res_txt[qty] = ["%sx%s" % (x, y) for (x, y) in cvh_Res]
+        sht.write_row(row + 2, CvxHDataStartCol + 1, cvh_QPs[qty])
+        sht.write_row(row + 3, CvxHDataStartCol + 1, cvh_Res_txt[qty])
 
-        cols = [startcol + 1 + i for i in range(len(hull[qty]))]
+        cols = [CvxHDataStartCol + 1 + i for i in range(len(hull[qty]))]
         AddSeriesToChart_Scatter_Rows(shtname, cols, row, row + 1, charts[idx],
                                       'ConvexHull', ConvexHullColor)
+    endrow = CvxHDataRows[-1] + CvxHDataNum
 
-    endrow = rows[-1] + numitems
+    # find out QP/resolution for given qty metric and qty value
+    startrow_fdout = endrow + 1
+    sht.write(startrow_fdout, CvxHDataStartCol, "  Find out QP/resolution for given quality metrics:")
+    numitem_fdout = 4  # qtymetric values, QP, resolution, one empty row
+    startrows_fdout = [startrow_fdout + 1 + i * numitem_fdout for i in range(len(tgtqmetrics))]
 
-    #add convex hull data into summary sheet. the length of each convex hull
-    #could be different
-    sum_row = sum_start_row
-    sum_sht.write(sum_row, 2, max_len)
-    sum_col = 3
-    for qty in QualityList:
-        row = sum_row
-        for point in hull[qty]:
-            sum_sht.write(row, sum_col, point[0])
-            sum_sht.write(row, sum_col + 1, point[1])
-            row += 1
-        sum_col += 2
+    for metric, idx in zip(tgtqmetrics, range(len(tgtqmetrics))):
+        if metric not in QualityList:
+            Utils.Logger.error("wrong qty metric name. should be one of the name in QualityList.")
+            return endrow
 
-    return endrow, sum_start_row + max_len - 1
+        qtyvals = tgtqmetrics[metric]
+        qtyQPs, qtyRes = LookUpQPAndResolutionInConvexHull(qtyvals, hull[metric],
+                                                       cvh_QPs[metric], cvh_Res_txt[metric])
+        # write the look up result into excel file
+        startrow = startrows_fdout[idx]
+        sht.write(startrow, CvxHDataStartCol, metric)
+        sht.write_row(startrow, 1, qtyvals)
+        sht.write(startrow + 1, CvxHDataStartCol, 'QP')
+        sht.write_row(startrow + 1, CvxHDataStartCol + 1, qtyQPs)
+        sht.write(startrow + 2, CvxHDataStartCol, 'Resolution')
+        sht.write_row(startrow + 2, CvxHDataStartCol + 1, qtyRes)
+        endrow = startrow + 3
+
+    return endrow
 
 ###############################################################################
 ######### Major Functions #####################################################
@@ -211,8 +233,7 @@
 
     Utils.Logger.info("finish running encode test.")
 
-def SaveConvexHullResultsToExcel(content, dnScAlgos, upScAlgos, sum_wb,
-                                 sum_start_row):
+def SaveConvexHullResultsToExcel(content, dnScAlgos, upScAlgos):
     Utils.Logger.info("start saving RD results to excel file.......")
     if not os.path.exists(Path_RDResults):
         os.makedirs(Path_RDResults)
@@ -231,7 +252,6 @@
         sht.write(1, 0, "QP")
         sht.write_column(CvxH_WtRows[0], 0, QPs)
         shtname = sht.get_name()
-        sum_sht = sum_wb.get_worksheet_by_name(shtname)
 
         charts = [];  y_mins = {}; y_maxs = {}; RDPoints = {}
         for qty, x in zip(QualityList, range(len(QualityList))):
@@ -279,16 +299,8 @@
                 RDPoints[x] = RDPoints[x] + rdpnts
 
         # add convexhull curve to charts
-        startrow = CvxH_WtRows[-1] + 2; startcol = 0
-
-        sum_startrow = sum_start_row[shtname]
-        sum_sht.write(sum_startrow, 0, cls)
-        sum_sht.write(sum_startrow, 1, contentname)
-        endrow, sum_end_row = AddConvexHullCurveToCharts(sht, startrow, startcol,
-                                                         charts, RDPoints,
-                                                         DnScaledRes, sum_sht,
-                                                         sum_startrow)
-        sum_start_row[shtname] = sum_end_row + 1
+        endrow = AddConvexHullCurveToCharts(sht, charts, RDPoints, DnScaledRes,
+                                            TargetQtyMetrics)
 
         #update RD chart with approprate y axis range
         for qty, x in zip(QualityList, range(len(QualityList))):
@@ -304,6 +316,7 @@
     wb.close()
     Utils.Logger.info("finish export convex hull results to excel file.")
 
+
 def ParseArguments(raw_args):
     parser = argparse.ArgumentParser(prog='ConvexHullTest.py',
                                      usage='%(prog)s [options]',
@@ -356,7 +369,11 @@
 # main
 ######################################
 if __name__ == "__main__":
-    #sys.argv = ["","-f","convexhull","-c","hevc","-m","ffmpeg","-p","medium"]
+    #sys.argv = ["","-f","scaling"]
+    #sys.argv = ["", "-f", "sumscaling"]
+    #sys.argv = ["", "-f", "encode","-c","av1","-m","aom","-p","1"]
+    #sys.argv = ["", "-f", "convexhull","-c","av1","-m","aom","-p","6"]
+    #sys.argv = ["", "-f", "summary", "-c", "av1", "-m", "aom", "-p", "6"]
     ParseArguments(sys.argv)
 
     # preparation for executing functions
@@ -381,20 +398,21 @@
             for dnScalAlgo, upScalAlgo in zip(DnScalingAlgos, UpScalingAlgos):
                 Run_ConvexHull_Test(content, dnScalAlgo, upScalAlgo)
     elif Function == 'convexhull':
-        sum_wb, sum_start_row = GenerateSummaryConvexHullExcelFile(EncodeMethod,
-                                                                   CodecName,
-                                                                   EncodePreset,
-                                                                   SummaryOutPath,
-                                                                   DnScalingAlgos,
-                                                                   UpScalingAlgos)
         for content in Contents:
-            SaveConvexHullResultsToExcel(content, DnScalingAlgos, UpScalingAlgos,
-                                         sum_wb, sum_start_row)
-        sum_wb.close()
+            SaveConvexHullResultsToExcel(content, DnScalingAlgos, UpScalingAlgos)
+
     elif Function == 'summary':
-        smfile = GenerateSummaryExcelFile(EncodeMethod, CodecName, EncodePreset,
-                                          SummaryOutPath, Path_RDResults,
-                                          ContentPath, Clips)
-        Utils.Logger.info("summary file generated: %s" % smfile)
+        RDResultFilesGenerated = []
+        for content in Contents:
+            RDResultFilesGenerated.append(GetRDResultExcelFile(content))
+
+        RDsmfile = GenerateSummaryRDDataExcelFile(EncodeMethod, CodecName, EncodePreset,
+                                                  SummaryOutPath, RDResultFilesGenerated,
+                                                  ContentPath, Clips)
+        Utils.Logger.info("RD data summary file generated: %s" % RDsmfile)
+
+        CvxHsmfile = GenerateSummaryConvexHullExcelFile(EncodeMethod, CodecName, EncodePreset,
+                                                       SummaryOutPath, RDResultFilesGenerated)
+        Utils.Logger.info("Convel hull summary file generated: %s" % CvxHsmfile)
     else:
         Utils.Logger.error("invalid parameter value of Function")
diff --git a/tools/convexhull_framework/src/PostAnalysis_Summary.py b/tools/convexhull_framework/src/PostAnalysis_Summary.py
index 1d711e9..c2b78a9 100644
--- a/tools/convexhull_framework/src/PostAnalysis_Summary.py
+++ b/tools/convexhull_framework/src/PostAnalysis_Summary.py
@@ -13,10 +13,11 @@
 import os
 import xlsxwriter
 import xlrd
+import re
 from Config import QPs, DnScaleRatio, QualityList, VbaBinFile, CvxH_WtRows,\
-    CvxH_WtLastCol, LoggerName
-from Utils import GetShortContentName, CalcRowsClassAndContentDict,\
-    SweepScalingAlgosInOneResultFile
+    CvxH_WtLastCol, LoggerName, CalcBDRateInExcel, CvxH_WtCols, CvxHDataRows, CvxHDataStartCol
+from Utils import GetShortContentName, CalcRowsClassAndContentDict
+from CalcBDRate import BD_RATE
 import logging
 
 subloggername = "PostAnalysisSummary"
@@ -29,18 +30,40 @@
 
 ################################################################################
 ### Helper Functions ###########################################################
-def GetSummaryFileName(encMethod, codecName, preset, path):
-    name = 'ConvexHullSummary_ScaleAlgosNum_%d_%s_%s_%s.xlsm'\
+def GetRDSummaryFileName(encMethod, codecName, preset, path):
+    filetype = 'xlsm' if CalcBDRateInExcel else 'xlsx'
+    name = 'ConvexHullRDSummary_ScaleAlgosNum_%d_%s_%s_%s.%s'\
+           % (len(DnScaleRatio), encMethod, codecName, preset, filetype)
+    return os.path.join(path, name)
+
+def GetConvexHullDataSummaryFileName(encMethod, codecName, preset, path):
+    name = 'ConvexHullData_ScaleAlgosNum_%d_%s_%s_%s.xlsx'\
            % (len(DnScaleRatio), encMethod, codecName, preset)
     return os.path.join(path, name)
 
-def GetConvexHullRDFileName(encMethod, codecName, preset, path):
-    name = 'ConvexHullRD_ScaleAlgosNum_%d_%s_%s_%s.xlsx'\
-           % (len(DnScaleRatio), encMethod, codecName, preset)
-    return os.path.join(path, name)
+def SweepScalingAlgosInOneResultFile(resultfiles):
+    dnscls = []
+    upscls = []
 
-def CopyResultDataToSummaryFile_Onesheet(sht, wt_cols, contentsdict, rows_class,
-                                         infile_path):
+    # here assume all result files includes same combinations of dn and up scaling algos
+    # that is, same number of sheet and sheet names
+    file = resultfiles[0]
+    if os.path.isfile(file):
+        rdwb = xlrd.open_workbook(file)
+    else:
+        return dnscls, upscls
+    if rdwb is not None:
+        shtnms = rdwb.sheet_names()
+        for shtname in shtnms:
+            item = re.findall(r"(.+)\-\-(.+)", shtname)
+            dnsl = item[0][0]
+            upsl = item[0][1]
+            dnscls.append(dnsl)
+            upscls.append(upsl)
+
+    return dnscls, upscls
+
+def CopyResultDataToSummaryFile_Onesheet(sht, wt_cols, resultfiles):
     rdrows = CvxH_WtRows
     rd_endcol = CvxH_WtLastCol
 
@@ -56,8 +79,7 @@
 
     # copy the results data from each content's result file to corresponding
     # location in summary excel file
-    resultfiles = os.listdir(infile_path)
-    for (cls, contents), row_class in zip(contentsdict.items(), rows_class):
+    for (cls, contents), row_class in zip(ContentsDict.items(), Rows_Class):
         sht.write(row_class, 0, cls)
         rows_content = [i * len(QPs) for i in range(len(contents))]
         for content, row_cont in zip(contents, rows_content):
@@ -66,7 +88,7 @@
             rdwb = None
             for resfile in resultfiles:
                 if key in resfile:
-                    rdwb = xlrd.open_workbook(os.path.join(infile_path, resfile))
+                    rdwb = xlrd.open_workbook(resfile)
                     rdsht = rdwb.sheet_by_name(shtname)
                     for i, rdrow in zip(range(len(QPs)), rdrows):
                         data = rdsht.row_values(rdrow, 0, rd_endcol + 1)
@@ -77,14 +99,14 @@
                 logger.warning("not find convex hull result file for content:%s"
                                % content)
 
-def CalBDRate_OneSheet(sht,  cols, contentsdict, rows_class, cols_bdmtrs, cellformat):
+def CalBDRateWithExcel_OneSheet(sht, cols, cols_bdmtrs, cellformat):
     row_refst = 0
-    bdstep = 3
+    bdstep = len(QPs) - 1
     for cols_bd, residx in zip(cols_bdmtrs, range(1, len(DnScaleRatio))):
         sht.write(0, cols_bd, 'BD-Rate %.2f vs. %.2f' % (DnScaleRatio[residx],
                                                          DnScaleRatio[0]))
         sht.write_row(1, cols_bd, QualityList)
-        for (cls, contents), row_class in zip(contentsdict.items(), rows_class):
+        for (cls, contents), row_class in zip(ContentsDict.items(), Rows_Class):
             rows_content = [i * len(QPs) for i in range(len(contents))]
             for row_cont in rows_content:
                 for y in range(len(QualityList)):
@@ -97,16 +119,16 @@
                     refq_e = xlrd.cellnameabs(row_class + row_cont + row_refst
                                               + bdstep, cols[0] + 1 + y)
 
-                    testbr_b = xlrd.cellnameabs(row_class + row_cont,
+                    testbr_b = xlrd.cellnameabs(row_class + row_cont + row_refst,
                                                 cols[residx])
-                    testbr_e = xlrd.cellnameabs(row_class + row_cont + bdstep,
-                                                cols[residx])
-                    testq_b = xlrd.cellnameabs(row_class + row_cont,
+                    testbr_e = xlrd.cellnameabs(row_class + row_cont + row_refst
+                                             + bdstep, cols[residx])
+                    testq_b = xlrd.cellnameabs(row_class + row_cont + row_refst,
                                                cols[residx] + 1 + y)
-                    testq_e = xlrd.cellnameabs(row_class + row_cont + bdstep,
-                                               cols[residx] + 1 + y)
+                    testq_e = xlrd.cellnameabs(row_class + row_cont + row_refst
+                                              + bdstep, cols[residx] + 1 + y)
 
-                    #formula = '=-bdrate(%s:%s,%s:%s,%s:%s,%s:%s)' % (
+                    #formula = '=bdrate(%s:%s,%s:%s,%s:%s,%s:%s)' % (
                     #refbr_b, refbr_e, refq_b, refq_e, testbr_b, testbr_e,
                     # testq_b, testq_e)
                     formula = '=bdRateExtend(%s:%s,%s:%s,%s:%s,%s:%s)'\
@@ -115,6 +137,36 @@
                     sht.write_formula(row_class + row_cont, cols_bd + y, formula,
                                       cellformat)
 
+
+def CalBDRateWithPython_OneSheet(sht, cols_bdmtrs, resultfiles, cellformat):
+    row_refst = 0
+    bdstep = len(QPs) - 1
+    assert row_refst + bdstep < len(CvxH_WtRows)
+
+    shtname = sht.get_name()
+    rdrows = CvxH_WtRows
+    rdcols = CvxH_WtCols
+    for cols_bd, residx in zip(cols_bdmtrs, range(1, len(DnScaleRatio))):
+        sht.write(0, cols_bd, 'BD-Rate %.2f vs. %.2f' % (DnScaleRatio[residx],
+                                                         DnScaleRatio[0]))
+        sht.write_row(1, cols_bd, QualityList)
+        for (cls, contents), row_class in zip(ContentsDict.items(), Rows_Class):
+            rows_content = [i * len(QPs) for i in range(len(contents))]
+            for row_cont, content in zip(rows_content, contents):
+                key = GetShortContentName(content)
+                for resfile in resultfiles:
+                    if key in resfile:
+                        rdwb = xlrd.open_workbook(resfile)
+                        rdsht = rdwb.sheet_by_name(shtname)
+                        break
+                for y in range(len(QualityList)):
+                    refbrs = rdsht.col_values(rdcols[0], rdrows[row_refst], rdrows[row_refst + bdstep] + 1)
+                    refqtys = rdsht.col_values(rdcols[0] + 1 + y, rdrows[row_refst], rdrows[row_refst + bdstep] + 1)
+                    testbrs = rdsht.col_values(rdcols[residx], rdrows[row_refst], rdrows[row_refst + bdstep] + 1)
+                    testqtys = rdsht.col_values(rdcols[residx] + 1 + y, rdrows[row_refst], rdrows[row_refst + bdstep] + 1)
+                    bdrate = BD_RATE(refbrs, refqtys, testbrs, testqtys) / 100.0
+                    sht.write(row_class + row_cont, cols_bd + y, bdrate, cellformat)
+
 def GenerateFormula_SumRows(shtname, rows, col):
     cells = ''
     for row in rows:
@@ -134,7 +186,7 @@
     formula = '=SUM(%s)/%d' % (cells, num)
     return formula
 
-def WriteBitrateQtyAverageSheet(wb, rdshts, contentsdict, rd_rows_class, rdcols):
+def WriteBitrateQtyAverageSheet(wb, rdshts, rdcols):
     avg_sht = wb.add_worksheet('Average')
     avg_sht.write(2, 0, 'Content Class')
     avg_sht.write(2, 1, 'Content Number')
@@ -162,11 +214,11 @@
 
     startrow = 3
     step = len(QPs)
-    rows_class_avg = [startrow + step * i for i in range(len(contentsdict))]
+    rows_class_avg = [startrow + step * i for i in range(len(ContentsDict))]
     totalnum_content = 0
-    for (cls, contents), row_class, rdclassrow in zip(contentsdict.items(),
+    for (cls, contents), row_class, rdclassrow in zip(ContentsDict.items(),
                                                       rows_class_avg,
-                                                      rd_rows_class):
+                                                      Rows_Class):
         avg_sht.write(row_class, 0, cls)
         totalnum_content = totalnum_content + len(contents)
         avg_sht.write(row_class, 1, len(contents))
@@ -226,8 +278,7 @@
                 if residx == 0:
                     break
 
-def WriteBDRateAverageSheet(wb, rdshts, contentsdict, rd_rows_class,
-                            rd_cols_bdmtrs, cellformat):
+def WriteBDRateAverageSheet(wb, rdshts, rd_cols_bdmtrs, cellformat):
     # write bdrate average sheet
     bdavg_sht = wb.add_worksheet('Average_BDRate')
     bdavg_sht.write(2, 0, 'Content Class')
@@ -242,7 +293,7 @@
     cols_upscl_bd = [step_upscl * i for i in range(len(upScalAlgos))]
     step_res = len(upScalAlgos) * step_upscl + colintval_dnscalres
     cols_res_bd = [step_res * i + startcol for i in range(len(DnScaleRatio) - 1)]
-    rows_class_rdavg = [startrow + i for i in range(len(contentsdict))]
+    rows_class_rdavg = [startrow + i for i in range(len(ContentsDict))]
 
     for residx, col_res_bd in zip(range(1, len(DnScaleRatio)), cols_res_bd):
         bdavg_sht.write(0, col_res_bd, 'BD-Rate %.2f vs. %.2f'
@@ -252,9 +303,9 @@
             bdavg_sht.write_row(2, col_res_bd + col_upscl_bd, QualityList)
 
     totalnum_content = 0
-    for (cls, contents), row_class, rdclassrow in zip(contentsdict.items(),
+    for (cls, contents), row_class, rdclassrow in zip(ContentsDict.items(),
                                                       rows_class_rdavg,
-                                                      rd_rows_class):
+                                                      Rows_Class):
         bdavg_sht.write(row_class, 0, cls)
         totalnum_content = totalnum_content + len(contents)
         bdavg_sht.write(row_class, 1, len(contents))
@@ -284,6 +335,7 @@
                 bdavg_sht.write_formula(last_row, col_res + col_upscl + j,
                                         formula, cellformat)
 
+
 #######################################################################
 #######################################################################
 # GenerateSummaryExcelFile is to
@@ -295,22 +347,20 @@
 # Arguments description:
 # content_paths is where test contents located, which used for generating convex
 #               hull results.
-# infile_path   is where convex hull results excel files located.
-# classes       is the content classes and  here it requires contents are located
-#               in corresponding subfolder named with its belonged class
+# resultfiles   is a list of all convex hull RD result files generated by
+#                runninging '-f convexhull'
 # summary_outpath  is the folder where output summary file will be
-# note: all results files under infile_path should have exactly same test items
-# before running this summary script
-def GenerateSummaryExcelFile(encMethod, codecName, preset, summary_outpath,
-                             infile_path, content_path, clips):
+def GenerateSummaryRDDataExcelFile(encMethod, codecName, preset, summary_outpath,
+                             resultfiles, content_path, clips):
+
     global dnScalAlgos, upScalAlgos
-    # find all scaling algos tested in results file, expect they are the same
-    # for every content
-    dnScalAlgos, upScalAlgos = SweepScalingAlgosInOneResultFile(infile_path)
+    # find all scaling algos tested in results file,
+    # IMPORTANT: expect up and down scaling algos are the same for every content
+    dnScalAlgos, upScalAlgos = SweepScalingAlgosInOneResultFile(resultfiles)
 
     if not os.path.exists(summary_outpath):
         os.makedirs(summary_outpath)
-    smfile = GetSummaryFileName(encMethod, codecName, preset, summary_outpath)
+    smfile = GetRDSummaryFileName(encMethod, codecName, preset, summary_outpath)
     wb = xlsxwriter.Workbook(smfile)
 
     # shts is for all scaling algorithms' convex hull test results
@@ -326,16 +376,17 @@
     colstart = 3
     colInterval = 2
     rowstart = 2
-
+    # to generate rows number of starting of each class: Rows_Class
+    global ContentsDict, Rows_Class
+    ContentsDict, Rows_Class = CalcRowsClassAndContentDict(rowstart,
+                                                           content_path,
+                                                           clips, len(QPs))
     # cols is column number of results files
     step = colInterval + 1 + len(QualityList)  # 1 is for bitrate
     sum_wtcols = [step * i + colstart for i in range(len(DnScaleRatio))]
-    # to generate rows number of starting of each class: rows_class
-    contentsdict, rows_class = CalcRowsClassAndContentDict(rowstart,
-                                                           content_path,
-                                                           clips, len(QPs))
 
-    wb.add_vba_project(VbaBinFile)
+    if CalcBDRateInExcel:
+        wb.add_vba_project(VbaBinFile)
     cellformat = wb.add_format()
     cellformat.set_num_format('0.00%')
     #cols_bdmtrs is the column number to write the bdrate data
@@ -345,45 +396,98 @@
     # -1 because first resolution is used as reference
 
     for sht in shts:
-        CopyResultDataToSummaryFile_Onesheet(sht, sum_wtcols, contentsdict,
-                                             rows_class, infile_path)
+        CopyResultDataToSummaryFile_Onesheet(sht, sum_wtcols, resultfiles)
         # calculate bd rate in each scaling sheet
-        CalBDRate_OneSheet(sht, sum_wtcols, contentsdict, rows_class,
-                           cols_bdmtrs, cellformat)
+        if CalcBDRateInExcel:
+            CalBDRateWithExcel_OneSheet(sht, sum_wtcols, cols_bdmtrs, cellformat)
+        else:
+            CalBDRateWithPython_OneSheet(sht, cols_bdmtrs, resultfiles, cellformat)
 
     # calculate average bitrate and quality metrics for each category and
     # write to "average" sheet
-    WriteBitrateQtyAverageSheet(wb, shts, contentsdict, rows_class, sum_wtcols)
+    WriteBitrateQtyAverageSheet(wb, shts, sum_wtcols)
 
     # calculate average bd metrics and write to a new sheet
-    WriteBDRateAverageSheet(wb, shts, contentsdict, rows_class, cols_bdmtrs,
-                            cellformat)
+    WriteBDRateAverageSheet(wb, shts, cols_bdmtrs, cellformat)
 
     wb.close()
     return smfile
 
 def GenerateSummaryConvexHullExcelFile(encMethod, codecName, preset,
-                                       summary_outpath, DnScalingAlgos,
-                                       UpScalingAlgos):
+                                       summary_outpath, resultfiles):
     if not os.path.exists(summary_outpath):
         os.makedirs(summary_outpath)
-    smfile = GetConvexHullRDFileName(encMethod, codecName, preset,
+    smfile = GetConvexHullDataSummaryFileName(encMethod, codecName, preset,
                                      summary_outpath)
-    sum_wb = xlsxwriter.Workbook(smfile)
+    wb = xlsxwriter.Workbook(smfile)
 
     # shts is for all scaling algorithms' convex hull test results
-    sum_start_row = {}
-    #write the header in each sheet
-    for dnsc, upsc in zip(DnScalingAlgos, UpScalingAlgos):
+    shts = []
+    cols = [3 + i * 4 for i in range(len(QualityList))]
+    for dnsc, upsc in zip(dnScalAlgos, upScalAlgos):
         shtname = dnsc + '--' + upsc
-        sht = sum_wb.add_worksheet(shtname)
+        sht = wb.add_worksheet(shtname)
+        shts.append(sht)
+        # write headers
         sht.write(0, 0, 'Content Class')
         sht.write(0, 1, 'Content Name')
         sht.write(0, 2, 'Num RD Points')
-        col = 3
-        for qty in QualityList:
-            sht.write(0, col, 'Bitrate(kbps)')
-            sht.write(0, col + 1, qty)
-            col += 2
-        sum_start_row[shtname] = 1
-    return sum_wb, sum_start_row
+
+        for qty, col in zip(QualityList, cols):
+            sht.write(0, col,     'Resolution')
+            sht.write(0, col + 1, 'QP')
+            sht.write(0, col + 2, 'Bitrate(kbps)')
+            sht.write(0, col + 3,  qty)
+
+        # copy convexhull data from each content's result file to corresponding
+        # location in summary excel file
+        row = 1
+        rdcolstart = CvxHDataStartCol + 1
+        for (cls, contents) in ContentsDict.items():
+            sht.write(row, 0, cls)
+            for content in contents:
+                key = GetShortContentName(content)
+                sht.write(row, 1, key)
+                for resfile in resultfiles:
+                    if key in resfile:
+                        rdwb = xlrd.open_workbook(resfile)
+                        rdsht = rdwb.sheet_by_name(shtname)
+                        maxNumQty = 0
+                        for rdrow, col in zip(CvxHDataRows, cols):
+                            qtys = []; brs = []; qps = []; ress = []
+                            numQty = 0
+                            for qty in rdsht.row_values(rdrow)[rdcolstart:]:
+                                if qty == '':
+                                    break
+                                else:
+                                    qtys.append(qty)
+                                    numQty = numQty + 1
+                            maxNumQty = max(maxNumQty, numQty)
+
+                            for br in rdsht.row_values(rdrow + 1)[rdcolstart:]:
+                                if br == '':
+                                    break
+                                else:
+                                    brs.append(br)
+                            for qp in rdsht.row_values(rdrow + 2)[rdcolstart:]:
+                                if qp == '':
+                                    break
+                                else:
+                                    qps.append(qp)
+                            for res in rdsht.row_values(rdrow + 3)[rdcolstart:]:
+                                if res == '':
+                                    break
+                                else:
+                                    ress.append(res)
+
+                            sht.write_column(row, col, ress)
+                            sht.write_column(row, col + 1, qps)
+                            sht.write_column(row, col + 2, brs)
+                            sht.write_column(row, col + 3, qtys)
+
+                        sht.write(row, 2, maxNumQty)
+                        row = row + maxNumQty
+                        break
+
+    wb.close()
+    return smfile
diff --git a/tools/convexhull_framework/src/ScalingTest.py b/tools/convexhull_framework/src/ScalingTest.py
index a8f4a7a..aa26d80 100644
--- a/tools/convexhull_framework/src/ScalingTest.py
+++ b/tools/convexhull_framework/src/ScalingTest.py
@@ -156,8 +156,7 @@
     wb.close()
     logger.info("finish export scaling quality results to excel file.")
 
-def GenerateSummarySheet(wb, dnScalAlgos, upScalAlgos, ratio, contentsdict,
-                         rows_class, path_log):
+def GenerateSummarySheet(wb, dnScalAlgos, upScalAlgos, ratio, path_log):
     logger.info("start generate summary sheet for ratio %2.2f" % ratio)
 
     shts = []
@@ -176,7 +175,7 @@
         sht.write_row(1, col, QualityList)
 
     content_infos = {}; totalnum_contents = 0
-    for (clss, contents), row_clss in zip(contentsdict.items(), rows_class):
+    for (clss, contents), row_clss in zip(ContentsDict.items(), Rows_Class):
         sht.write(row_clss, 0, clss)
         totalnum_contents = totalnum_contents + len(contents)
         for content, row_cont in zip(contents, range(len(contents))):
@@ -203,7 +202,7 @@
                                         range(len(dnScalAlgos))):
         qualities = []
         seriname = dn_algo + '--' + up_algo
-        for (clss, contents), row_clss in zip(contentsdict.items(), rows_class):
+        for (clss, contents), row_clss in zip(ContentsDict.items(), Rows_Class):
             for content, row_cont in zip(contents, range(len(contents))):
                 key = GetShortContentName(content)
                 w = content_infos[key][0]
@@ -241,8 +240,7 @@
 
     return sht
 
-def GenerateAverageSheet(wb, sumsht, dnScalAlgos, upScalAlgos, ratio,
-                         contentsdict, rows_class):
+def GenerateAverageSheet(wb, sumsht, dnScalAlgos, upScalAlgos, ratio):
     logger.info("start generate average sheet for ratio %2.2f" % ratio)
 
     rdsht = sumsht
@@ -262,7 +260,7 @@
         sht.write(0, col, algos)
         sht.write_row(1, col, StatsMetrics)
 
-    step = len(contentsdict) + 1  # 1 extra row for total of each class
+    step = len(ContentsDict) + 1  # 1 extra row for total of each class
     startrow = 2
     rows_qtymtr = [startrow + step * i for i in range(len(QualityList))]
     for qty, row_qm, y in zip(QualityList, rows_qtymtr, range(len(QualityList))):
@@ -274,9 +272,9 @@
         #charts.append(chart)
 
         totalnum_contents = 0
-        for (cls, contents), idx, rdrow_cls in zip(contentsdict.items(),
-                                                   range(len(contentsdict)),
-                                                   rows_class):
+        for (cls, contents), idx, rdrow_cls in zip(ContentsDict.items(),
+                                                   range(len(ContentsDict)),
+                                                   Rows_Class):
             sht.write(row_qm + idx, 1, cls)
             num_content = len(contents)
             totalnum_contents = totalnum_contents + num_content
@@ -304,7 +302,7 @@
                 sht.write(row_qm + idx, wtcol + 3, formula)
 
         #write total contents statistics
-        wtrow = row_qm + len(contentsdict)
+        wtrow = row_qm + len(ContentsDict)
         sht.write(wtrow, 1, 'Total')
         sht.write(wtrow, 2, totalnum_contents)
         for rdcol, wtcol in zip(ScalSumQty_WtCols, cols_avg):
@@ -349,18 +347,17 @@
     logger.info("start generating scaling quality summary excel file.......")
     sumexcFile = GetScalingResultExcelFile(len(scaleRatios), len(DnScaleRatio))
     wb = xlsxwriter.Workbook(sumexcFile)
-    # to generate rows number of starting of each class: rows_class
-    contentsdict, rows_class = CalcRowsClassAndContentDict(ScalQty_startRow,
+    # to generate rows number of starting of each class: Rows_Class
+    global ContentsDict, Rows_Class
+    ContentsDict, Rows_Class = CalcRowsClassAndContentDict(ScalQty_startRow,
                                                            ContentPath, Clips)
 
     sumShts = []
     for ratio in scaleRatios:
-        sht = GenerateSummarySheet(wb, dnScalAlgos, upScalAlgos, ratio,
-                                   contentsdict, rows_class, path_log)
+        sht = GenerateSummarySheet(wb, dnScalAlgos, upScalAlgos, ratio, path_log)
         sumShts.append(sht)
     for ratio, sumsht in zip(scaleRatios, sumShts):
-        GenerateAverageSheet(wb, sumsht, dnScalAlgos, upScalAlgos, ratio,
-                             contentsdict, rows_class)
+        GenerateAverageSheet(wb, sumsht, dnScalAlgos, upScalAlgos, ratio)
 
     wb.close()
     logger.info("finish saving scaling quality results to excel files.......")
diff --git a/tools/convexhull_framework/src/Utils.py b/tools/convexhull_framework/src/Utils.py
index 632b1a9..ccac884 100644
--- a/tools/convexhull_framework/src/Utils.py
+++ b/tools/convexhull_framework/src/Utils.py
@@ -12,7 +12,6 @@
 
 import os
 import re
-import xlrd
 import subprocess
 import time
 import logging
@@ -26,7 +25,7 @@
                 os.remove(file)
 
 def CreateNewSubfolder(parent, name):
-    if name == '' or name == None:
+    if name == '' or name is None:
         return None
     folder = os.path.join(parent, name)
     if not os.path.exists(folder):
@@ -114,27 +113,6 @@
 
     return contentsdict, rows_class
 
-def SweepScalingAlgosInOneResultFile(infile_path):
-    dnscls = []
-    upscls = []
-    resultfiles = os.listdir(infile_path)
-    # here assume all result files includes same combinations of dn and up
-    # scaling algos
-    file = os.path.join(infile_path, resultfiles[0])
-    if os.path.isfile(file):
-        rdwb = xlrd.open_workbook(os.path.join(infile_path, resultfiles[0]))
-    else:
-        return dnscls, upscls
-    if rdwb is not None:
-        shtnms = rdwb.sheet_names()
-        for shtname in shtnms:
-            item = re.findall(r"(.+)\-\-(.+)", shtname)
-            dnsl = item[0][0]
-            upsl = item[0][1]
-            dnscls.append(dnsl)
-            upscls.append(upsl)
-
-    return dnscls, upscls
 
 def CreateChart_Scatter(wb, title, xaxis_name, yaxis_name):
     chart = wb.add_chart({'type': 'scatter', 'subtype': 'straight_with_markers'})
diff --git a/tools/convexhull_framework/src/VideoEncoder.py b/tools/convexhull_framework/src/VideoEncoder.py
index 8bbf32c..412e710 100644
--- a/tools/convexhull_framework/src/VideoEncoder.py
+++ b/tools/convexhull_framework/src/VideoEncoder.py
@@ -28,11 +28,14 @@
 
 def EncodeWithAOM_AV1(infile, QP, framenum, framerate, width, height, outfile,
                       preset):
-    args = " --codec=av1 -v --psnr --ivf  --frame-parallel=0 --cpu-used=%s" \
-           " --limit=%d --auto-alt-ref=1 --passes=2  " \
-           "--threads=1 --lag-in-frames=25 --end-usage=q --cq-level=%d" \
-           " -w %d -h %d -o %s %s"\
-           % (preset, framenum, QP, width, height, outfile, infile)
+    args = " --verbose --codec=av1 -v --psnr --ivf  --frame-parallel=0 --cpu-used=%s" \
+           " --limit=%d --auto-alt-ref=1 --passes=1 --end-usage=q --i420" \
+           " --min-gf-interval=16 --max-gf-interval=16 --gf-min-pyr-height=4 " \
+           " --gf-max-pyr-height=4 --threads=1 --lag-in-frames=19 --end-usage=q " \
+           " --kf-min-dist=65 --kf-max-dist=65 --use-fixed-qp-offsets=1 --deltaq-mode=0 " \
+           " --enable-tpl-model=0  --enable-keyframe-filtering=0 " \
+           " --fps=60/1 --input-bit-depth=8 --qp=%d -w %d -h %d -o %s %s"\
+           % (preset, framenum, 4*QP, width, height, outfile, infile)
     cmd = AOMENC + args
     ExecuteCmd(cmd, LogCmdOnly)
 
diff --git a/tools/convexhull_framework/src/VideoScaler.py b/tools/convexhull_framework/src/VideoScaler.py
index 2420d1b..51e85c0 100644
--- a/tools/convexhull_framework/src/VideoScaler.py
+++ b/tools/convexhull_framework/src/VideoScaler.py
@@ -31,7 +31,8 @@
 #use ffmpeg to do image rescaling for yuv420 8bit
 def RescaleWithFfmpeg(infile, inw, inh, outw, outh, algo, outfile, num, app_path):
     args = " -y -s:v %dx%d -i %s -vf scale=%dx%d -c:v rawvideo -pix_fmt yuv420p" \
-           " -sws_flags %s+accurate_rnd+full_chroma_int -sws_dither none" \
+           " -sws_flags %s+accurate_rnd+full_chroma_int+full_chroma_inp+bitexact"\
+           "+print_info -sws_dither none" \
            % (inw, inh, infile, outw, outh, algo)
     if (algo == 'lanczos'):
         args += " -param0 5 "