Skip to content
GitLab
Projects
Groups
Snippets
Help
Loading...
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in / Register
Toggle navigation
A
aom-rav1e
Project overview
Project overview
Details
Activity
Releases
Repository
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Issues
0
Issues
0
List
Boards
Labels
Service Desk
Milestones
Merge Requests
0
Merge Requests
0
CI / CD
CI / CD
Pipelines
Jobs
Schedules
Operations
Operations
Incidents
Environments
Packages & Registries
Packages & Registries
Container Registry
Analytics
Analytics
CI / CD
Repository
Value Stream
Wiki
Wiki
Snippets
Snippets
Members
Members
Collapse sidebar
Close sidebar
Activity
Graph
Create a new issue
Jobs
Commits
Issue Boards
Open sidebar
Xiph.Org
aom-rav1e
Commits
e4f0c541
Commit
e4f0c541
authored
Apr 28, 2013
by
Ronald S. Bultje
Browse files
Options
Browse Files
Download
Email Patches
Plain Diff
Merge encode_sb and encode_sb64 in a recursive encode_sb/b function.
Change-Id: Ifd1f7319e398381ca7d55aaacc68c39a1319d651
parent
7c5eb6d5
Changes
1
Hide whitespace changes
Inline
Side-by-side
Showing
1 changed file
with
102 additions
and
163 deletions
+102
-163
vp9/encoder/vp9_encodeframe.c
vp9/encoder/vp9_encodeframe.c
+102
-163
No files found.
vp9/encoder/vp9_encodeframe.c
View file @
e4f0c541
...
...
@@ -786,196 +786,134 @@ static void update_stats(VP9_COMP *cpi, int mi_row, int mi_col) {
}
}
static
void
encode_sb
(
VP9_COMP
*
cpi
,
int
mi_row
,
int
mi_col
,
int
output_enabled
,
TOKENEXTRA
**
tp
,
BLOCK_SIZE_TYPE
is_sb
)
{
VP9_COMMON
*
const
cm
=
&
cpi
->
common
;
MACROBLOCK
*
const
x
=
&
cpi
->
mb
;
MACROBLOCKD
*
const
xd
=
&
x
->
e_mbd
;
BLOCK_SIZE_TYPE
bsize
=
BLOCK_SIZE_SB32X32
;
int
pl
;
set_partition_seg_context
(
cpi
,
mi_row
,
mi_col
);
pl
=
partition_plane_context
(
xd
,
bsize
);
if
(
is_sb
==
BLOCK_SIZE_SB32X32
)
{
set_offsets
(
cpi
,
mi_row
,
mi_col
,
bsize
);
update_state
(
cpi
,
&
x
->
sb32_context
[
xd
->
sb_index
],
bsize
,
output_enabled
);
encode_superblock
(
cpi
,
tp
,
output_enabled
,
mi_row
,
mi_col
,
bsize
);
if
(
output_enabled
)
{
update_stats
(
cpi
,
mi_row
,
mi_col
);
cpi
->
partition_count
[
pl
][
PARTITION_NONE
]
++
;
(
*
tp
)
->
token
=
EOSB_TOKEN
;
(
*
tp
)
++
;
}
}
else
if
(
is_sb
==
BLOCK_SIZE_SB16X32
)
{
int
i
;
if
(
output_enabled
)
cpi
->
partition_count
[
pl
][
PARTITION_VERT
]
++
;
for
(
i
=
0
;
i
<
2
&&
mi_col
+
(
i
<<
CONFIG_SB8X8
)
!=
cm
->
mi_cols
;
i
++
)
{
set_offsets
(
cpi
,
mi_row
,
mi_col
+
(
i
<<
CONFIG_SB8X8
),
BLOCK_SIZE_SB16X32
);
update_state
(
cpi
,
&
x
->
sb16x32_context
[
xd
->
sb_index
][
i
],
BLOCK_SIZE_SB16X32
,
output_enabled
);
encode_superblock
(
cpi
,
tp
,
output_enabled
,
mi_row
,
mi_col
+
(
i
<<
CONFIG_SB8X8
),
BLOCK_SIZE_SB16X32
);
if
(
output_enabled
)
{
update_stats
(
cpi
,
mi_row
,
mi_col
+
(
i
<<
CONFIG_SB8X8
));
(
*
tp
)
->
token
=
EOSB_TOKEN
;
(
*
tp
)
++
;
}
}
}
else
if
(
is_sb
==
BLOCK_SIZE_SB32X16
)
{
int
i
;
if
(
output_enabled
)
cpi
->
partition_count
[
pl
][
PARTITION_HORZ
]
++
;
for
(
i
=
0
;
i
<
2
&&
mi_row
+
(
i
<<
CONFIG_SB8X8
)
!=
cm
->
mi_rows
;
i
++
)
{
set_offsets
(
cpi
,
mi_row
+
(
i
<<
CONFIG_SB8X8
),
mi_col
,
BLOCK_SIZE_SB32X16
);
update_state
(
cpi
,
&
x
->
sb32x16_context
[
xd
->
sb_index
][
i
],
BLOCK_SIZE_SB32X16
,
output_enabled
);
encode_superblock
(
cpi
,
tp
,
output_enabled
,
mi_row
+
(
i
<<
CONFIG_SB8X8
),
mi_col
,
BLOCK_SIZE_SB32X16
);
if
(
output_enabled
)
{
update_stats
(
cpi
,
mi_row
+
(
i
<<
CONFIG_SB8X8
),
mi_col
);
(
*
tp
)
->
token
=
EOSB_TOKEN
;
(
*
tp
)
++
;
}
}
static
void
set_block_index
(
MACROBLOCKD
*
xd
,
int
idx
,
BLOCK_SIZE_TYPE
bsize
)
{
if
(
bsize
>=
BLOCK_SIZE_SB32X32
)
{
xd
->
sb_index
=
idx
;
}
else
{
int
i
;
if
(
output_enabled
)
cpi
->
partition_count
[
pl
][
PARTITION_SPLIT
]
++
;
#if CONFIG_SB8X8
assert
(
bsize
>=
BLOCK_SIZE_MB16X16
);
#endif
xd
->
mb_index
=
idx
;
}
}
for
(
i
=
0
;
i
<
4
;
i
++
)
{
const
int
x_idx
=
(
i
&
1
)
<<
CONFIG_SB8X8
;
const
int
y_idx
=
(
i
>>
1
)
<<
CONFIG_SB8X8
;
static
PICK_MODE_CONTEXT
*
get_block_context
(
MACROBLOCK
*
x
,
BLOCK_SIZE_TYPE
bsize
)
{
MACROBLOCKD
*
const
xd
=
&
x
->
e_mbd
;
if
((
mi_row
+
y_idx
>=
cm
->
mi_rows
)
||
(
mi_col
+
x_idx
>=
cm
->
mi_cols
))
{
// MB lies outside frame, move on
continue
;
}
switch
(
bsize
)
{
case
BLOCK_SIZE_SB64X64
:
return
&
x
->
sb64_context
;
case
BLOCK_SIZE_SB64X32
:
return
&
x
->
sb64x32_context
[
xd
->
sb_index
];
case
BLOCK_SIZE_SB32X64
:
return
&
x
->
sb32x64_context
[
xd
->
sb_index
];
case
BLOCK_SIZE_SB32X32
:
return
&
x
->
sb32_context
[
xd
->
sb_index
];
case
BLOCK_SIZE_SB32X16
:
return
&
x
->
sb32x16_context
[
xd
->
sb_index
][
xd
->
mb_index
];
case
BLOCK_SIZE_SB16X32
:
return
&
x
->
sb16x32_context
[
xd
->
sb_index
][
xd
->
mb_index
];
case
BLOCK_SIZE_MB16X16
:
return
&
x
->
mb_context
[
xd
->
sb_index
][
xd
->
mb_index
];
default:
assert
(
0
);
return
NULL
;
}
}
set_offsets
(
cpi
,
mi_row
+
y_idx
,
mi_col
+
x_idx
,
BLOCK_SIZE_MB16X16
);
xd
->
mb_index
=
i
;
update_state
(
cpi
,
&
x
->
mb_context
[
xd
->
sb_index
][
i
],
BLOCK_SIZE_MB16X16
,
output_enabled
);
static
void
encode_b
(
VP9_COMP
*
cpi
,
TOKENEXTRA
**
tp
,
int
mi_row
,
int
mi_col
,
int
output_enabled
,
BLOCK_SIZE_TYPE
bsize
,
int
sub_index
)
{
VP9_COMMON
*
const
cm
=
&
cpi
->
common
;
MACROBLOCK
*
const
x
=
&
cpi
->
mb
;
MACROBLOCKD
*
const
xd
=
&
x
->
e_mbd
;
if
(
cpi
->
oxcf
.
tuning
==
VP8_TUNE_SSIM
)
vp9_activity_masking
(
cpi
,
x
)
;
if
(
mi_row
>=
cm
->
mi_rows
||
mi_col
>=
cm
->
mi_cols
)
return
;
encode_macroblock
(
cpi
,
tp
,
output_enabled
,
mi_row
+
y_idx
,
mi_col
+
x_idx
);
if
(
output_enabled
)
{
update_stats
(
cpi
,
mi_row
+
y_idx
,
mi_col
+
x_idx
);
if
(
sub_index
!=
-
1
)
set_block_index
(
xd
,
sub_index
,
bsize
);
set_offsets
(
cpi
,
mi_row
,
mi_col
,
bsize
);
update_state
(
cpi
,
get_block_context
(
x
,
bsize
),
bsize
,
output_enabled
);
if
(
bsize
==
BLOCK_SIZE_MB16X16
)
{
if
(
cpi
->
oxcf
.
tuning
==
VP8_TUNE_SSIM
)
vp9_activity_masking
(
cpi
,
x
);
(
*
tp
)
->
token
=
EOSB_TOKEN
;
(
*
tp
)
++
;
}
}
encode_macroblock
(
cpi
,
tp
,
output_enabled
,
mi_row
,
mi_col
);
}
else
{
encode_superblock
(
cpi
,
tp
,
output_enabled
,
mi_row
,
mi_col
,
bsize
);
}
set_partition_seg_context
(
cpi
,
mi_row
,
mi_col
);
update_partition_context
(
xd
,
is_sb
,
BLOCK_SIZE_SB32X32
);
if
(
output_enabled
)
{
update_stats
(
cpi
,
mi_row
,
mi_col
);
// debug output
#if DBG_PRNT_SEGMAP
{
FILE
*
statsfile
;
statsfile
=
fopen
(
"segmap2.stt"
,
"a"
);
fprintf
(
statsfile
,
"
\n
"
);
fclose
(
statsfile
);
(
*
tp
)
->
token
=
EOSB_TOKEN
;
(
*
tp
)
++
;
}
#endif
}
static
void
encode_sb
64
(
VP9_COMP
*
cpi
,
int
mi_row
,
int
mi_co
l
,
TOKENEXTRA
**
tp
,
BLOCK_SIZE_TYPE
is_sb
[
4
])
{
static
void
encode_sb
(
VP9_COMP
*
cpi
,
TOKENEXTRA
**
tp
,
int
mi_row
,
int
mi_col
,
int
output_enabled
,
BLOCK_SIZE_TYPE
leve
l
,
BLOCK_SIZE_TYPE
c1
,
BLOCK_SIZE_TYPE
c2
[
4
])
{
VP9_COMMON
*
const
cm
=
&
cpi
->
common
;
MACROBLOCK
*
const
x
=
&
cpi
->
mb
;
MACROBLOCKD
*
const
xd
=
&
x
->
e_mbd
;
BLOCK_SIZE_TYPE
bsize
=
BLOCK_SIZE_SB64X64
;
const
int
bsl
=
mi_width_log2
(
level
),
bs
=
1
<<
(
bsl
-
1
);
const
int
bwl
=
mi_width_log2
(
c1
),
bhl
=
mi_height_log2
(
c1
);
int
pl
;
set_partition_seg_context
(
cpi
,
mi_row
,
mi_col
);
pl
=
partition_plane_context
(
xd
,
bsize
)
;
if
(
mi_row
>=
cm
->
mi_rows
||
mi_col
>=
cm
->
mi_cols
)
return
;
if
(
is_sb
[
0
]
==
BLOCK_SIZE_SB64X64
)
{
set_offsets
(
cpi
,
mi_row
,
mi_col
,
bsize
);
update_state
(
cpi
,
&
x
->
sb64_context
,
bsize
,
1
);
encode_superblock
(
cpi
,
tp
,
1
,
mi_row
,
mi_col
,
bsize
);
update_stats
(
cpi
,
mi_row
,
mi_col
);
set_partition_seg_context
(
cpi
,
mi_row
,
mi_col
);
pl
=
partition_plane_context
(
xd
,
level
);
(
*
tp
)
->
token
=
EOSB_TOKEN
;
(
*
tp
)
++
;
cpi
->
partition_count
[
pl
][
PARTITION_NONE
]
++
;
}
else
if
(
is_sb
[
0
]
==
BLOCK_SIZE_SB32X64
)
{
if
(
bsl
==
bwl
&&
bsl
==
bhl
)
{
if
(
output_enabled
&&
level
>
BLOCK_SIZE_MB16X16
)
cpi
->
partition_count
[
pl
][
PARTITION_NONE
]
++
;
encode_b
(
cpi
,
tp
,
mi_row
,
mi_col
,
output_enabled
,
c1
,
-
1
);
}
else
if
(
bsl
==
bhl
&&
bsl
>
bwl
)
{
if
(
output_enabled
)
cpi
->
partition_count
[
pl
][
PARTITION_VERT
]
++
;
encode_b
(
cpi
,
tp
,
mi_row
,
mi_col
,
output_enabled
,
c1
,
0
);
encode_b
(
cpi
,
tp
,
mi_row
,
mi_col
+
bs
,
output_enabled
,
c1
,
1
);
}
else
if
(
bsl
==
bwl
&&
bsl
>
bhl
)
{
if
(
output_enabled
)
cpi
->
partition_count
[
pl
][
PARTITION_HORZ
]
++
;
encode_b
(
cpi
,
tp
,
mi_row
,
mi_col
,
output_enabled
,
c1
,
0
);
encode_b
(
cpi
,
tp
,
mi_row
+
bs
,
mi_col
,
output_enabled
,
c1
,
1
);
}
else
{
BLOCK_SIZE_TYPE
subsize
;
int
i
;
cpi
->
partition_count
[
pl
][
PARTITION_VERT
]
++
;
for
(
i
=
0
;
i
<
2
&&
mi_col
+
(
i
*
2
<<
CONFIG_SB8X8
)
!=
cm
->
mi_cols
;
i
++
)
{
set_offsets
(
cpi
,
mi_row
,
mi_col
+
(
i
*
2
<<
CONFIG_SB8X8
),
BLOCK_SIZE_SB32X64
);
update_state
(
cpi
,
&
x
->
sb32x64_context
[
i
],
BLOCK_SIZE_SB32X64
,
1
);
encode_superblock
(
cpi
,
tp
,
1
,
mi_row
,
mi_col
+
(
i
*
2
<<
CONFIG_SB8X8
),
BLOCK_SIZE_SB32X64
);
update_stats
(
cpi
,
mi_row
,
mi_col
+
(
i
*
2
<<
CONFIG_SB8X8
));
(
*
tp
)
->
token
=
EOSB_TOKEN
;
(
*
tp
)
++
;
assert
(
bwl
<
bsl
&&
bhl
<
bsl
);
if
(
level
==
BLOCK_SIZE_SB64X64
)
{
subsize
=
BLOCK_SIZE_SB32X32
;
}
else
{
assert
(
level
==
BLOCK_SIZE_SB32X32
);
subsize
=
BLOCK_SIZE_MB16X16
;
}
}
else
if
(
is_sb
[
0
]
==
BLOCK_SIZE_SB64X32
)
{
int
i
;
cpi
->
partition_count
[
pl
][
PARTITION_HORZ
]
++
;
for
(
i
=
0
;
i
<
2
&&
mi_row
+
(
i
*
2
<<
CONFIG_SB8X8
)
!=
cm
->
mi_rows
;
i
++
)
{
set_offsets
(
cpi
,
mi_row
+
(
i
*
2
<<
CONFIG_SB8X8
),
mi_col
,
BLOCK_SIZE_SB64X32
);
update_state
(
cpi
,
&
x
->
sb64x32_context
[
i
],
BLOCK_SIZE_SB64X32
,
1
);
encode_superblock
(
cpi
,
tp
,
1
,
mi_row
+
(
i
*
2
<<
CONFIG_SB8X8
),
mi_col
,
BLOCK_SIZE_SB64X32
);
update_stats
(
cpi
,
mi_row
+
(
i
*
2
<<
CONFIG_SB8X8
),
mi_col
);
(
*
tp
)
->
token
=
EOSB_TOKEN
;
(
*
tp
)
++
;
}
}
else
{
int
i
;
cpi
->
partition_count
[
pl
][
PARTITION_SPLIT
]
++
;
if
(
output_enabled
)
cpi
->
partition_count
[
pl
][
PARTITION_SPLIT
]
++
;
for
(
i
=
0
;
i
<
4
;
i
++
)
{
const
int
x_idx
=
(
i
&
1
)
<<
(
1
+
CONFIG_SB8X8
);
const
int
y_idx
=
(
i
&
2
)
<<
CONFIG_SB8X8
;
const
int
x_idx
=
i
&
1
,
y_idx
=
i
>>
1
;
if
(
mi_row
+
y_idx
>=
cm
->
mi_rows
||
mi_col
+
x_idx
>=
cm
->
mi_cols
)
{
// MB lies outside frame, move on
continue
;
}
xd
->
sb_index
=
i
;
encode_sb
(
cpi
,
mi_row
+
y_idx
,
mi_col
+
x_idx
,
1
,
tp
,
is_sb
[
i
]);
set_block_index
(
xd
,
i
,
subsize
);
encode_sb
(
cpi
,
tp
,
mi_row
+
y_idx
*
bs
,
mi_col
+
x_idx
*
bs
,
output_enabled
,
subsize
,
subsize
==
BLOCK_SIZE_MB16X16
?
c1
:
c2
[
i
],
c2
);
}
}
if
(
is_sb
[
0
]
>
BLOCK_SIZE_SB32X32
)
{
if
(
level
>
BLOCK_SIZE_MB16X16
&&
(
level
==
BLOCK_SIZE_SB32X32
||
bsl
==
bwl
||
bsl
==
bhl
))
{
set_partition_seg_context
(
cpi
,
mi_row
,
mi_col
);
update_partition_context
(
xd
,
is_sb
[
0
],
BLOCK_SIZE_SB64X64
);
update_partition_context
(
xd
,
c1
,
level
);
}
}
...
...
@@ -1231,8 +1169,8 @@ static void encode_sb_row(VP9_COMP *cpi,
// pixels of the lower level; also, inverting SB/MB order (big->small
// instead of small->big) means we can use as threshold for small, which
// may enable breakouts if RD is not good enough (i.e. faster)
encode_sb
(
cpi
,
mi_row
+
y_idx
,
mi_col
+
x_idx
,
0
,
tp
,
sb_partitioning
[
i
]
);
encode_sb
(
cpi
,
tp
,
mi_row
+
y_idx
,
mi_col
+
x_idx
,
0
,
BLOCK_SIZE_SB32X32
,
sb_partitioning
[
i
],
sb_partitioning
);
}
for
(
p
=
0
;
p
<
MAX_MB_PLANE
;
p
++
)
{
...
...
@@ -1362,7 +1300,8 @@ static void encode_sb_row(VP9_COMP *cpi,
}
assert
(
tp_orig
==
*
tp
);
encode_sb64
(
cpi
,
mi_row
,
mi_col
,
tp
,
sb_partitioning
);
encode_sb
(
cpi
,
tp
,
mi_row
,
mi_col
,
1
,
BLOCK_SIZE_SB64X64
,
sb_partitioning
[
0
],
sb_partitioning
);
assert
(
tp_orig
<
*
tp
);
}
}
...
...
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
.
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment