GitLab

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

Signal one bit to indicate whether current superblock reuses filter
level of previous superblock.
Try filtering and compute sse using previous filter level and search
the best possible filter level. If their diff is less than predefined
threshold, current superblock reuses previous level. Otherwise,
signal the best filter level.

Change-Id: Ibf125860883b774ef2464b62bb8b799b48258c64

The compressed header is now used only when the refresh
type is set as forward, i.e. in error resilience and
frame parallel modes. As long as backward updates are
used the header is disabled thereby saving bits.

Change-Id: Iee9f66ffbd30ef3552ea41b75e4b51537cd9ff97

Removes setup in compressed header so that the compressed
header can be skipped.

Change-Id: I8d7ed63944a4f75704222f4ad7d0159db1cec0d1

Change-Id: I3d6a440b13473b0d1e8b18c6629c7e8e3fb446ae

This patch moves the sb_size to the keyframe header from all frame
headers as discussed in the AOM Codec WG meeting.

Change-Id: Ia0190e57b36b98e51ab61ad4ff14f24f9c294877

For the first superblock, signal a filter level (6 bit).
For other superblocks, signal the delta (3 bit) and sign (1 bit).
To guarantee the delta can be represented by 3 bits, the search
range of current superblock filter level is capped as
curr_lvl = prev_lvl +- ((1 << 3) - 1)

Change-Id: Ibbe2941aa96ec1220ed2adb7edf3d29cb032f0ec

It's not being used anymore, replaced by the CDF model.
The counters are moved under the entropy-stats experiment, so that they
can be used to tune the default CDF values.

Change-Id: I50cb170c4c8699cf7317fd77853b3fedf2342d3e

Use common structure for inter and intra tx type information when
possible.

Change-Id: I1fd3bc86033871ffbcc2b496a31dca00b7d64b31

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

Change-Id: I78bb38e3d61d74442278bd5ed1c4f695b7c8e24a

Currently, when new-multisymbol and ext-comp-refs are
both enabled, the comp_ref_type_prob and uni_comp_ref_prob
arrays are forward updated in the compressed header, but
their values are never used.

We can save a tiny bit of space by not signalling the
forward updates at all; as a side benefit, we can wrap
the whole of read_frame_reference_mode_probs() in
a #if !CONFIG_NEW_MULTISYMBOL block.

Note: It seems the encoder already does this; I think
the reason it doesn't cause mismatches is because we
effectively pad the compressed header out to a full byte,
and av1_diff_update_prob() reads a bit with a very high
probability of being 0.

Change-Id: Ia1fca05ee498609c98c7ea1f89578f6783357d7f

This adds the tool CONFIG_MAX_TILE
Uniform tiles are implemented using power of two number of rows or columns.
Maximum number of rows or columns is 64
Explicit tiles will follow in a later commit once the command line API is updated for this

Change-Id: Ia8d22e7f4aa779448211496c644937afdf037228

Change-Id: Ic3c93a5d2e427ce1ed578389196a265245063821

The error-resilient-mode flag is currently set per frame,
so we can encode a non-error-resilient frame immediately
after an error-resilient frame.

As of https://aomedia-review.googlesource.com/c/21783 , this
case causes the decoder to read uninitialized memory. This
happens because the error-resilient frame no longer sets up
cm->cur_frame->global_motion. Then, on the non-error-resilient
frame, that is renamed to cm->prev_frame->global_motion and we
try to use it as a reference for delta encoding.

Fix this by always writing cm->cur_frame->global_motion.

Change-Id: I0d4f13bf413ca15da210e06d5ce1780331c005da

Improves keyframe coding by 0.1% on the screen_content testset.

Change-Id: I5793a67eaae21010ef200038af99ebb9029fc770

This allows gm parameters to be written when error resilient mode
is enabled but avoids depending on stored parameters from the
previous frame.

BUG=aomedia:741

Change-Id: Iae455a346e0eebb18e2bcfadc8826c75aedfee99

Using an assert (which was compiled out) meant we got to a
use-after-free in bug 729.

BUG=aomedia:729

Change-Id: I4d0fa5e80322c395f94565c76e2285782c328505

Before LR the border extension needs to be consistent.
Otherwise there will be inconsistency at the frame boundaries
causing mismatches.

BUG=aomedia:742
BUG=aomedia:744
BUG=aomedia:745

Change-Id: I5b0c51aa1493c58f7acc706bf686ce711eadd75d

This allows a mask for mrc-tx to be sent in the bitstream for
inter or intra 32x32 transform blocks. The option to send the mask
vs build it from the prediction signal is currently controlled with
a macro. In the future, it is likely the macro will be removed and it
will be possible for a block to select either method. The mask building
functions are still placeholders and will be filled in in a followup.

Change-Id: Ie27643ff172cc2b1a9b389fd503fe6bf7c9e21e3

Since CDEF looks uses the luma direction for chroma, CDEF would have
to change significantly to support formats like 4:2:2.  The limited
use of such formats does not justify the complexity to support this,
so the simple solution is to mandate that the chroma planes aren't
filtered if subsampling_x != subsampling_y.  Most of the visual gain
is in luma, anyway.

This also means that the chroma strengths and chroma skip condition
shall not be sent if subsampling_x != subsampling_y.

BUG=aomedia:720

Change-Id: I35c184a6fe0908ae0fee1e74494b6904fa9a3c82

This patch forces the vertical filtering for the top and bottom
rows of a processing unit for the Wiener filter to not use border
more than what is set in the WIENER_BORDER_VERT macro.
This macro is currently set at 0 to eliminate line buffer completely,
but it could be increased to 1 or 2 to use limited line buffers
if the coding efficiency is affected too much with a 0 line-buffer.

Also, for the sgr filter we added the option of using overlapping
windows horizonttally and vertically to improve coding efficiency.
The vertical border used is set by the SGRPROJ_BORDER_VERT
macro, while the horizontal border can be set by the
SGRPROJ_BORDER_HORZ macro set at 2, the max needed. Currently we do not
recommend changing SGRPROJ_BORDER_HORZ below 2.

The overall line buffer requirement for LR is twice the max of
WIENER_BORDER_VERT and SGRPROJ_BORDER_VERT.
Currently both are set as 0, eliminating line buffers completely.

Also this patch extends borders consistently before CDEF / LR.

Change-Id: Ie58a98c784a0db547627b9cfcf55f018c30e8e79

This patch allows ncobmc-adapt-weight to replace warped-causal,
and also remove transmitting ncobmc_mode_prob in the frame header.

Change-Id: I2713b3abbd28eef8b203637e432eca6a782e3b9a

Save bits by not encoding global motion data when there's no
previous frame to use as a reference. Use the same logic
as for using the previous frame's motion vectors - ie, we don't
read global motion information when the current frame is
intra-only or when using error-resilient mode.

This also fixes an undefined behaviour / segfault bug - see
https://bugs.chromium.org/p/aomedia/issues/detail?id=731 for
details

BUG=aomedia:731

Change-Id: Icca90a1bccafd06de8a4056ca5353318fce416cb

The callsites to decode_block and decode_partition in the body of
decode_partition are rather noisy with code that is enabled or
disabled by config flags, so it's hard to see what is fundamentally a
simple recursion.

This patch moves all that cruft into a pair of locally defined
preprocessor macros (DEC_BLOCK and DEC_PARTITION) to simplify
things.

There's no diff in disassembled code when compiling before and after
the patch.

Change-Id: Ie08db263a9874e2c566c758e8f3a51d131b1b80b

As of patch https://aomedia-review.googlesource.com/c/20220 ,
it is no longer always the case that tile_rows == (1 << log2_tile_rows)
and tile_cols == (1 << log2_tile_cols). This exposed an inconsistency
in the tile-group decoding:

When reading the first tile group in a frame, we read
(log2_tile_rows + log2_tile_cols) bits each for the tile group
start and length, but when reading later tile groups we read
get_msb(tile_rows * tile_cols) bits. But now there are edge cases
where those values differ! Since the encoder always uses
(log2_tile_rows + log2_tile_cols) bits, this leads to mis-parsing
the bitstream.

Fix this by moving the decode logic to one function, which always
reads (log2_tile_rows + log2_tile_cols) bits. As a bonus, this gives
us one place to check other invariants, eg. that tile groups can't
run off the end of the frame.

Change-Id: I83b24314526b6055300b70b0f1cdce038e6b23dc

This requires making a temporary copy of the functions in
binary_codes_writer/reader to take in the aom_write_bit_buffer type.

