Skip to content
GitLab
Projects
Groups
Snippets
/
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Menu
Open sidebar
Mathis Rosenhauer
libaec
Commits
78f89fdb
Commit
78f89fdb
authored
Nov 02, 2012
by
Mathis Rosenhauer
Committed by
Thomas Jahns
Feb 19, 2013
Browse files
Order FSM functions bottom up
parent
fee6bbff
Changes
1
Hide whitespace changes
Inline
Side-by-side
src/encode.c
View file @
78f89fdb
...
...
@@ -27,15 +27,6 @@
#define ROS -1
static
int
m_get_block
(
struct
aec_stream
*
strm
);
static
int
m_get_rsi_resumable
(
struct
aec_stream
*
strm
);
static
int
m_check_zero_block
(
struct
aec_stream
*
strm
);
static
int
m_select_code_option
(
struct
aec_stream
*
strm
);
static
int
m_flush_block
(
struct
aec_stream
*
strm
);
static
int
m_flush_block_resumable
(
struct
aec_stream
*
strm
);
static
int
m_encode_splitting
(
struct
aec_stream
*
strm
);
static
int
m_encode_uncomp
(
struct
aec_stream
*
strm
);
static
int
m_encode_se
(
struct
aec_stream
*
strm
);
static
int
m_encode_zero
(
struct
aec_stream
*
strm
);
static
inline
void
emit
(
struct
internal_state
*
state
,
uint32_t
data
,
int
bits
)
...
...
@@ -394,181 +385,48 @@ static int assess_se_option(uint64_t limit, struct aec_stream *strm)
*
*/
static
int
m_
get
_block
(
struct
aec_stream
*
strm
)
static
int
m_
flush
_block
_resumable
(
struct
aec_stream
*
strm
)
{
/**
Provide the next block of preprocessed input data.
Pull in a whole Reference Sample Interval (RSI) of data if
block buffer is empty.
Slow and restartable flushing
*/
struct
internal_state
*
state
=
strm
->
state
;
if
(
strm
->
avail_out
>
state
->
cds_len
)
{
if
(
!
state
->
direct_out
)
{
state
->
direct_out
=
1
;
*
strm
->
next_out
=
*
state
->
cds
;
state
->
cds
=
strm
->
next_out
;
}
}
else
{
if
(
state
->
zero_blocks
==
0
||
state
->
direct_out
)
{
/* copy leftover from last block */
*
state
->
cds_buf
=
*
state
->
cds
;
state
->
cds
=
state
->
cds_buf
;
}
state
->
direct_out
=
0
;
}
if
(
state
->
blocks_avail
==
0
)
{
state
->
block
=
state
->
data_pp
;
if
(
strm
->
avail_in
>=
state
->
block_len
*
strm
->
rsi
)
{
state
->
get_rsi
(
strm
);
state
->
blocks_avail
=
strm
->
rsi
-
1
;
while
(
state
->
cds_buf
+
state
->
i
<
state
->
cds
)
{
if
(
strm
->
avail_out
==
0
)
return
M_EXIT
;
if
(
strm
->
flags
&
AEC_DATA_PREPROCESS
)
{
state
->
preprocess
(
strm
);
state
->
ref
=
1
;
}
return
m_check_zero_block
(
strm
);
}
else
{
state
->
i
=
0
;
state
->
mode
=
m_get_rsi_resumable
;
}
}
else
{
state
->
ref
=
0
;
state
->
block
+=
strm
->
block_size
;
state
->
blocks_avail
--
;
return
m_check_zero_block
(
strm
);
*
strm
->
next_out
++
=
state
->
cds_buf
[
state
->
i
];
strm
->
avail_out
--
;
strm
->
total_out
++
;
state
->
i
++
;
}
state
->
mode
=
m_get_block
;
return
M_CONTINUE
;
}
static
int
m_get_rsi_resumable
(
struct
aec_stream
*
strm
)
{
/**
Get RSI while input buffer is short.
Let user provide more input. Once we got all input pad buffer
to full RSI.
*/
int
j
;
struct
internal_state
*
state
=
strm
->
state
;
do
{
if
(
strm
->
avail_in
>
0
)
{
state
->
data_raw
[
state
->
i
]
=
state
->
get_sample
(
strm
);
}
else
{
if
(
state
->
flush
==
AEC_FLUSH
)
{
if
(
state
->
i
>
0
)
{
for
(
j
=
state
->
i
;
j
<
strm
->
rsi
*
strm
->
block_size
;
j
++
)
state
->
data_raw
[
j
]
=
state
->
data_raw
[
state
->
i
-
1
];
state
->
i
=
strm
->
rsi
*
strm
->
block_size
;
}
else
{
if
(
state
->
zero_blocks
)
{
state
->
mode
=
m_encode_zero
;
return
M_CONTINUE
;
}
emit
(
state
,
0
,
state
->
bits
);
if
(
state
->
direct_out
==
0
)
*
strm
->
next_out
++
=
*
state
->
cds
;
strm
->
avail_out
--
;
strm
->
total_out
++
;
return
M_EXIT
;
}
}
else
{
return
M_EXIT
;
}
}
}
while
(
++
state
->
i
<
strm
->
rsi
*
strm
->
block_size
);
state
->
blocks_avail
=
strm
->
rsi
-
1
;
if
(
strm
->
flags
&
AEC_DATA_PREPROCESS
)
{
state
->
preprocess
(
strm
);
state
->
ref
=
1
;
}
return
m_check_zero_block
(
strm
);
}
static
int
m_check_zero_block
(
struct
aec_stream
*
strm
)
static
int
m_flush_block
(
struct
aec_stream
*
strm
)
{
/**
Check if input block is all z
er
o
.
Flush block in direct_out mode by updating count
er
s
.
Aggregate consecutive zero blocks until we find !0 or reach the
end of a segment or RSI.
Fall back to slow flushing if in buffered mode.
*/
int
n
;
struct
internal_state
*
state
=
strm
->
state
;
uint32_t
*
p
=
state
->
block
+
state
->
ref
;
uint32_t
*
end
=
state
->
block
+
strm
->
block_size
;
while
(
p
<
end
&&
*
p
==
0
)
p
++
;
if
(
p
<
end
)
{
if
(
state
->
zero_blocks
)
{
/* The current block isn't zero but we have to emit a
* previous zero block first. The current block will be
* handled later.
*/
state
->
block
-=
strm
->
block_size
;
state
->
blocks_avail
++
;
state
->
mode
=
m_encode_zero
;
return
M_CONTINUE
;
}
state
->
mode
=
m_select_code_option
;
return
M_CONTINUE
;
}
else
{
state
->
zero_blocks
++
;
if
(
state
->
zero_blocks
==
1
)
{
state
->
zero_ref
=
state
->
ref
;
state
->
zero_ref_sample
=
state
->
block
[
0
];
}
if
(
state
->
blocks_avail
==
0
||
(
strm
->
rsi
-
state
->
blocks_avail
)
%
64
==
0
)
{
if
(
state
->
zero_blocks
>
4
)
state
->
zero_blocks
=
ROS
;
state
->
mode
=
m_encode_zero
;
return
M_CONTINUE
;
}
if
(
state
->
direct_out
)
{
n
=
state
->
cds
-
strm
->
next_out
;
strm
->
next_out
+=
n
;
strm
->
avail_out
-=
n
;
strm
->
total_out
+=
n
;
state
->
mode
=
m_get_block
;
return
M_CONTINUE
;
}
}
static
int
m_select_code_option
(
struct
aec_stream
*
strm
)
{
/**
Decide which code option to use.
*/
uint64_t
uncomp_len
;
uint64_t
split_len
;
uint64_t
se_len
;
struct
internal_state
*
state
=
strm
->
state
;
uncomp_len
=
(
strm
->
block_size
-
state
->
ref
)
*
strm
->
bit_per_sample
;
split_len
=
assess_splitting_option
(
strm
);
se_len
=
assess_se_option
(
split_len
,
strm
);
if
(
split_len
<
uncomp_len
)
{
if
(
split_len
<
se_len
)
return
m_encode_splitting
(
strm
);
else
return
m_encode_se
(
strm
);
}
else
{
if
(
uncomp_len
<=
se_len
)
return
m_encode_uncomp
(
strm
);
else
return
m_encode_se
(
strm
);
}
state
->
i
=
0
;
state
->
mode
=
m_flush_block_resumable
;
return
M_CONTINUE
;
}
static
int
m_encode_splitting
(
struct
aec_stream
*
strm
)
...
...
@@ -643,47 +501,180 @@ static int m_encode_zero(struct aec_stream *strm)
return
m_flush_block
(
strm
);
}
static
int
m_
flush_block
(
struct
aec_stream
*
strm
)
static
int
m_
select_code_option
(
struct
aec_stream
*
strm
)
{
/**
Flush block in direct_out mode by updating counters.
Decide which code option to use.
*/
Fall back to slow flushing if in buffered mode.
uint64_t
uncomp_len
;
uint64_t
split_len
;
uint64_t
se_len
;
struct
internal_state
*
state
=
strm
->
state
;
uncomp_len
=
(
strm
->
block_size
-
state
->
ref
)
*
strm
->
bit_per_sample
;
split_len
=
assess_splitting_option
(
strm
);
se_len
=
assess_se_option
(
split_len
,
strm
);
if
(
split_len
<
uncomp_len
)
{
if
(
split_len
<
se_len
)
return
m_encode_splitting
(
strm
);
else
return
m_encode_se
(
strm
);
}
else
{
if
(
uncomp_len
<=
se_len
)
return
m_encode_uncomp
(
strm
);
else
return
m_encode_se
(
strm
);
}
}
static
int
m_check_zero_block
(
struct
aec_stream
*
strm
)
{
/**
Check if input block is all zero.
Aggregate consecutive zero blocks until we find !0 or reach the
end of a segment or RSI.
*/
int
n
;
struct
internal_state
*
state
=
strm
->
state
;
uint32_t
*
p
=
state
->
block
+
state
->
ref
;
uint32_t
*
end
=
state
->
block
+
strm
->
block_size
;
if
(
state
->
direct_out
)
{
n
=
state
->
cds
-
strm
->
next_out
;
strm
->
next_out
+=
n
;
strm
->
avail_out
-=
n
;
strm
->
total_out
+=
n
;
while
(
p
<
end
&&
*
p
==
0
)
p
++
;
if
(
p
<
end
)
{
if
(
state
->
zero_blocks
)
{
/* The current block isn't zero but we have to emit a
* previous zero block first. The current block will be
* handled later.
*/
state
->
block
-=
strm
->
block_size
;
state
->
blocks_avail
++
;
state
->
mode
=
m_encode_zero
;
return
M_CONTINUE
;
}
state
->
mode
=
m_select_code_option
;
return
M_CONTINUE
;
}
else
{
state
->
zero_blocks
++
;
if
(
state
->
zero_blocks
==
1
)
{
state
->
zero_ref
=
state
->
ref
;
state
->
zero_ref_sample
=
state
->
block
[
0
];
}
if
(
state
->
blocks_avail
==
0
||
(
strm
->
rsi
-
state
->
blocks_avail
)
%
64
==
0
)
{
if
(
state
->
zero_blocks
>
4
)
state
->
zero_blocks
=
ROS
;
state
->
mode
=
m_encode_zero
;
return
M_CONTINUE
;
}
state
->
mode
=
m_get_block
;
return
M_CONTINUE
;
}
}
state
->
i
=
0
;
state
->
mode
=
m_flush_block_resumable
;
return
M_CONTINUE
;
static
int
m_get_rsi_resumable
(
struct
aec_stream
*
strm
)
{
/**
Get RSI while input buffer is short.
Let user provide more input. Once we got all input pad buffer
to full RSI.
*/
int
j
;
struct
internal_state
*
state
=
strm
->
state
;
do
{
if
(
strm
->
avail_in
>
0
)
{
state
->
data_raw
[
state
->
i
]
=
state
->
get_sample
(
strm
);
}
else
{
if
(
state
->
flush
==
AEC_FLUSH
)
{
if
(
state
->
i
>
0
)
{
for
(
j
=
state
->
i
;
j
<
strm
->
rsi
*
strm
->
block_size
;
j
++
)
state
->
data_raw
[
j
]
=
state
->
data_raw
[
state
->
i
-
1
];
state
->
i
=
strm
->
rsi
*
strm
->
block_size
;
}
else
{
if
(
state
->
zero_blocks
)
{
state
->
mode
=
m_encode_zero
;
return
M_CONTINUE
;
}
emit
(
state
,
0
,
state
->
bits
);
if
(
state
->
direct_out
==
0
)
*
strm
->
next_out
++
=
*
state
->
cds
;
strm
->
avail_out
--
;
strm
->
total_out
++
;
return
M_EXIT
;
}
}
else
{
return
M_EXIT
;
}
}
}
while
(
++
state
->
i
<
strm
->
rsi
*
strm
->
block_size
);
state
->
blocks_avail
=
strm
->
rsi
-
1
;
if
(
strm
->
flags
&
AEC_DATA_PREPROCESS
)
{
state
->
preprocess
(
strm
);
state
->
ref
=
1
;
}
return
m_check_zero_block
(
strm
);
}
static
int
m_
flush
_block
_resumable
(
struct
aec_stream
*
strm
)
static
int
m_
get
_block
(
struct
aec_stream
*
strm
)
{
/**
Slow and restartable flushing
Provide the next block of preprocessed input data.
Pull in a whole Reference Sample Interval (RSI) of data if
block buffer is empty.
*/
struct
internal_state
*
state
=
strm
->
state
;
while
(
state
->
cds_buf
+
state
->
i
<
state
->
cds
)
{
if
(
strm
->
avail_out
==
0
)
return
M_EXIT
;
if
(
strm
->
avail_out
>
state
->
cds_len
)
{
if
(
!
state
->
direct_out
)
{
state
->
direct_out
=
1
;
*
strm
->
next_out
=
*
state
->
cds
;
state
->
cds
=
strm
->
next_out
;
}
}
else
{
if
(
state
->
zero_blocks
==
0
||
state
->
direct_out
)
{
/* copy leftover from last block */
*
state
->
cds_buf
=
*
state
->
cds
;
state
->
cds
=
state
->
cds_buf
;
}
state
->
direct_out
=
0
;
}
*
strm
->
next_out
++
=
state
->
cds_buf
[
state
->
i
];
strm
->
avail_out
--
;
strm
->
total_out
++
;
state
->
i
++
;
if
(
state
->
blocks_avail
==
0
)
{
state
->
block
=
state
->
data_pp
;
if
(
strm
->
avail_in
>=
state
->
block_len
*
strm
->
rsi
)
{
state
->
get_rsi
(
strm
);
state
->
blocks_avail
=
strm
->
rsi
-
1
;
if
(
strm
->
flags
&
AEC_DATA_PREPROCESS
)
{
state
->
preprocess
(
strm
);
state
->
ref
=
1
;
}
return
m_check_zero_block
(
strm
);
}
else
{
state
->
i
=
0
;
state
->
mode
=
m_get_rsi_resumable
;
}
}
else
{
state
->
ref
=
0
;
state
->
block
+=
strm
->
block_size
;
state
->
blocks_avail
--
;
return
m_check_zero_block
(
strm
);
}
state
->
mode
=
m_get_block
;
return
M_CONTINUE
;
}
...
...
@@ -816,8 +807,8 @@ int aec_encode(struct aec_stream *strm, int flush)
encoder.
*/
int
n
;
struct
internal_state
*
state
;
state
=
strm
->
state
;
struct
internal_state
*
state
=
strm
->
state
;
state
->
flush
=
flush
;
while
(
state
->
mode
(
strm
)
==
M_CONTINUE
);
...
...
Write
Preview
Supports
Markdown
0%
Try again
or
attach a new 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