Skip to content
Projects
Groups
Snippets
Help
Loading...
Sign in / Register
Toggle navigation
F
ffmpeg
Project
Project
Details
Activity
Cycle Analytics
Repository
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Charts
Issues
0
Issues
0
List
Board
Labels
Milestones
Merge Requests
0
Merge Requests
0
CI / CD
CI / CD
Pipelines
Jobs
Schedules
Charts
Packages
Packages
Wiki
Wiki
Snippets
Snippets
Members
Members
Collapse sidebar
Close sidebar
Activity
Graph
Charts
Create a new issue
Jobs
Commits
Issue Boards
Open sidebar
submodule
ffmpeg
Commits
82541d83
Commit
82541d83
authored
Dec 30, 2012
by
Nicolas George
Browse files
Options
Browse Files
Download
Email Patches
Plain Diff
lavfi: merge all filtering code into ff_filter_frame.
parent
765158dd
Hide whitespace changes
Inline
Side-by-side
Showing
3 changed files
with
155 additions
and
326 deletions
+155
-326
audio.c
libavfilter/audio.c
+0
-111
avfilter.c
libavfilter/avfilter.c
+155
-14
video.c
libavfilter/video.c
+0
-201
No files found.
libavfilter/audio.c
View file @
82541d83
...
...
@@ -179,114 +179,3 @@ AVFilterBufferRef* avfilter_get_audio_buffer_ref_from_arrays(uint8_t **data,
nb_samples
,
sample_fmt
,
channels
,
channel_layout
);
}
static
int
default_filter_frame
(
AVFilterLink
*
link
,
AVFilterBufferRef
*
frame
)
{
return
ff_filter_frame
(
link
->
dst
->
outputs
[
0
],
frame
);
}
int
ff_filter_samples_framed
(
AVFilterLink
*
link
,
AVFilterBufferRef
*
samplesref
)
{
int
(
*
filter_frame
)(
AVFilterLink
*
,
AVFilterBufferRef
*
);
AVFilterPad
*
src
=
link
->
srcpad
;
AVFilterPad
*
dst
=
link
->
dstpad
;
int64_t
pts
;
AVFilterBufferRef
*
buf_out
;
int
ret
;
FF_TPRINTF_START
(
NULL
,
filter_frame
);
ff_tlog_link
(
NULL
,
link
,
1
);
if
(
link
->
closed
)
{
avfilter_unref_buffer
(
samplesref
);
return
AVERROR_EOF
;
}
if
(
!
(
filter_frame
=
dst
->
filter_frame
))
filter_frame
=
default_filter_frame
;
av_assert1
((
samplesref
->
perms
&
src
->
min_perms
)
==
src
->
min_perms
);
samplesref
->
perms
&=
~
src
->
rej_perms
;
/* prepare to copy the samples if the buffer has insufficient permissions */
if
((
dst
->
min_perms
&
samplesref
->
perms
)
!=
dst
->
min_perms
||
dst
->
rej_perms
&
samplesref
->
perms
)
{
av_log
(
link
->
dst
,
AV_LOG_DEBUG
,
"Copying audio data in avfilter (have perms %x, need %x, reject %x)
\n
"
,
samplesref
->
perms
,
link
->
dstpad
->
min_perms
,
link
->
dstpad
->
rej_perms
);
buf_out
=
ff_default_get_audio_buffer
(
link
,
dst
->
min_perms
,
samplesref
->
audio
->
nb_samples
);
if
(
!
buf_out
)
{
avfilter_unref_buffer
(
samplesref
);
return
AVERROR
(
ENOMEM
);
}
buf_out
->
pts
=
samplesref
->
pts
;
buf_out
->
audio
->
sample_rate
=
samplesref
->
audio
->
sample_rate
;
/* Copy actual data into new samples buffer */
av_samples_copy
(
buf_out
->
extended_data
,
samplesref
->
extended_data
,
0
,
0
,
samplesref
->
audio
->
nb_samples
,
av_get_channel_layout_nb_channels
(
link
->
channel_layout
),
link
->
format
);
avfilter_unref_buffer
(
samplesref
);
}
else
buf_out
=
samplesref
;
link
->
cur_buf
=
buf_out
;
pts
=
buf_out
->
pts
;
ret
=
filter_frame
(
link
,
buf_out
);
ff_update_link_current_pts
(
link
,
pts
);
return
ret
;
}
int
ff_filter_samples
(
AVFilterLink
*
link
,
AVFilterBufferRef
*
samplesref
)
{
int
insamples
=
samplesref
->
audio
->
nb_samples
,
inpos
=
0
,
nb_samples
;
AVFilterBufferRef
*
pbuf
=
link
->
partial_buf
;
int
nb_channels
=
av_get_channel_layout_nb_channels
(
link
->
channel_layout
);
int
ret
=
0
;
av_assert1
(
samplesref
->
format
==
link
->
format
);
av_assert1
(
samplesref
->
audio
->
channels
==
link
->
channels
);
av_assert1
(
samplesref
->
audio
->
channel_layout
==
link
->
channel_layout
);
av_assert1
(
samplesref
->
audio
->
sample_rate
==
link
->
sample_rate
);
if
(
!
link
->
min_samples
||
(
!
pbuf
&&
insamples
>=
link
->
min_samples
&&
insamples
<=
link
->
max_samples
))
{
return
ff_filter_samples_framed
(
link
,
samplesref
);
}
/* Handle framing (min_samples, max_samples) */
while
(
insamples
)
{
if
(
!
pbuf
)
{
AVRational
samples_tb
=
{
1
,
link
->
sample_rate
};
int
perms
=
link
->
dstpad
->
min_perms
|
AV_PERM_WRITE
;
pbuf
=
ff_get_audio_buffer
(
link
,
perms
,
link
->
partial_buf_size
);
if
(
!
pbuf
)
{
av_log
(
link
->
dst
,
AV_LOG_WARNING
,
"Samples dropped due to memory allocation failure.
\n
"
);
return
0
;
}
avfilter_copy_buffer_ref_props
(
pbuf
,
samplesref
);
pbuf
->
pts
=
samplesref
->
pts
+
av_rescale_q
(
inpos
,
samples_tb
,
link
->
time_base
);
pbuf
->
audio
->
nb_samples
=
0
;
}
nb_samples
=
FFMIN
(
insamples
,
link
->
partial_buf_size
-
pbuf
->
audio
->
nb_samples
);
av_samples_copy
(
pbuf
->
extended_data
,
samplesref
->
extended_data
,
pbuf
->
audio
->
nb_samples
,
inpos
,
nb_samples
,
nb_channels
,
link
->
format
);
inpos
+=
nb_samples
;
insamples
-=
nb_samples
;
pbuf
->
audio
->
nb_samples
+=
nb_samples
;
if
(
pbuf
->
audio
->
nb_samples
>=
link
->
min_samples
)
{
ret
=
ff_filter_samples_framed
(
link
,
pbuf
);
pbuf
=
NULL
;
}
}
avfilter_unref_buffer
(
samplesref
);
link
->
partial_buf
=
pbuf
;
return
ret
;
}
libavfilter/avfilter.c
View file @
82541d83
...
...
@@ -34,6 +34,8 @@
#include "internal.h"
#include "audio.h"
static
int
ff_filter_frame_framed
(
AVFilterLink
*
link
,
AVFilterBufferRef
*
frame
);
char
*
ff_get_ref_perms_string
(
char
*
buf
,
size_t
buf_size
,
int
perms
)
{
snprintf
(
buf
,
buf_size
,
"%s%s%s%s%s%s"
,
...
...
@@ -342,7 +344,7 @@ int ff_request_frame(AVFilterLink *link)
if
(
ret
==
AVERROR_EOF
&&
link
->
partial_buf
)
{
AVFilterBufferRef
*
pbuf
=
link
->
partial_buf
;
link
->
partial_buf
=
NULL
;
ff_filter_
samples
_framed
(
link
,
pbuf
);
ff_filter_
frame
_framed
(
link
,
pbuf
);
return
0
;
}
if
(
ret
==
AVERROR_EOF
)
...
...
@@ -631,22 +633,161 @@ enum AVMediaType avfilter_pad_get_type(AVFilterPad *pads, int pad_idx)
return
pads
[
pad_idx
].
type
;
}
static
int
default_filter_frame
(
AVFilterLink
*
link
,
AVFilterBufferRef
*
frame
)
{
return
ff_filter_frame
(
link
->
dst
->
outputs
[
0
],
frame
);
}
static
int
ff_filter_frame_framed
(
AVFilterLink
*
link
,
AVFilterBufferRef
*
frame
)
{
int
(
*
filter_frame
)(
AVFilterLink
*
,
AVFilterBufferRef
*
);
AVFilterPad
*
src
=
link
->
srcpad
;
AVFilterPad
*
dst
=
link
->
dstpad
;
AVFilterBufferRef
*
out
;
int
perms
,
ret
;
AVFilterCommand
*
cmd
=
link
->
dst
->
command_queue
;
int64_t
pts
;
if
(
link
->
closed
)
{
avfilter_unref_buffer
(
frame
);
return
AVERROR_EOF
;
}
if
(
!
(
filter_frame
=
dst
->
filter_frame
))
filter_frame
=
default_filter_frame
;
av_assert1
((
frame
->
perms
&
src
->
min_perms
)
==
src
->
min_perms
);
frame
->
perms
&=
~
src
->
rej_perms
;
perms
=
frame
->
perms
;
if
(
frame
->
linesize
[
0
]
<
0
)
perms
|=
AV_PERM_NEG_LINESIZES
;
/* prepare to copy the frame if the buffer has insufficient permissions */
if
((
dst
->
min_perms
&
perms
)
!=
dst
->
min_perms
||
dst
->
rej_perms
&
perms
)
{
av_log
(
link
->
dst
,
AV_LOG_DEBUG
,
"Copying data in avfilter (have perms %x, need %x, reject %x)
\n
"
,
perms
,
link
->
dstpad
->
min_perms
,
link
->
dstpad
->
rej_perms
);
/* Maybe use ff_copy_buffer_ref instead? */
switch
(
link
->
type
)
{
case
AVMEDIA_TYPE_VIDEO
:
out
=
ff_get_video_buffer
(
link
,
dst
->
min_perms
,
link
->
w
,
link
->
h
);
break
;
case
AVMEDIA_TYPE_AUDIO
:
out
=
ff_get_audio_buffer
(
link
,
dst
->
min_perms
,
frame
->
audio
->
nb_samples
);
break
;
default:
return
AVERROR
(
EINVAL
);
}
if
(
!
out
)
{
avfilter_unref_buffer
(
frame
);
return
AVERROR
(
ENOMEM
);
}
avfilter_copy_buffer_ref_props
(
out
,
frame
);
switch
(
link
->
type
)
{
case
AVMEDIA_TYPE_VIDEO
:
av_image_copy
(
out
->
data
,
out
->
linesize
,
frame
->
data
,
frame
->
linesize
,
frame
->
format
,
frame
->
video
->
w
,
frame
->
video
->
h
);
break
;
case
AVMEDIA_TYPE_AUDIO
:
av_samples_copy
(
out
->
extended_data
,
frame
->
extended_data
,
0
,
0
,
frame
->
audio
->
nb_samples
,
av_get_channel_layout_nb_channels
(
frame
->
audio
->
channel_layout
),
frame
->
format
);
break
;
default:
return
AVERROR
(
EINVAL
);
}
avfilter_unref_buffer
(
frame
);
}
else
out
=
frame
;
while
(
cmd
&&
cmd
->
time
<=
frame
->
pts
*
av_q2d
(
link
->
time_base
)){
av_log
(
link
->
dst
,
AV_LOG_DEBUG
,
"Processing command time:%f command:%s arg:%s
\n
"
,
cmd
->
time
,
cmd
->
command
,
cmd
->
arg
);
avfilter_process_command
(
link
->
dst
,
cmd
->
command
,
cmd
->
arg
,
0
,
0
,
cmd
->
flags
);
ff_command_queue_pop
(
link
->
dst
);
cmd
=
link
->
dst
->
command_queue
;
}
pts
=
out
->
pts
;
ret
=
filter_frame
(
link
,
out
);
ff_update_link_current_pts
(
link
,
pts
);
return
ret
;
}
static
int
ff_filter_frame_needs_framing
(
AVFilterLink
*
link
,
AVFilterBufferRef
*
frame
)
{
int
insamples
=
frame
->
audio
->
nb_samples
,
inpos
=
0
,
nb_samples
;
AVFilterBufferRef
*
pbuf
=
link
->
partial_buf
;
int
nb_channels
=
frame
->
audio
->
channels
;
int
ret
=
0
;
/* Handle framing (min_samples, max_samples) */
while
(
insamples
)
{
if
(
!
pbuf
)
{
AVRational
samples_tb
=
{
1
,
link
->
sample_rate
};
int
perms
=
link
->
dstpad
->
min_perms
|
AV_PERM_WRITE
;
pbuf
=
ff_get_audio_buffer
(
link
,
perms
,
link
->
partial_buf_size
);
if
(
!
pbuf
)
{
av_log
(
link
->
dst
,
AV_LOG_WARNING
,
"Samples dropped due to memory allocation failure.
\n
"
);
return
0
;
}
avfilter_copy_buffer_ref_props
(
pbuf
,
frame
);
pbuf
->
pts
=
frame
->
pts
+
av_rescale_q
(
inpos
,
samples_tb
,
link
->
time_base
);
pbuf
->
audio
->
nb_samples
=
0
;
}
nb_samples
=
FFMIN
(
insamples
,
link
->
partial_buf_size
-
pbuf
->
audio
->
nb_samples
);
av_samples_copy
(
pbuf
->
extended_data
,
frame
->
extended_data
,
pbuf
->
audio
->
nb_samples
,
inpos
,
nb_samples
,
nb_channels
,
link
->
format
);
inpos
+=
nb_samples
;
insamples
-=
nb_samples
;
pbuf
->
audio
->
nb_samples
+=
nb_samples
;
if
(
pbuf
->
audio
->
nb_samples
>=
link
->
min_samples
)
{
ret
=
ff_filter_frame_framed
(
link
,
pbuf
);
pbuf
=
NULL
;
}
}
avfilter_unref_buffer
(
frame
);
link
->
partial_buf
=
pbuf
;
return
ret
;
}
int
ff_filter_frame
(
AVFilterLink
*
link
,
AVFilterBufferRef
*
frame
)
{
int
ret
;
FF_TPRINTF_START
(
NULL
,
filter_frame
);
ff_tlog_link
(
NULL
,
link
,
1
);
ff_tlog
(
NULL
,
" "
);
ff_tlog_ref
(
NULL
,
frame
,
1
);
switch
(
link
->
type
)
{
case
AVMEDIA_TYPE_VIDEO
:
if
((
ret
=
ff_start_frame
(
link
,
frame
))
<
0
)
return
ret
;
if
((
ret
=
ff_draw_slice
(
link
,
0
,
frame
->
video
->
h
,
1
))
<
0
)
return
ret
;
if
((
ret
=
ff_end_frame
(
link
))
<
0
)
return
ret
;
return
ret
;
case
AVMEDIA_TYPE_AUDIO
:
return
ff_filter_samples
(
link
,
frame
);
default:
return
AVERROR
(
EINVAL
);
/* Consistency checks */
if
(
link
->
type
==
AVMEDIA_TYPE_VIDEO
)
{
if
(
strcmp
(
link
->
dst
->
filter
->
name
,
"scale"
))
{
av_assert1
(
frame
->
format
==
link
->
format
);
av_assert1
(
frame
->
video
->
w
==
link
->
w
);
av_assert1
(
frame
->
video
->
h
==
link
->
h
);
}
}
else
{
av_assert1
(
frame
->
format
==
link
->
format
);
av_assert1
(
frame
->
audio
->
channels
==
link
->
channels
);
av_assert1
(
frame
->
audio
->
channel_layout
==
link
->
channel_layout
);
av_assert1
(
frame
->
audio
->
sample_rate
==
link
->
sample_rate
);
}
/* Go directly to actual filtering if possible */
if
(
link
->
type
==
AVMEDIA_TYPE_AUDIO
&&
link
->
min_samples
&&
(
link
->
partial_buf
||
frame
->
audio
->
nb_samples
<
link
->
min_samples
||
frame
->
audio
->
nb_samples
>
link
->
max_samples
))
{
return
ff_filter_frame_needs_framing
(
link
,
frame
);
}
else
{
return
ff_filter_frame_framed
(
link
,
frame
);
}
}
libavfilter/video.c
View file @
82541d83
...
...
@@ -158,204 +158,3 @@ AVFilterBufferRef *ff_get_video_buffer(AVFilterLink *link, int perms, int w, int
return
ret
;
}
static
int
default_start_frame
(
AVFilterLink
*
inlink
,
AVFilterBufferRef
*
picref
)
{
AVFilterLink
*
outlink
=
NULL
;
if
(
inlink
->
dstpad
->
filter_frame
)
return
0
;
if
(
inlink
->
dst
->
nb_outputs
)
outlink
=
inlink
->
dst
->
outputs
[
0
];
if
(
outlink
&&
(
inlink
->
dstpad
->
start_frame
||
inlink
->
dstpad
->
end_frame
))
{
AVFilterBufferRef
*
buf_out
;
outlink
->
out_buf
=
ff_get_video_buffer
(
outlink
,
AV_PERM_WRITE
,
outlink
->
w
,
outlink
->
h
);
if
(
!
outlink
->
out_buf
)
return
AVERROR
(
ENOMEM
);
avfilter_copy_buffer_ref_props
(
outlink
->
out_buf
,
picref
);
outlink
->
out_buf
->
video
->
w
=
outlink
->
w
;
outlink
->
out_buf
->
video
->
h
=
outlink
->
h
;
buf_out
=
avfilter_ref_buffer
(
outlink
->
out_buf
,
~
0
);
if
(
!
buf_out
)
return
AVERROR
(
ENOMEM
);
return
ff_start_frame
(
outlink
,
buf_out
);
}
return
0
;
}
static
void
clear_link
(
AVFilterLink
*
link
)
{
avfilter_unref_bufferp
(
&
link
->
cur_buf
);
avfilter_unref_bufferp
(
&
link
->
src_buf
);
avfilter_unref_bufferp
(
&
link
->
out_buf
);
link
->
cur_buf_copy
=
NULL
;
/* we do not own the reference */
}
/* XXX: should we do the duplicating of the picture ref here, instead of
* forcing the source filter to do it? */
int
ff_start_frame
(
AVFilterLink
*
link
,
AVFilterBufferRef
*
picref
)
{
int
(
*
start_frame
)(
AVFilterLink
*
,
AVFilterBufferRef
*
);
AVFilterPad
*
src
=
link
->
srcpad
;
AVFilterPad
*
dst
=
link
->
dstpad
;
int
ret
,
perms
;
AVFilterCommand
*
cmd
=
link
->
dst
->
command_queue
;
int64_t
pts
;
FF_TPRINTF_START
(
NULL
,
start_frame
);
ff_tlog_link
(
NULL
,
link
,
0
);
ff_tlog
(
NULL
,
" "
);
ff_tlog_ref
(
NULL
,
picref
,
1
);
if
(
strcmp
(
link
->
dst
->
filter
->
name
,
"scale"
))
{
av_assert1
(
picref
->
format
==
link
->
format
);
av_assert1
(
picref
->
video
->
w
==
link
->
w
);
av_assert1
(
picref
->
video
->
h
==
link
->
h
);
}
if
(
link
->
closed
)
{
avfilter_unref_buffer
(
picref
);
return
AVERROR_EOF
;
}
if
(
!
(
start_frame
=
dst
->
start_frame
))
start_frame
=
default_start_frame
;
av_assert1
((
picref
->
perms
&
src
->
min_perms
)
==
src
->
min_perms
);
picref
->
perms
&=
~
src
->
rej_perms
;
perms
=
picref
->
perms
;
if
(
picref
->
linesize
[
0
]
<
0
)
perms
|=
AV_PERM_NEG_LINESIZES
;
/* prepare to copy the picture if it has insufficient permissions */
if
((
dst
->
min_perms
&
perms
)
!=
dst
->
min_perms
||
dst
->
rej_perms
&
perms
)
{
av_log
(
link
->
dst
,
AV_LOG_DEBUG
,
"frame copy needed (have perms %x, need %x, reject %x)
\n
"
,
picref
->
perms
,
link
->
dstpad
->
min_perms
,
link
->
dstpad
->
rej_perms
);
link
->
cur_buf
=
ff_get_video_buffer
(
link
,
dst
->
min_perms
,
link
->
w
,
link
->
h
);
if
(
!
link
->
cur_buf
)
{
avfilter_unref_bufferp
(
&
picref
);
return
AVERROR
(
ENOMEM
);
}
link
->
src_buf
=
picref
;
avfilter_copy_buffer_ref_props
(
link
->
cur_buf
,
link
->
src_buf
);
/* copy palette if required */
if
(
av_pix_fmt_desc_get
(
link
->
format
)
->
flags
&
PIX_FMT_PAL
)
memcpy
(
link
->
cur_buf
->
data
[
1
],
link
->
src_buf
->
data
[
1
],
AVPALETTE_SIZE
);
}
else
link
->
cur_buf
=
picref
;
link
->
cur_buf_copy
=
link
->
cur_buf
;
while
(
cmd
&&
cmd
->
time
<=
picref
->
pts
*
av_q2d
(
link
->
time_base
)){
av_log
(
link
->
dst
,
AV_LOG_DEBUG
,
"Processing command time:%f command:%s arg:%s
\n
"
,
cmd
->
time
,
cmd
->
command
,
cmd
->
arg
);
avfilter_process_command
(
link
->
dst
,
cmd
->
command
,
cmd
->
arg
,
0
,
0
,
cmd
->
flags
);
ff_command_queue_pop
(
link
->
dst
);
cmd
=
link
->
dst
->
command_queue
;
}
pts
=
link
->
cur_buf
->
pts
;
ret
=
start_frame
(
link
,
link
->
cur_buf
);
ff_update_link_current_pts
(
link
,
pts
);
if
(
ret
<
0
)
clear_link
(
link
);
else
/* incoming buffers must not be freed in start frame,
because they can still be in use by the automatic copy mechanism */
av_assert1
(
link
->
cur_buf_copy
->
buf
->
refcount
>
0
);
return
ret
;
}
static
int
default_end_frame
(
AVFilterLink
*
inlink
)
{
AVFilterLink
*
outlink
=
NULL
;
if
(
inlink
->
dstpad
->
filter_frame
)
{
int
ret
=
inlink
->
dstpad
->
filter_frame
(
inlink
,
inlink
->
cur_buf
);
inlink
->
cur_buf
=
NULL
;
return
ret
;
}
if
(
inlink
->
dst
->
nb_outputs
)
outlink
=
inlink
->
dst
->
outputs
[
0
];
if
(
outlink
)
{
if
(
inlink
->
dstpad
->
filter_frame
)
{
int
ret
=
inlink
->
dstpad
->
filter_frame
(
inlink
,
inlink
->
cur_buf
);
inlink
->
cur_buf
=
NULL
;
return
ret
;
}
else
if
(
inlink
->
dstpad
->
start_frame
||
inlink
->
dstpad
->
end_frame
){
return
ff_end_frame
(
outlink
);
}
else
{
int
ret
=
ff_filter_frame
(
outlink
,
inlink
->
cur_buf
);
inlink
->
cur_buf
=
NULL
;
return
ret
;
}
}
return
0
;
}
int
ff_end_frame
(
AVFilterLink
*
link
)
{
int
(
*
end_frame
)(
AVFilterLink
*
);
int
ret
;
if
(
!
(
end_frame
=
link
->
dstpad
->
end_frame
))
end_frame
=
default_end_frame
;
ret
=
end_frame
(
link
);
clear_link
(
link
);
return
ret
;
}
int
ff_draw_slice
(
AVFilterLink
*
link
,
int
y
,
int
h
,
int
slice_dir
)
{
uint8_t
*
src
[
4
],
*
dst
[
4
];
int
i
,
j
,
vsub
;
FF_TPRINTF_START
(
NULL
,
draw_slice
);
ff_tlog_link
(
NULL
,
link
,
0
);
ff_tlog
(
NULL
,
" y:%d h:%d dir:%d
\n
"
,
y
,
h
,
slice_dir
);
/* copy the slice if needed for permission reasons */
if
(
link
->
src_buf
)
{
const
AVPixFmtDescriptor
*
desc
=
av_pix_fmt_desc_get
(
link
->
format
);
vsub
=
desc
->
log2_chroma_h
;
for
(
i
=
0
;
i
<
4
;
i
++
)
{
if
(
link
->
src_buf
->
data
[
i
])
{
src
[
i
]
=
link
->
src_buf
->
data
[
i
]
+
(
y
>>
(
i
==
1
||
i
==
2
?
vsub
:
0
))
*
link
->
src_buf
->
linesize
[
i
];
dst
[
i
]
=
link
->
cur_buf_copy
->
data
[
i
]
+
(
y
>>
(
i
==
1
||
i
==
2
?
vsub
:
0
))
*
link
->
cur_buf_copy
->
linesize
[
i
];
}
else
src
[
i
]
=
dst
[
i
]
=
NULL
;
}
for
(
i
=
0
;
i
<
4
;
i
++
)
{
int
planew
=
av_image_get_linesize
(
link
->
format
,
link
->
cur_buf_copy
->
video
->
w
,
i
);
if
(
!
src
[
i
])
continue
;
for
(
j
=
0
;
j
<
h
>>
(
i
==
1
||
i
==
2
?
vsub
:
0
);
j
++
)
{
memcpy
(
dst
[
i
],
src
[
i
],
planew
);
src
[
i
]
+=
link
->
src_buf
->
linesize
[
i
];
dst
[
i
]
+=
link
->
cur_buf_copy
->
linesize
[
i
];
}
}
}
/* incoming buffers must not be freed in start frame,
because they can still be in use by the automatic copy mechanism */
av_assert1
(
link
->
cur_buf_copy
->
buf
->
refcount
>
0
);
return
0
;
}
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