Change-Id: Idb60b29cff69b45224535c6e6a4079a34a2c6871

Change-Id: I7393596d98f11aa53ba4b9e329386b5168b3e086

Changes loop-restoration to use processing unit size that is
64x64 for luma; for chroma the processing unit is coupled to
64x64 support region for luma.
Thus for chroma the processing unit size is 32x32 for 4:2:0,
32x64 for 4:2:2 and 64x64 for 4:4:4, etc.

While the Wiener filter output should not change with this patch,
the sgr filter will change since the boundary pixel handling in
sgr is internal within the filter.

Change-Id: I65a9e2df88927a19445420ce400acb1fcf7afa93

Change-Id: I1cd1197b48a3315fe4f44578b80634be73de17a3

In the bitstream in bug 709, the frame has a width of 13318 mi
units. This rounds up to 13328 mi units (when rounding to a whole
number of max superblocks) but then the shift right by log2_tile_cols
gives floor(13328/32) = floor(416.5) = 416. Of course 32*416 = 13312
which is less than 13318.

This patch moves the <mi_cols, log2_tile_cols> -> tile_width
calculation (and the equivalent calculation for tile_height) into a
common function which gets the rounding right.

BUG=aomedia:709

Change-Id: If5e8e6b7a3c6f3d336cda9edd94a17595eaf5406

The example bitstream in bug 710 shows what might go on. This has a
frame with mi_cols=540 and log2_tile_cols=3. But 540/8 = 67.5, which
gets rounded up to give a tile_width of 5*16=80. However, 540/80 =
6.75 which means that the frame finishes somewhere in the middle of
tile 7 (and tile 8 is completely empty).

This patch clamps tile_rows/tile_cols to ensure that can't happen. The
bitstream still signals ceil(log2(tile_<rows/cols>)) so there's no
change there.

BUG=aomedia:710

Change-Id: Idfad658ef59cf71674100f5e74bd53dd192c6a84

BUG=aomedia:721

Change-Id: Ic6e767b1c11399379391a2ba92e3ec53dd0a2be0

Change-Id: If0b48a4ee1f7902d8c6154945ccef68a2b5aabb5

BUG=aomedia:709

Change-Id: I26f8938a744f7ebfd9734929502730b17de348f9

The example in bug 712 is a bitstream that signals a global motion
type of ROTZOOM, but its second frame has shear parameters that fail
the is_affine_shear_allowed check at warped_motion.c:754. This is
quite possible (and it's not obvious how to change the bitstream
format so that you can't signal something like this).

This patch replaces the failing assertion with a proper "no you
can't!" error.

BUG=aomedia:712

Change-Id: I6a32632d17031b777acd2f78a887491a40177785

Rather than encoding the loop restoration coefficients at the start of
the frame header, this patch moves them to occur just after certain
top-level superblocks.

You might hope that we could just encode coefficients on top-level
superblocks where the top-left corner of the superblock was also the
top-left corner of the loop restoration tile. Unfortunately, this
can't work with the superres experiment, where the loop restoration
tiles don't necessarily line up with the superblocks. Indeed, in
general there can be multiple different loop restoration coefficients
that apply in a given top-level superblock. This patch defines a
function, av1_loop_restoration_corners_in_sb, which yields the
rectangle [rrow0, rrow1) x [rcol0, rcol1) of loop restoration tiles
whose top left corners lie in this top-level superblock.

The total file size should be unchanged by this patch: the bits have
just been moved from the frame header and spread out among the rest of
the frame.

Change-Id: Icf43b0560964a63dea0d2cd801313f04139188d7

Change-Id: Ie67266538db41c6aa7d79a5c270c26c021583c48

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

This is a baby-step towards encoding the coefficients at the start of
superblocks at the top-left of loop restoration tiles. Note that this
patch causes us to reset "wiener_info" and "sgrproj_info" at each tile
boundary, which will cause a performance drop.

This is necessary because, in order for tiles to be processed in
parallel, we cannot delta-encode coefficients across tile boundaries
if the coefficients are signalled within tiles. We could probably do
better than the current patch by, say, delta-encoding against previous
frames.

This patch also fixes up the costing in pickrst.c to match

Change-Id: I5b8b91d63aaf49627cde40219c31c0ac776dfd38