►
From YouTube: WebPerfWG call 2023 01 19 - LCP and image entropy
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
So,
as
as
background,
what
we're
trying
to
do
here,
this
is
addressing
an
image
or
an
issue.
That's
been
output
for
a
while
on
the
GitHub
repo
about
the
fact
that
a
lot
of
times,
the
image
that
we
capture
as
LCP
is
not
actually
contentful
right,
LCP
is,
is
primarily
a
user
experience.
Metric
and
we've
always
tried
to
exclude
content
that
you
know,
exists
and
is
painted
and
takes
up
space,
but
doesn't
actually
contribute
to
the
content
of
the
page.
A
It's
not
something
that
the
user
sees
understands
needs
for
the
page
right,
so
we've
traditionally
excluded
things
like
in
some
cases
like
full
viewport
images,
background
images
that
are
just
solid
colors
or
just
gradients.
A
Things
like
that
have
always
been
excluded,
but
there's
a
bunch
of
other
things
that
we're
not
catching
and-
and
we
want
to
try
to
to
do
better
than
this
basically
like,
so
that
we
can
more
accurately
capture
the
user
experience
of
the
page
and
like
when
do
the
real
content
show
up
for
them
right.
This
is
a
a
timeline
that
Annie
took
using
web
page
tests
and
posted
a
couple
months
ago,
showing
an
example
of
what
happens
on
the
on
the
web
now
right.
A
So
this
is
a
news
article
and
what
they're
doing
here
is
lazy
loading,
their
main
content
they're
above
the
full
name,
content
which
is
fun
and
they're
doing
this
in
a
way
that
they're
reserving
space
with
a
transparent,
placeholder.
That's
getting
flagged
in
that
middle
slide
is
as
green
because
it's
the
LCP,
but
it's
completely
transparent
and
exists
only
to
reserve
space
for
the
image
that
gets
loaded.
A
A
A
And
there's
there's
lots
of
ways
that
you
can
Define
such
a
thing.
All
kinds
of
information
theory
around
this,
but
we
want
to
go
like
as
simple
as
possible
and
like
the
easiest
thing
we
can
do,
is
look
at
bits
per
pixel,
literally
I'm,
looking
at
the
number
of
bits
in
the
resource
transfer
size.
A
So
we're
assuming
that
there
is
compression
built
into
the
image
format
and
then
the
compression
is
doing
its
job
and
that
the
image
is
compressed
roughly
down
to
the
sort
of
minimum
number
of
bits
that
you
need
to
express
that
image
and
for
pixels
we're
looking
at
the
CSS
pixels
that
are
actually
used
on
the
page
to
render
this.
So
this
is.
This
is
certainly.
A
Did
they
get
muted?
Sorry,
you
disappeared
so.
A
How
about
now
yeah,
okay,
excellent?
Did
we
get
bits
or
just
I'm,
not
sure
how
far
back
I
should
go?
Okay,
Michael,
say
yeah,
so
so
pixels
pixels
and
CSS
pixels
that
are
used
to
render
the
image.
So
this
is
sensitive
to
the
device
size.
Smaller
devices
have
fewer
pixels
to
work
with.
A
It
is
also
sensitive
to
container
scaling
so
that,
if
you
have
a
small
image
and
you
blow
it
up
into
a
large
container,
that
is
more
pixels.
Conversely,
if
you
have
a
massive
image
and
you
scale
it
down
to
a
tiny,
tiny
div
right-
that's
fewer
pixels,
we're
using
CSS
pixels
so
that
we
exclude
things
like
device,
pixel
ratio-
and
you
don't
get
penalized
for
for
using
something
with.
You
know
like
a
two
two
or
a
three
DPR.
A
A
Oh,
we
went
and
did
the
same
thing
in
Chrome
to
actually
measure
and
report
back
the
actual
LCP
entropy
for
every
page
load
that
users
see
and
we
classified
this
into
nice.
You
know
sort
of
logarithmically
spaced
buckets,
and
this
is
what
we
get
so
roughly
the
same
thing
and
again
like
the
left
edge
of
this
graph
is
values
of
a
hundred
thousand
plus
pixels
per
bit,
with
the
right
Edge
being
values
of
like
10,
000
plus
bits
per
pixel,
the
peak
value
in
the
middle.
A
There
is
basically
between
two
and
three
bits
per
pixel,
which
is
roughly
what
we
saw
in
HTTP
and
it
sort
of
matches
what
we
roughly
think
as
possible.
Imaging
coding
there's
about
75
percent
of
the
samples
in
this
Central
Peak
here
between
1
and
20
bits
per
pixel
between
about
0.6
and
60.
We
get
about
90
of
the
samples
and
those
are
all
content
right
like
so.
This
is
not
what
we're
interested
in.
What
we're
really
interested
in
is
the
low
end
right.
A
A
A
What
we
saw
is
the
LCP
image.
Was
this
so
more
accurately,
we
saw
this
in
essentially
every
case
right.
It's
a
full
screen,
transparent
image,
encoded
as
a
data
URL,
and
this
loads
really
really
quick,
but
it
does
nothing
for
the
user
all
right
and
some
of
those
bottom
buckets
like
that's
literally
all
we
see
as
we
move
up
a
little
bit
to
about
here.
A
We
start
seeing
things
like
solid
color
backgrounds
or
just
simple
gradient
backgrounds,
sometimes
small,
like
smaller
placeholders
that
are
still
transparent,
like
we
saw
in
that
initial
film
strip,
you
know
maybe
not
full
viewport,
but
but
a
reasonable
size
of
it,
and
it's
not
until
we
get
to
about
actually
this
is
this
bar
is
in
the
wrong
spot,
I'm
going
to
move
that,
but
to
about
0.2
bits
per
pixel
that
we
see
the
first
signs
of
anything
that
might
be
content
right.
A
It's
still
mostly
transparent
images
and
solid
color
backgrounds,
but
they're
getting
smaller
right
like
I,
said
this,
because
this
is
sensitive
to
viewport
size
right.
These,
smaller
your
transparent
images
like
I,
guess
the
more
entropy
it
has,
but
we
also
see
a
couple
things
that
are
like
simple
SVG
icons
or
backgrounds
that
are
used
behind
text
and
that
kind
of
thing
that
still
might
be
worth
filtering
out.
But
it's
more
debatable.
A
So
what
we're
doing
at
this
point
now
we've
been
experimenting,
this
in
Chrome
Beta
imposing
sort
of
a
cutoff
for
LCP.
So
at
like
these
three
different
points,
this
is
like
0.01,
0.05
and
0.2.
A
At
our
high
end,
we
experiment
with
just
throwing
out
any
images
that
don't
hit
that
threshold
and
say
these
are
not
candidates
for
LCP
and
we
will
move
on
to
the
next
next
largest
image
that
actually
meets
that
bar
and
report
that,
and
we
think
that
this
is
going
to
have
a
relatively
small
effect
overall
on
LCP,
but
it
should
for
the
sites
that
are
using
things
like
this
actually
push
their
LCP
forward,
a
little
bit
to
the
point
where
the
you
get
the
content
that
the
user
can
actually
care
about.
A
Unfortunately,
this
is
still
on
beta,
so
we
don't
have
real
numbers
we're
seeing
like
maybe
a
percent
shift
in
in
LCP
overall,
but
until
we
get
it
to
stable
and
I
can
actually
see.
We
won't
have
anything
real
to
report
back
and
I.
Think
that's
the
end
of
the
slides,
I'm
happy
to
take
and
answer
questions
on
all
this.