blob: a7db9ffe9a512a6d6de859f970f29ca35bce8f99 [file] [log] [blame]
#!/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 sys
import xlsxwriter
import xlrd
import argparse
from Config import VbaBinFile, QualityList, CalcBDRateInExcel, \
EnablePreInterpolation
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='')
parser.add_argument('-i1', '--input1', dest='Input1', type=str,
required=True, metavar='',
help="convex hull summary excel file for base mode")
parser.add_argument('-i2', '--input2', dest='Input2', type=str,
required=True, metavar='',
help="convex hull summary excel file for target mode")
parser.add_argument('-o', '--output', dest='Output', type=str,
required=True, metavar='',
help="output excel file with BDRATE for base and target"
" modes")
if len(raw_args) == 1:
parser.print_help()
sys.exit(1)
args = parser.parse_args(raw_args[1:])
global InputBase, InputTarget, Output
InputBase = args.Input1
InputTarget = args.Input2
Output = args.Output
def read_cell_as_str(sht, row, col):
cell_val = sht.cell(row, col).value
if cell_val == '':
return ''
else:
return str(cell_val)
def read_cell_as_float(sht, row, col):
cell_val = sht.cell(row, col).value
if cell_val == '':
return ''
else:
return float(cell_val)
def read_cell_as_int(sht, row, col):
cell_val = sht.cell(row, col).value
if cell_val == '':
return ''
else:
return int(cell_val)
def ParseConvexHullRD(xls, EnablePreInterpolation = False):
wb = xlrd.open_workbook(xls)
shts = wb.sheet_names() #list of sheet names
data = {} #dict of data, key is the sheet name
cvx_cols = 4
if EnablePreInterpolation:
cvx_cols = 6
cols = [3 + i * cvx_cols 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
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 == '':
print("Error: read empty cells")
exit()
point = ConvexHullData(name, cls, num)
rd_data = {}
for row in range(num):
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 EnablePreInterpolation:
int_br = read_cell_as_float(sht, start_row+row, col + 4) #Int_Bitrate
int_q = read_cell_as_float(sht, start_row+row, col + 5) # Int_Quality
if int_br != '' and int_q != '':
if qty in rd_data:
rd_data[qty].append((br, q, int_br, int_q))
else:
rd_data.update({qty: [(br, q, int_br, int_q)]})
else:
if br != '' and q != '':
if qty in rd_data:
rd_data[qty].append((br, q))
else:
rd_data.update({qty: [(br, q)]})
start_row += num
point.RDPoints = rd_data
if sht_name in data:
data[sht_name].append(point)
else:
data.update({sht_name: [point]})
return shts, data
def WriteOutputHeaderRow(sht, EnablePreInterpolation = False):
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)
if EnablePreInterpolation:
sht.write(0, col + 2, 'Int_Bitrate(kbps)')
sht.write(0, col + 3, 'Int_' + qty)
col += 4
else:
col += 2
col += 1
for qty in QualityList:
sht.write(0, col, 'Bitrate(kbps)')
sht.write(0, col + 1, qty)
if EnablePreInterpolation:
sht.write(0, col + 2, 'Int_Bitrate(kbps)')
sht.write(0, col + 3, 'Int_' + qty)
col += 4
else:
col += 2
col += 1
for (idx, qty) in zip(range(len(QualityList)), QualityList):
sht.write(0, col + idx, "BDRATE-%s" % qty)
def WriteRDData(sht, rd_data, start_row, start_col, format,
EnablePreInterpolation = False):
col = start_col
max_rows = 0
for qty in QualityList:
row = start_row
for (line, point) in zip(range(len(rd_data.RDPoints[qty])),
rd_data.RDPoints[qty]):
if point[0] != '':
sht.write_number(row + line, col, point[0], format) #Bitrate
if point[1] != '':
sht.write_number(row + line, col + 1, point[1], format) #Quality
if EnablePreInterpolation:
if point[2] != '':
sht.write_number(row + line, col + 2, point[2], format) # Int_Bitrate
if point[3] != '':
sht.write_number(row + line, col + 3, point[3], format) # Int_Quality
if EnablePreInterpolation:
col += 4
else:
col += 2
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,
EnablePreInterpolation = False):
sht.write(start_row, 0, base_data.ContentClass)
sht.write(start_row, 1, base_data.ContentName)
#write base data
base_start_col = 3
cvx_cols = 2
if EnablePreInterpolation:
cvx_cols = 4
base_max_rows = WriteRDData(sht, base_data, start_row, base_start_col,
float_fmt, EnablePreInterpolation)
#write target data
target_start_col = base_start_col + cvx_cols * len(QualityList) + 1
target_max_rows = WriteRDData(sht, target_data, start_row, target_start_col,
float_fmt, EnablePreInterpolation)
#write bdrate formula
bdrate_start_col = target_start_col + cvx_cols * 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))):
if CalcBDRateInExcel:
refbr_b = xlrd.cellnameabs(start_row,
base_start_col + col * cvx_cols)
refbr_e = xlrd.cellnameabs(start_row + total_rows - 1,
base_start_col + col * cvx_cols)
refq_b = xlrd.cellnameabs(start_row,
base_start_col + col * cvx_cols + 1)
refq_e = xlrd.cellnameabs(start_row + total_rows - 1,
base_start_col + col * cvx_cols + 1)
testbr_b = xlrd.cellnameabs(start_row,
target_start_col + col * cvx_cols)
testbr_e = xlrd.cellnameabs(start_row + total_rows - 1,
target_start_col + col * cvx_cols)
testq_b = xlrd.cellnameabs(start_row,
target_start_col + col * cvx_cols + 1)
testq_e = xlrd.cellnameabs(start_row + total_rows - 1,
target_start_col + col * cvx_cols + 1)
# 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)
if EnablePreInterpolation:
refbr_b = xlrd.cellnameabs(start_row,
base_start_col + col * cvx_cols + 2)
refbr_e = xlrd.cellnameabs(start_row + total_rows - 1,
base_start_col + col * cvx_cols + 2)
refq_b = xlrd.cellnameabs(start_row,
base_start_col + col * cvx_cols + 3)
refq_e = xlrd.cellnameabs(start_row + total_rows - 1,
base_start_col + col * cvx_cols + 3)
testbr_b = xlrd.cellnameabs(start_row,
target_start_col + col * cvx_cols + 2)
testbr_e = xlrd.cellnameabs(start_row + total_rows - 1,
target_start_col + col * cvx_cols + 2)
testq_b = xlrd.cellnameabs(start_row,
target_start_col + col * cvx_cols + 3)
testq_e = xlrd.cellnameabs(start_row + total_rows - 1,
target_start_col + col * cvx_cols + 3)
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 + 1, bdrate_start_col + col, formula, bdrate_fmt)
else:
refbrs = [base_data.RDPoints[qty][i][0] for i in range(len(base_data.RDPoints[qty]))]
refqtys = [base_data.RDPoints[qty][i][1] for i in range(len(base_data.RDPoints[qty]))]
testbrs = [target_data.RDPoints[qty][i][0] for i in range(len(target_data.RDPoints[qty]))]
testqtys = [target_data.RDPoints[qty][i][1] for i in range(len(target_data.RDPoints[qty]))]
bdrate = BD_RATE(qty, refbrs, refqtys, testbrs, testqtys)
if (bdrate != 'Non-monotonic Error'):
bdrate /= 100.0
sht.write_number(start_row, bdrate_start_col + col, bdrate, bdrate_fmt)
else:
sht.write(start_row, bdrate_start_col + col, bdrate)
if EnablePreInterpolation:
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(qty, refbrs, refqtys, testbrs, testqtys)
if (bdrate != 'Non-monotonic Error'):
bdrate /= 100.0
sht.write_number(start_row + 1, bdrate_start_col + col, bdrate, bdrate_fmt)
else:
sht.write(start_row + 1, bdrate_start_col + col, bdrate)
return total_rows
def FindContent(name, rd_data):
for data in rd_data:
if name == data.ContentName:
return data
return ''
######################################
# main
######################################
if __name__ == "__main__":
#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, EnablePreInterpolation)
target_shts, target_rd_data = ParseConvexHullRD(InputTarget, EnablePreInterpolation)
output_wb = xlsxwriter.Workbook(Output)
# vba file needed when to calculate bdrate
output_wb.add_vba_project(VbaBinFile)
bdrate_fmt = output_wb.add_format()
bdrate_fmt.set_num_format('0.00%')
float_fmt = output_wb.add_format()
float_fmt.set_num_format('0.00')
for sht_name in base_shts:
if sht_name in target_shts:
sht = output_wb.add_worksheet(sht_name)
WriteOutputHeaderRow(sht, False)
start_row = 1
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 != '':
total_rows = WriteRDRecord(sht, base_data, target_data,
start_row, bdrate_fmt, float_fmt,
EnablePreInterpolation)
start_row += total_rows
output_wb.close()