diff --git a/src/ext/conf/ExtensionConf.js b/src/ext/conf/ExtensionConf.js index ab74a3e..38c98e2 100644 --- a/src/ext/conf/ExtensionConf.js +++ b/src/ext/conf/ExtensionConf.js @@ -138,6 +138,126 @@ var ExtensionConf = { testRowOffset: 0.02 // we test this % of height from detected edge } }, + aardGl: { + disabledReason: "", // if automatic aspect ratio has been disabled, show reason + allowedMisaligned: 0.05, // top and bottom letterbox thickness can differ by this much. + // Any more and we don't adjust ar. + allowedArVariance: 0.075, // amount by which old ar can differ from the new (1 = 100%) + timers: { // autodetection frequency + playing: 333, // while playing + paused: 3000, // while paused + error: 3000, // after error + minimumTimeout: 5, + }, + sampleCols: 32, + canvasDimensions: { + blackframeCanvas: { // smaller than sample canvas, blackframe canvas is used to recon for black frames + // it's not used to detect aspect ratio by itself, so it can be tiny af + width: 16, + height: 9, + }, + sampleCanvas: { // size of image sample for detecting aspect ratio. Bigger size means more accurate results, + // at the expense of performance. Width == sample texture size (size of webGL canvas is pegged + // on sample count) + width: 640, + height: 360, + }, + }, + + // samplingInterval: 10, // we sample at columns at (width/this) * [ 1 .. this - 1] + blackframe: { + sufficientColorVariance: 0.10, // calculate difference between average intensity and pixel, for every pixel for every color + // component. Average intensity is normalized to where 0 is black and 1 is biggest value for + // that component. If sum of differences between normalized average intensity and normalized + // component varies more than this % between color components, we can afford to use less strict + // cummulative treshold. + cumulativeThresholdLax: 1600, + cumulativeThresholdStrict: 2560,// if we add values of all pixels together and get more than this, the frame is bright enough. + // (note: blackframe is 16x9 px -> 144px total. cumulative threshold can be reached fast) + blackPixelsCondition: 0.6, // How much pixels must be black (1 all, 0 none) before we consider frame as black. Takes + // precedence over cumulative threshold: if blackPixelsCondition is met, the frame is dark + // regardless of whether cumulative threshold has been reached. + }, + blackbar: { + blackLevel: 10, // everything darker than 10/255 across all RGB components is considered black by + // default. blackLevel can decrease if we detect darker black. + threshold: 16, // if pixel is darker than the sum of black level and this value, we count it as black + // on 0-255. Needs to be fairly high (8 might not cut it) due to compression + // artifacts in the video itself + frameThreshold: 4, // treshold, but when doing blackframe test + imageThreshold: 16, // in order to detect pixel as "not black", the pixel must be brighter than + // the sum of black level, threshold and this value. + gradientThreshold: 2, // When trying to determine thickness of the black bars, we take 2 values: position of + // the last pixel that's darker than our threshold, and position of the first pixel that's + // brighter than our image threshold. If positions are more than this many pixels apart, + // we assume we aren't looking at letterbox and thus don't correct the aspect ratio. + gradientSampleSize: 16, // How far do we look to find the gradient + maxGradient: 6, // if two neighbouring pixels in gradientSampleSize differ by more than this, then we aren't + // looking at a gradient + gradientNegativeTreshold: -2, + gradientMaxSD: 6, // reserved for future use + antiGradientMode: AntiGradientMode.Lax, + }, + variableBlackbarThresholdOptions: { // In case of poor bitrate videos, jpeg artifacts may cause us issues + // FOR FUTURE USE + enabled: true, // allow increasing blackbar threshold + disableArDetectOnMax: true, // disable autodetection when threshold goes over max blackbar threshold + maxBlackbarThreshold: 48, // max threshold (don't increase past this) + thresholdStep: 8, // when failing to set aspect ratio, increase threshold by this much + increaseAfterConsecutiveResets: 2 // increase if AR resets this many times in a row + }, + sampling: { + staticCols: 9, // we take a column at [0-n]/n-th parts along the width and sample it + randomCols: 0, // we add this many randomly selected columns to the static columns + staticRows: 9, // forms grid with staticSampleCols. Determined in the same way. For black frame checks + }, + guardLine: { // all pixels on the guardline need to be black, or else we trigger AR recalculation + // (if AR fails to be recalculated, we reset AR) + enabled: true, + ignoreEdgeMargin: 0.20, // we ignore anything that pokes over the black line this close to the edge + // (relative to width of the sample) + imageTestThreshold: 0.1, // when testing for image, this much pixels must be over blackbarThreshold + edgeTolerancePx: 2, // black edge violation is performed this far from reported 'last black pixel' + edgeTolerancePercent: null // unused. same as above, except use % of canvas height instead of pixels + }, + fallbackMode: { + enabled: true, + safetyBorderPx: 5, // determines the thickness of safety border in fallback mode + noTriggerZonePx: 8 // if we detect edge less than this many pixels thick, we don't correct. + }, + arSwitchLimiter: { // to be implemented + switches: 2, // we can switch this many times + period: 2.0 // per this period + }, + edgeDetection: { + sampleWidth: 8, // we take a sample this wide for edge detection + detectionThreshold: 4, // sample needs to have this many non-black pixels to be a valid edge + confirmationThreshold: 1, // + singleSideConfirmationThreshold: 3, // we need this much edges (out of all samples, not just edges) in order + // to confirm an edge in case there's no edges on top or bottom (other + // than logo, of course) + logoThreshold: 0.15, // if edge candidate sits with count greater than this*all_samples, it can't be logo + // or watermark. + edgeTolerancePx: 1, // we check for black edge violation this far from detection point + edgeTolerancePercent: null, // we check for black edge detection this % of height from detection point. unused + middleIgnoredArea: 0.2, // we ignore this % of canvas height towards edges while detecting aspect ratios + minColsForSearch: 0.5, // if we hit the edge of blackbars for all but this many columns (%-wise), we don't + // continue with search. It's pointless, because black edge is higher/lower than we + // are now. (NOTE: keep this less than 1 in case we implement logo detection) + }, + pillarTest: { + ignoreThinPillarsPx: 5, // ignore pillars that are less than this many pixels thick. + allowMisaligned: 0.05 // left and right edge can vary this much (%) + }, + textLineTest: { + nonTextPulse: 0.10, // if a single continuous pulse has this many non-black pixels, we aren't dealing + // with text. This value is relative to canvas width (%) + pulsesToConfirm: 10, // this is a threshold to confirm we're seeing text. + pulsesToConfirmIfHalfBlack: 5, // this is the threshold to confirm we're seeing text if longest black pulse + // is over 50% of the canvas width + testRowOffset: 0.02 // we test this % of height from detected edge + } + }, zoom: { minLogZoom: -1, maxLogZoom: 3,