GitLab

Change-Id: I9d3f0380865790d8adcb85f03305b193bc1949d7

Change-Id: I4ce263b2731676e8620f0dbd1da2cd79bfded18c

Count filter level reuse, sign, and delta. And use counts to train
default cdfs.
Default cdf tables updated.

Change-Id: If4fbf3e06ec7d568d940ca7b170bbbb4b778f176

If you have a structure, foo_t, with an alignment request then Visual
Studio won't allow you to declare a function

  void use_foo(foo_t x);

The reasoning is that x might be passed on the stack, and their ABI
doesn't allow them to guarantee that x is aligned appropriately. More
strangely, this isn't allowed either:

 void use_some_foos(foo_t x[10]);

This is functionally equivalent to:

 void use_windows_foos(foo_t *x);

(except that you can't tell how long the array should be from the
function signature).

Since Visual Studio is supposed to allow the latter form, use that
instead.

Change-Id: Icd449fc1058606fa7e48a6f791091bbb42a73b2c

Introduced by: https://aomedia-review.googlesource.com/c/aom/+/25181

Change-Id: I1f25178d6b273fbeade4c33f153b5f2bac4a8b99

Change-Id: Iaff923f34100ecdce76d2319fab67cde59d485ae

Change-Id: I4732dbbb71a0db9ac284a4b2ae5f10816e0e9264

Change-Id: If6e84f390c6f92e8e013056c657758ba9e407a71

When experiment LOOPFILTER_LEVEL is on, there're four base filter levels
for each frame. This patch enables one to use one delta or four deltas
to update corresponding filter levels for each superblock in
EXT_DELTA_Q.

1 bit per frame is sent through bitstream to select one or four deltas.
Now, we hard code to use one delta.

Change-Id: I9c61a035064fa81878b0575ad21664e2b22a6a45

Before LOOPFILTER_LEVEL, there's one filter level,
now we have four filter levels for y plane vertical,
y plane horizontal, u plane and v plane.

This patch enables experiment LOOPFILTER_LEVEL to support per
superblock loop filter level update.

Change-Id: Ib11a1564471eb3076c26e73e5cdf7b5a3045ef97

This experiment has been adopted, we can simplify the code
by dropping the associated preprocessor conditionals.

Change-Id: Ic077963f72e8cc2ae9872b58c8a0241988384110

Change-Id: Ifa983d83a509cdfad78f6400df7d60c8f5b4f68c

Change-Id: Ieb28f40d85e4db4af33648c32c406dd2931ceb89

Experiment LOOPFILTER_LVL has 4 deblocking filter levels for:
y plane horizontal, y plane vertical, u plane, and v plane.

The patch supports segment updates for each of the four filter levels.

Change-Id: I494e8d9ab67e37c5f6234b8d9db8e3e3abf70d52

This change enables using 13 taps for luma plane deblocking and 5 taps for
chroma plane deblocking when pixels are in flat area.

The aim for the experiment is to make sure that luma line 57 and chroma
line 29 of the current superblock is not changed by the deblocking process
of the superblock below. Previously this was already the case for luma
line 56 and chroma line 28 (but not for 57 and 29).

This experiment is part of an effort to reduce the overall line buffer
size for DEBLOCK+CDEF+LR. With this change it is possible to CDEF line
-8 to +55 direcly on the output of deblock (which require line +56 and
+57 to be final).

Change-Id: I7779a08d6ad5683bf35c3372b1526786eaac8472

Only use cm->mi, instead of cm->mi_grid_visible to get filter level.
The latter may not work for shifted grid loop filtering.

Change-Id: I55ed6a42f0abb19d6814e8c0cf8d64ce79bf6abc

For each superblock, its filtering range is shifted up and left by
8 pixels (half of the maximum loop filter length), such that
estimation of deblocking filtering will not cross two superblocks.

Change-Id: I82244b7c26ab8b2ac553037b3bb1fe1d82bf5704

Search and pick filter level for each superblock after the entire
frame has been encoded. And then apply loop filtering using
selected filter levels.

Now it can't work with LOOPFILTER_LEVEL. Y, U, V planes share the
same filter level.

