Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
Greenplum
Opencv
提交
ca572396
O
Opencv
项目概览
Greenplum
/
Opencv
10 个月 前同步成功
通知
7
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
DevOps
流水线
流水线任务
计划
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
O
Opencv
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
DevOps
DevOps
流水线
流水线任务
计划
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
流水线任务
提交
Issue看板
前往新版Gitcode,体验更适合开发者的 AI 搜索 >>
提交
ca572396
编写于
5月 02, 2012
作者:
V
Vladislav Vinogradov
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
fixed some problems after r8280 (lost code)
上级
d5a0088b
变更
4
隐藏空白更改
内联
并排
Showing
4 changed file
with
639 addition
and
4 deletion
+639
-4
modules/gpu/src/orb.cpp
modules/gpu/src/orb.cpp
+0
-3
modules/gpu/test/test_video.cpp
modules/gpu/test/test_video.cpp
+113
-1
modules/highgui/src/cap_ffmpeg_impl.hpp
modules/highgui/src/cap_ffmpeg_impl.hpp
+525
-0
samples/gpu/brox_optical_flow.cpp
samples/gpu/brox_optical_flow.cpp
+1
-0
未找到文件。
modules/gpu/src/orb.cpp
浏览文件 @
ca572396
...
...
@@ -622,9 +622,6 @@ void cv::gpu::ORB_GPU::computeDescriptors(GpuMat& descriptors)
if
(
keyPointsCount_
[
level
]
==
0
)
continue
;
if
(
keyPointsCount_
[
level
]
==
0
)
continue
;
GpuMat
descRange
=
descriptors
.
rowRange
(
offset
,
offset
+
keyPointsCount_
[
level
]);
if
(
blurForDescriptor
)
...
...
modules/gpu/test/test_video.cpp
浏览文件 @
ca572396
...
...
@@ -375,7 +375,7 @@ TEST_P(FarnebackOpticalFlow, Accuracy)
EXPECT_MAT_SIMILAR
(
flowxy
[
0
],
d_flowx
,
0.1
);
EXPECT_MAT_SIMILAR
(
flowxy
[
1
],
d_flowy
,
0.1
);
}
;
}
INSTANTIATE_TEST_CASE_P
(
GPU_Video
,
FarnebackOpticalFlow
,
testing
::
Combine
(
ALL_DEVICES
,
...
...
@@ -413,4 +413,116 @@ TEST_P(OpticalFlowNan, Regression)
INSTANTIATE_TEST_CASE_P
(
GPU_Video
,
OpticalFlowNan
,
ALL_DEVICES
);
/////////////////////////////////////////////////////////////////////////////////////////////////
// VideoWriter
#ifdef WIN32
PARAM_TEST_CASE
(
VideoWriter
,
cv
::
gpu
::
DeviceInfo
,
std
::
string
)
{
cv
::
gpu
::
DeviceInfo
devInfo
;
std
::
string
inputFile
;
std
::
string
outputFile
;
virtual
void
SetUp
()
{
devInfo
=
GET_PARAM
(
0
);
inputFile
=
GET_PARAM
(
1
);
cv
::
gpu
::
setDevice
(
devInfo
.
deviceID
());
inputFile
=
std
::
string
(
cvtest
::
TS
::
ptr
()
->
get_data_path
())
+
"video/"
+
inputFile
;
outputFile
=
inputFile
.
substr
(
0
,
inputFile
.
find
(
'.'
))
+
"_test.avi"
;
}
};
TEST_P
(
VideoWriter
,
Regression
)
{
const
double
FPS
=
25.0
;
cv
::
VideoCapture
reader
(
inputFile
);
ASSERT_TRUE
(
reader
.
isOpened
()
);
cv
::
gpu
::
VideoWriter_GPU
d_writer
;
cv
::
Mat
frame
;
std
::
vector
<
cv
::
Mat
>
frames
;
cv
::
gpu
::
GpuMat
d_frame
;
for
(
int
i
=
1
;
i
<
10
;
++
i
)
{
reader
>>
frame
;
if
(
frame
.
empty
())
break
;
frames
.
push_back
(
frame
.
clone
());
d_frame
.
upload
(
frame
);
if
(
!
d_writer
.
isOpened
())
d_writer
.
open
(
outputFile
,
frame
.
size
(),
FPS
);
d_writer
.
write
(
d_frame
);
}
reader
.
release
();
d_writer
.
close
();
reader
.
open
(
outputFile
);
ASSERT_TRUE
(
reader
.
isOpened
()
);
for
(
int
i
=
0
;
i
<
5
;
++
i
)
{
reader
>>
frame
;
ASSERT_FALSE
(
frame
.
empty
()
);
}
}
INSTANTIATE_TEST_CASE_P
(
GPU_Video
,
VideoWriter
,
testing
::
Combine
(
ALL_DEVICES
,
testing
::
Values
(
std
::
string
(
"VID00003-20100701-2204.mpg"
),
std
::
string
(
"big_buck_bunny.mpg"
))));
#endif // WIN32
/////////////////////////////////////////////////////////////////////////////////////////////////
// VideoReader
PARAM_TEST_CASE
(
VideoReader
,
cv
::
gpu
::
DeviceInfo
,
std
::
string
)
{
cv
::
gpu
::
DeviceInfo
devInfo
;
std
::
string
inputFile
;
virtual
void
SetUp
()
{
devInfo
=
GET_PARAM
(
0
);
inputFile
=
GET_PARAM
(
1
);
cv
::
gpu
::
setDevice
(
devInfo
.
deviceID
());
inputFile
=
std
::
string
(
cvtest
::
TS
::
ptr
()
->
get_data_path
())
+
"video/"
+
inputFile
;
}
};
TEST_P
(
VideoReader
,
Regression
)
{
cv
::
gpu
::
VideoReader_GPU
reader
(
inputFile
);
ASSERT_TRUE
(
reader
.
isOpened
()
);
cv
::
gpu
::
GpuMat
frame
;
for
(
int
i
=
0
;
i
<
5
;
++
i
)
{
ASSERT_TRUE
(
reader
.
read
(
frame
)
);
ASSERT_FALSE
(
frame
.
empty
()
);
}
reader
.
close
();
ASSERT_FALSE
(
reader
.
isOpened
()
);
}
INSTANTIATE_TEST_CASE_P
(
GPU_Video
,
VideoReader
,
testing
::
Combine
(
ALL_DEVICES
,
testing
::
Values
(
std
::
string
(
"VID00003-20100701-2204.mpg"
))));
}
// namespace
modules/highgui/src/cap_ffmpeg_impl.hpp
浏览文件 @
ca572396
...
...
@@ -1565,3 +1565,528 @@ int cvWriteFrame_FFMPEG( CvVideoWriter_FFMPEG* writer,
return
writer
->
writeFrame
(
data
,
step
,
width
,
height
,
cn
,
origin
);
}
/*
* For CUDA encoder
*/
struct
OutputMediaStream_FFMPEG
{
bool
open
(
const
char
*
fileName
,
int
width
,
int
height
,
double
fps
);
void
close
();
void
write
(
unsigned
char
*
data
,
int
size
,
int
keyFrame
);
// add a video output stream to the container
static
AVStream
*
addVideoStream
(
AVFormatContext
*
oc
,
CodecID
codec_id
,
int
w
,
int
h
,
int
bitrate
,
double
fps
,
PixelFormat
pixel_format
);
AVOutputFormat
*
fmt_
;
AVFormatContext
*
oc_
;
AVStream
*
video_st_
;
};
void
OutputMediaStream_FFMPEG
::
close
()
{
// no more frame to compress. The codec has a latency of a few
// frames if using B frames, so we get the last frames by
// passing the same picture again
// TODO -- do we need to account for latency here?
if
(
oc_
)
{
// write the trailer, if any
av_write_trailer
(
oc_
);
// free the streams
for
(
unsigned
int
i
=
0
;
i
<
oc_
->
nb_streams
;
++
i
)
{
av_freep
(
&
oc_
->
streams
[
i
]
->
codec
);
av_freep
(
&
oc_
->
streams
[
i
]);
}
if
(
!
(
fmt_
->
flags
&
AVFMT_NOFILE
)
&&
oc_
->
pb
)
{
// close the output file
#if LIBAVCODEC_VERSION_INT < ((52<<16)+(123<<8)+0)
#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(49<<8)+0)
url_fclose
(
oc_
->
pb
);
#else
url_fclose
(
&
oc_
->
pb
);
#endif
#else
avio_close
(
oc_
->
pb
);
#endif
}
// free the stream
av_free
(
oc_
);
}
}
AVStream
*
OutputMediaStream_FFMPEG
::
addVideoStream
(
AVFormatContext
*
oc
,
CodecID
codec_id
,
int
w
,
int
h
,
int
bitrate
,
double
fps
,
PixelFormat
pixel_format
)
{
#if LIBAVFORMAT_BUILD >= CALC_FFMPEG_VERSION(53, 10, 0)
AVStream
*
st
=
avformat_new_stream
(
oc
,
0
);
#else
AVStream
*
st
=
av_new_stream
(
oc
,
0
);
#endif
if
(
!
st
)
return
0
;
#if LIBAVFORMAT_BUILD > 4628
AVCodecContext
*
c
=
st
->
codec
;
#else
AVCodecContext
*
c
=
&
(
st
->
codec
);
#endif
c
->
codec_id
=
codec_id
;
c
->
codec_type
=
AVMEDIA_TYPE_VIDEO
;
// put sample parameters
unsigned
long
long
lbit_rate
=
static_cast
<
unsigned
long
long
>
(
bitrate
);
lbit_rate
+=
(
bitrate
/
4
);
lbit_rate
=
std
::
min
(
lbit_rate
,
static_cast
<
unsigned
long
long
>
(
std
::
numeric_limits
<
int
>::
max
()));
c
->
bit_rate
=
bitrate
;
// took advice from
// http://ffmpeg-users.933282.n4.nabble.com/warning-clipping-1-dct-coefficients-to-127-127-td934297.html
c
->
qmin
=
3
;
// resolution must be a multiple of two
c
->
width
=
w
;
c
->
height
=
h
;
AVCodec
*
codec
=
avcodec_find_encoder
(
c
->
codec_id
);
// time base: this is the fundamental unit of time (in seconds) in terms
// of which frame timestamps are represented. for fixed-fps content,
// timebase should be 1/framerate and timestamp increments should be
// identically 1
int
frame_rate
=
static_cast
<
int
>
(
fps
+
0.5
);
int
frame_rate_base
=
1
;
while
(
fabs
(
static_cast
<
double
>
(
frame_rate
)
/
frame_rate_base
)
-
fps
>
0.001
)
{
frame_rate_base
*=
10
;
frame_rate
=
static_cast
<
int
>
(
fps
*
frame_rate_base
+
0.5
);
}
c
->
time_base
.
den
=
frame_rate
;
c
->
time_base
.
num
=
frame_rate_base
;
#if LIBAVFORMAT_BUILD > 4752
// adjust time base for supported framerates
if
(
codec
&&
codec
->
supported_framerates
)
{
AVRational
req
=
{
frame_rate
,
frame_rate_base
};
const
AVRational
*
best
=
NULL
;
AVRational
best_error
=
{
INT_MAX
,
1
};
for
(
const
AVRational
*
p
=
codec
->
supported_framerates
;
p
->
den
!=
0
;
++
p
)
{
AVRational
error
=
av_sub_q
(
req
,
*
p
);
if
(
error
.
num
<
0
)
error
.
num
*=
-
1
;
if
(
av_cmp_q
(
error
,
best_error
)
<
0
)
{
best_error
=
error
;
best
=
p
;
}
}
c
->
time_base
.
den
=
best
->
num
;
c
->
time_base
.
num
=
best
->
den
;
}
#endif
c
->
gop_size
=
12
;
// emit one intra frame every twelve frames at most
c
->
pix_fmt
=
pixel_format
;
if
(
c
->
codec_id
==
CODEC_ID_MPEG2VIDEO
)
c
->
max_b_frames
=
2
;
if
(
c
->
codec_id
==
CODEC_ID_MPEG1VIDEO
||
c
->
codec_id
==
CODEC_ID_MSMPEG4V3
)
{
// needed to avoid using macroblocks in which some coeffs overflow
// this doesnt happen with normal video, it just happens here as the
// motion of the chroma plane doesnt match the luma plane
// avoid FFMPEG warning 'clipping 1 dct coefficients...'
c
->
mb_decision
=
2
;
}
#if LIBAVCODEC_VERSION_INT > 0x000409
// some formats want stream headers to be seperate
if
(
oc
->
oformat
->
flags
&
AVFMT_GLOBALHEADER
)
{
c
->
flags
|=
CODEC_FLAG_GLOBAL_HEADER
;
}
#endif
return
st
;
}
bool
OutputMediaStream_FFMPEG
::
open
(
const
char
*
fileName
,
int
width
,
int
height
,
double
fps
)
{
fmt_
=
0
;
oc_
=
0
;
video_st_
=
0
;
// tell FFMPEG to register codecs
av_register_all
();
av_log_set_level
(
AV_LOG_ERROR
);
// auto detect the output format from the name and fourcc code
#if LIBAVFORMAT_BUILD >= CALC_FFMPEG_VERSION(53, 2, 0)
fmt_
=
av_guess_format
(
NULL
,
fileName
,
NULL
);
#else
fmt_
=
guess_format
(
NULL
,
fileName
,
NULL
);
#endif
if
(
!
fmt_
)
return
false
;
CodecID
codec_id
=
CODEC_ID_H264
;
// alloc memory for context
#if LIBAVFORMAT_BUILD >= CALC_FFMPEG_VERSION(53, 2, 0)
oc_
=
avformat_alloc_context
();
#else
oc_
=
av_alloc_format_context
();
#endif
if
(
!
oc_
)
return
false
;
// set some options
oc_
->
oformat
=
fmt_
;
snprintf
(
oc_
->
filename
,
sizeof
(
oc_
->
filename
),
"%s"
,
fileName
);
oc_
->
max_delay
=
(
int
)(
0.7
*
AV_TIME_BASE
);
// This reduces buffer underrun warnings with MPEG
// set a few optimal pixel formats for lossless codecs of interest..
PixelFormat
codec_pix_fmt
=
PIX_FMT_YUV420P
;
int
bitrate_scale
=
64
;
// TODO -- safe to ignore output audio stream?
video_st_
=
addVideoStream
(
oc_
,
codec_id
,
width
,
height
,
width
*
height
*
bitrate_scale
,
fps
,
codec_pix_fmt
);
if
(
!
video_st_
)
return
false
;
// set the output parameters (must be done even if no parameters)
#if LIBAVFORMAT_BUILD < CALC_FFMPEG_VERSION(53, 2, 0)
if
(
av_set_parameters
(
oc_
,
NULL
)
<
0
)
return
false
;
#endif
// now that all the parameters are set, we can open the audio and
// video codecs and allocate the necessary encode buffers
#if LIBAVFORMAT_BUILD > 4628
AVCodecContext
*
c
=
(
video_st_
->
codec
);
#else
AVCodecContext
*
c
=
&
(
video_st_
->
codec
);
#endif
c
->
codec_tag
=
MKTAG
(
'H'
,
'2'
,
'6'
,
'4'
);
c
->
bit_rate_tolerance
=
c
->
bit_rate
;
// open the output file, if needed
if
(
!
(
fmt_
->
flags
&
AVFMT_NOFILE
))
{
#if LIBAVFORMAT_BUILD < CALC_FFMPEG_VERSION(53, 2, 0)
int
err
=
url_fopen
(
&
oc_
->
pb
,
fileName
,
URL_WRONLY
);
#else
int
err
=
avio_open
(
&
oc_
->
pb
,
fileName
,
AVIO_FLAG_WRITE
);
#endif
if
(
err
!=
0
)
return
false
;
}
// write the stream header, if any
#if LIBAVFORMAT_BUILD < CALC_FFMPEG_VERSION(53, 2, 0)
av_write_header
(
oc_
);
#else
avformat_write_header
(
oc_
,
NULL
);
#endif
return
true
;
}
void
OutputMediaStream_FFMPEG
::
write
(
unsigned
char
*
data
,
int
size
,
int
keyFrame
)
{
// if zero size, it means the image was buffered
if
(
size
>
0
)
{
AVPacket
pkt
;
av_init_packet
(
&
pkt
);
if
(
keyFrame
)
pkt
.
flags
|=
PKT_FLAG_KEY
;
pkt
.
stream_index
=
video_st_
->
index
;
pkt
.
data
=
data
;
pkt
.
size
=
size
;
// write the compressed frame in the media file
av_write_frame
(
oc_
,
&
pkt
);
}
}
struct
OutputMediaStream_FFMPEG
*
create_OutputMediaStream_FFMPEG
(
const
char
*
fileName
,
int
width
,
int
height
,
double
fps
)
{
OutputMediaStream_FFMPEG
*
stream
=
(
OutputMediaStream_FFMPEG
*
)
malloc
(
sizeof
(
OutputMediaStream_FFMPEG
));
if
(
stream
->
open
(
fileName
,
width
,
height
,
fps
))
return
stream
;
stream
->
close
();
free
(
stream
);
return
0
;
}
void
release_OutputMediaStream_FFMPEG
(
struct
OutputMediaStream_FFMPEG
*
stream
)
{
stream
->
close
();
free
(
stream
);
}
void
write_OutputMediaStream_FFMPEG
(
struct
OutputMediaStream_FFMPEG
*
stream
,
unsigned
char
*
data
,
int
size
,
int
keyFrame
)
{
stream
->
write
(
data
,
size
,
keyFrame
);
}
/*
* For CUDA decoder
*/
enum
{
VideoCodec_MPEG1
=
0
,
VideoCodec_MPEG2
,
VideoCodec_MPEG4
,
VideoCodec_VC1
,
VideoCodec_H264
,
VideoCodec_JPEG
,
VideoCodec_H264_SVC
,
VideoCodec_H264_MVC
,
// Uncompressed YUV
VideoCodec_YUV420
=
((
'I'
<<
24
)
|
(
'Y'
<<
16
)
|
(
'U'
<<
8
)
|
(
'V'
)),
// Y,U,V (4:2:0)
VideoCodec_YV12
=
((
'Y'
<<
24
)
|
(
'V'
<<
16
)
|
(
'1'
<<
8
)
|
(
'2'
)),
// Y,V,U (4:2:0)
VideoCodec_NV12
=
((
'N'
<<
24
)
|
(
'V'
<<
16
)
|
(
'1'
<<
8
)
|
(
'2'
)),
// Y,UV (4:2:0)
VideoCodec_YUYV
=
((
'Y'
<<
24
)
|
(
'U'
<<
16
)
|
(
'Y'
<<
8
)
|
(
'V'
)),
// YUYV/YUY2 (4:2:2)
VideoCodec_UYVY
=
((
'U'
<<
24
)
|
(
'Y'
<<
16
)
|
(
'V'
<<
8
)
|
(
'Y'
)),
// UYVY (4:2:2)
};
enum
{
VideoChromaFormat_Monochrome
=
0
,
VideoChromaFormat_YUV420
,
VideoChromaFormat_YUV422
,
VideoChromaFormat_YUV444
,
};
struct
InputMediaStream_FFMPEG
{
public:
bool
open
(
const
char
*
fileName
,
int
*
codec
,
int
*
chroma_format
,
int
*
width
,
int
*
height
);
void
close
();
bool
read
(
unsigned
char
**
data
,
int
*
size
,
int
*
endOfFile
);
private:
InputMediaStream_FFMPEG
(
const
InputMediaStream_FFMPEG
&
);
InputMediaStream_FFMPEG
&
operator
=
(
const
InputMediaStream_FFMPEG
&
);
AVFormatContext
*
ctx_
;
int
video_stream_id_
;
AVPacket
pkt_
;
};
bool
InputMediaStream_FFMPEG
::
open
(
const
char
*
fileName
,
int
*
codec
,
int
*
chroma_format
,
int
*
width
,
int
*
height
)
{
int
err
;
ctx_
=
0
;
video_stream_id_
=
-
1
;
memset
(
&
pkt_
,
0
,
sizeof
(
AVPacket
));
#if LIBAVFORMAT_BUILD >= CALC_FFMPEG_VERSION(53, 13, 0)
avformat_network_init
();
#endif
// register all codecs, demux and protocols
av_register_all
();
av_log_set_level
(
AV_LOG_ERROR
);
#if LIBAVFORMAT_BUILD >= CALC_FFMPEG_VERSION(53, 6, 0)
err
=
avformat_open_input
(
&
ctx_
,
fileName
,
0
,
0
);
#else
err
=
av_open_input_file
(
&
ctx_
,
fileName
,
0
,
0
,
0
);
#endif
if
(
err
<
0
)
return
false
;
#if LIBAVFORMAT_BUILD >= CALC_FFMPEG_VERSION(53, 3, 0)
err
=
avformat_find_stream_info
(
ctx_
,
0
);
#else
err
=
av_find_stream_info
(
ctx_
);
#endif
if
(
err
<
0
)
return
false
;
for
(
unsigned
int
i
=
0
;
i
<
ctx_
->
nb_streams
;
++
i
)
{
#if LIBAVFORMAT_BUILD > 4628
AVCodecContext
*
enc
=
ctx_
->
streams
[
i
]
->
codec
;
#else
AVCodecContext
*
enc
=
&
ctx_
->
streams
[
i
]
->
codec
;
#endif
if
(
enc
->
codec_type
==
AVMEDIA_TYPE_VIDEO
)
{
video_stream_id_
=
static_cast
<
int
>
(
i
);
switch
(
enc
->
codec_id
)
{
case
CODEC_ID_MPEG1VIDEO
:
*
codec
=
::
VideoCodec_MPEG1
;
break
;
case
CODEC_ID_MPEG2VIDEO
:
*
codec
=
::
VideoCodec_MPEG2
;
break
;
case
CODEC_ID_MPEG4
:
*
codec
=
::
VideoCodec_MPEG4
;
break
;
case
CODEC_ID_VC1
:
*
codec
=
::
VideoCodec_VC1
;
break
;
case
CODEC_ID_H264
:
*
codec
=
::
VideoCodec_H264
;
break
;
default:
return
false
;
};
switch
(
enc
->
pix_fmt
)
{
case
PIX_FMT_YUV420P
:
*
chroma_format
=
::
VideoChromaFormat_YUV420
;
break
;
case
PIX_FMT_YUV422P
:
*
chroma_format
=
::
VideoChromaFormat_YUV422
;
break
;
case
PIX_FMT_YUV444P
:
*
chroma_format
=
::
VideoChromaFormat_YUV444
;
break
;
default:
return
false
;
}
*
width
=
enc
->
coded_width
;
*
height
=
enc
->
coded_height
;
break
;
}
}
if
(
video_stream_id_
<
0
)
return
false
;
av_init_packet
(
&
pkt_
);
return
true
;
}
void
InputMediaStream_FFMPEG
::
close
()
{
if
(
ctx_
)
{
#if LIBAVFORMAT_BUILD >= CALC_FFMPEG_VERSION(53, 24, 2)
avformat_close_input
(
&
ctx_
);
#else
av_close_input_file
(
ctx_
);
#endif
}
// free last packet if exist
if
(
pkt_
.
data
)
av_free_packet
(
&
pkt_
);
}
bool
InputMediaStream_FFMPEG
::
read
(
unsigned
char
**
data
,
int
*
size
,
int
*
endOfFile
)
{
// free last packet if exist
if
(
pkt_
.
data
)
av_free_packet
(
&
pkt_
);
// get the next frame
for
(;;)
{
int
ret
=
av_read_frame
(
ctx_
,
&
pkt_
);
if
(
ret
==
AVERROR
(
EAGAIN
))
continue
;
if
(
ret
<
0
)
{
if
(
ret
==
AVERROR_EOF
)
*
endOfFile
=
true
;
return
false
;
}
if
(
pkt_
.
stream_index
!=
video_stream_id_
)
{
av_free_packet
(
&
pkt_
);
continue
;
}
break
;
}
*
data
=
pkt_
.
data
;
*
size
=
pkt_
.
size
;
*
endOfFile
=
false
;
return
true
;
}
InputMediaStream_FFMPEG
*
create_InputMediaStream_FFMPEG
(
const
char
*
fileName
,
int
*
codec
,
int
*
chroma_format
,
int
*
width
,
int
*
height
)
{
InputMediaStream_FFMPEG
*
stream
=
(
InputMediaStream_FFMPEG
*
)
malloc
(
sizeof
(
InputMediaStream_FFMPEG
));
if
(
stream
&&
stream
->
open
(
fileName
,
codec
,
chroma_format
,
width
,
height
))
return
stream
;
stream
->
close
();
free
(
stream
);
return
0
;
}
void
release_InputMediaStream_FFMPEG
(
InputMediaStream_FFMPEG
*
stream
)
{
stream
->
close
();
free
(
stream
);
}
int
read_InputMediaStream_FFMPEG
(
InputMediaStream_FFMPEG
*
stream
,
unsigned
char
**
data
,
int
*
size
,
int
*
endOfFile
)
{
return
stream
->
read
(
data
,
size
,
endOfFile
);
}
samples/gpu/brox_optical_flow.cpp
浏览文件 @
ca572396
...
...
@@ -215,6 +215,7 @@ int main(int argc, const char* argv[])
switch
(
key
)
{
case
27
:
return
0
;
case
'A'
:
if
(
currentFrame
>
0
)
...
...
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录