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
767dd469
Commit
767dd469
authored
Apr 29, 2013
by
Ronald S. Bultje
Committed by
Gerrit Code Review
Apr 29, 2013
Browse files
Options
Browse Files
Download
Plain Diff
Merge "Merge encode_sb and encode_sb64 in a recursive encode_sb/b function." into experimental
parents
02d8cbaa
e4f0c541
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 @
767dd469
...
...
@@ -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