Per superblock, filter levels are signaled via bitstream.

Future work: move selecting filter level into each superblock
rather than wait for the whole frame encoded.

Change-Id: I46cb994ec4866abb0456146f7c3cae8813c1d52e

Baseline + parallel_deblocking:

- Passed unit tests *SSE2/Loop8Test6*, *AVX2/Loop8Test6*.
- 1080p, 25 frames, profile=0, encoding/decoding, output match.
- Decoder frame rate increases from 54.15 to 65.84.

Change-Id: I55938c94961066594f4b9080192c7268c19d9bf9

Change-Id: If0b48a4ee1f7902d8c6154945ccef68a2b5aabb5

Lots of small bug fixes, mainly around the transform size coding:

* The loop filter was accidentally using the non-subsampled
  block size for the V plane, due to comparing a plane index
  (0, 1, or 2) against PLANE_TYPE_UV (== 1)

* We allowed an initial update of the transform partition probabilities
  even on frames where we know they will never be used
  (because tx_mode != TX_MODE_SELECT).
  Further, these probabilities would not be reverted at the end
  of the frame, leading to the probability delta persisting across frames.

  Change this to behave more like the non-var-tx transform size coding,
  where probability deltas are only coded for frames with
  tx_mode == TX_MODE_SELECT, and the deltas only apply for one frame.

* Fix decoder for the case where the video as a whole isn't lossless,
  and we have tx_mode == TX_MODE_SELECT, but the current segment
  *is* lossless.
  Note that the encoder already does the right thing in this case.

* Don't allow the transform splitting to recurse "below" 4x4.
  This is really just a refactor, but means we can increase the
  maximum depth when subdividing rectangular transforms if we
  want to, whereas the previous code would have needed special cases
  for 4x8 and 8x4 transforms.

* Finally, when we hit the maximum splitting depth, don't update
  the counts as if we had coded a 'no split' symbol.

Change-Id: Iaebdacc9de81d2e93d3c49241e719bbc02e32682

- Decoder speed improves ~13.7% (baseline + parallel_deblocking).
- Highbd loopfilter AVX2 version works when this experiment is
  disabled.

Change-Id: I5d56b137a1d52236a4735656c370d57ef71ae043

CONFIG_UV_LVL --> CONFIG_LOOPFILTER_LEVEL
Change name because the experiment combines filter level search
in U, V plane, and horizontal, vertical search in Y plane.

Change-Id: Ia05b8f80cd93b60a0305eb94e5783559ef904c13

A new experiment for deblocking filter that separates vertical
and horizontal filter strengths. This experiment is based on the
assumption that non-flatness characteristics of vertical and
horizontal direction may differ. Therefore selecting different
filter strengths for vertical and horizontal can improve deblocking
performance.

The process of finding proper filter strength:
1. Search through the filter level under the constraint that
   (vertical == horizontal), and find the best solution.
2. Fix vertical level as the best solution found in step 1 and vary
   horizontal level to find the best value.
3. Fix the selected horizontal level, vary vertical level to find
   its best value.

The experiment is working with UV_LVL, sharing the same config flag.
The searching for horizontal and vertical filter strength only applies
on Y plane for now.

The experimental flag should be changed to filter_level later.

Change-Id: I164eec8d3ccb3da7ff109c5c55f4b52c1536ddf1

This experiment has been adopted as it has been cleared by Tapas.

Change-Id: I0682face60f62dd43091efa0a92d09d846396850

Add asserts for switch.
Add helper functions to make selection of plane functions readable.
Remove extra { such that brackets match.

Change-Id: I048f3e5e0822bf1669fdcbedb84a0255139df686

Make directional deblocking work with parallel deblocking.

Change-Id: Id1b4e0ff824f97b48cef52d594af56c0140db452

Change-Id: I0c3772110e9fa62ac687bd99e290b5006bf3bd6c

1.Change mix case variable names to underscore cases following
  Google C++ coding style guide:
  https://google.github.io/styleguide/cppguide.html#Variable_Names

2.Reduce number of parameters to pass. Derive these parameters
  when needed inside functions.

Change-Id: I17ca8aed20be2f83f9e46275e6a1f01c8f0ec510

Previously, U, V planes share the same filter level with Y.
Here, we search and pick the best filter level for U, V planes.
Selected filter levels are transmitted per frame.
This works with parallel_deblocking.

Coding gain on Google test set:
		Avg_psnr	ovr_psnr	ssim
lowres: 	-0.116		-0.120		-0.339
midres:		-0.218		-0.228		-0.338
hdres:		-0.260		-0.264		-0.365

Change-Id: I03d2ac47539f3eea9f3c4b08007bd6d3f4b73572

Fix width/height for U, V planes.
Previously, width/height will be right shifted multiple times
in the loop.

Change-Id: I3581cb948c1918e39c30eb5c99ac958df5d3ed31

New deblocking filter that smooths block boundaries in an estimated
direction of object orientation.

1. Select the proper direction for deblocking filtering.
Compute abs gradient line by line for the block.
Select the direction with least sum of abs gradient.

2. Apply deblocking filtering for a block along this direction.
Apply directional filtering for Y, U, V planes.

Coding gain on Google test set:

%	  	avg_psnr   ovr_psnr  ssim
lowres  	-0.129 	  -0.136    -0.277
midres  	-0.103    -0.127    -0.188
hdres	  	-0.159    -0.158    -0.173
screen_content  -0.408    -0.397    -0.695

Change-Id: Ie8646dcc163ace5d8faf5e502b38342d885efc30

Change-Id: I9a0470cb47f953cfdb026fb699cdcc000a8deca9

this change enables parallel_deblocking by default after it has been
officially adopted. the parallel_deblocking_15taps experiment is merged
into the parallel_deblocking experiment so it is removed to clean up
the code. internal compile flags are added to disable 15 tap for both
luma and chroma plane for future experiment purpose. the internal
compile flags are disabled by default.

Change-Id: I1668fd2cb7676d756c52263d6993241618d33ee6

Change-Id: I802c9e41ebfed090b5ad8300917aad5e16ad026a

This patch adds support for 4:1 rectangular blocks to various common
data arrays, and adds new partition types to the EXT_PARTITION_TYPES
experiment which will use them.

This patch has the following restrictions, which can be lifted in
future patches:

  * ext-partition-types is incompatible with fp_mb_stats and supertx
    for the moment

  * Currently only 32x32 superblocks can use the new partition types

There's a slightly odd restriction about when we allow
PARTITION_HORZ_4 or PARTITION_VERT_4. Since these both live in the
EXT_PARTITION_TYPES CDF, read_partition() can only return them if both
has_rows and has_cols is true. This means that at least half of the
width and height of the block must be visible. It might be nice to
relax that restriction but that would imply a change to how we encode
partition types, which seems already to be in a state of flux, so
maybe it's better to wait until that has settled down.

Change-Id: Id7fc3fd0f762f35f63b3d3e3bf4e07c245c7b4fa

Use a variable instead of an array.
Make the horizontal function the same structure as the vertical function.

Change-Id: Iabfebe823ed9641cda0b5a0973c4dad4ecaef1a7

cb4x4 itself should not require these sizes.

This simplifies compatibility with other experiments, since we can
first make them work with cb4x4 (which is now on by default), and
then worry about chroma_sub8x8 and chroma_2x2 (which is not) in
separate steps.

Encoder and decoder output should remain unchanged.

Change-Id: Iff2a5494cab3b7d96f881e8bd9cd4bf18c817cfa

for chroma plane, when mapping from pixel location to the mi_row
and mi_col, need to consider sampling ration of the chroma plane.

Change-Id: I7a369fd6a5c6c4dc5495da64d83f90a532de7ad5

the tile boundary info flag was updated for each mi data structure
which starts from cm->mi. there is the second level buffer which
contains the pointer to the mi structure. it starts at
cm->mi_grid_visible. for every coded block, pointer in the second level
buffer only points to the top left mi structure of that particular coded
block. in order to get the correct boundary info for each mi. we have to
access the mi structure from cm->mi instead of cm->mi_grid_visible.
this change doesn't impact the result, it only cleans up the logic.

Change-Id: I8f883a284f600e3075754124b8197d78898a56be