From: Bernd Kuhls Date: Mon, 28 Mar 2016 19:49:32 +0000 (+0200) Subject: package/opencv: bump version to 2.4.12.3 X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=4aa2831ac67d7411369eb99c3674d221e08d0210;p=buildroot.git package/opencv: bump version to 2.4.12.3 Removed patches applied upstream: https://github.com/Itseez/opencv/commit/ea50be0529c248961e1b66293f8a9e4b807294a6 https://github.com/Itseez/opencv/commit/2e393ab83362743ba1825ad4b31d4a2925c606b4 https://github.com/Itseez/opencv/commit/eceada586bbf18fc267e437522ec4f1f23ddc656 Added upstream patch to support ffmpeg 3.0. Signed-off-by: Bernd Kuhls Signed-off-by: Thomas Petazzoni --- diff --git a/package/opencv/0001-core-fix-x86-PIC-code-compilation.patch b/package/opencv/0001-core-fix-x86-PIC-code-compilation.patch deleted file mode 100644 index 9e8c2e98eb..0000000000 --- a/package/opencv/0001-core-fix-x86-PIC-code-compilation.patch +++ /dev/null @@ -1,49 +0,0 @@ -From ea50be0529c248961e1b66293f8a9e4b807294a6 Mon Sep 17 00:00:00 2001 -From: Samuel Martin -Date: Sun, 12 Oct 2014 10:17:23 +0200 -Subject: [PATCH] core: fix x86 PIC code compilation - -This bug was triggered by Buildroot autobuilders [1,2], causing this -kind of failures [3,4]: - - [ 14%] Building CXX object modules/core/CMakeFiles/opencv_core.dir/src/system.cpp.o - /home/test/autobuild/instance-0/output/build/opencv-2.4.10/modules/core/src/system.cpp: In function '(static initializers for /home/test/autobuild/instance-0/output/build/opencv-2.4.10/modules/core/src/system.cpp)': - /home/test/autobuild/instance-0/output/build/opencv-2.4.10/modules/core/src/system.cpp:280:10: error: inconsistent operand constraints in an 'asm' - make[3]: *** [modules/core/CMakeFiles/opencv_core.dir/src/system.cpp.o] Error 1 - -[1] http://buildroot.org/ -[2] http://autobuild.buildroot.org/ -[3] http://autobuild.buildroot.org/?reason=opencv-2.4.10 -[4] http://autobuild.buildroot.org/results/483/4838285b25d6293a5cf0bb9eadd5040a7c75d766/build-end.log - -Signed-off-by: Samuel Martin ---- - modules/core/src/system.cpp | 5 ++++- - 1 file changed, 4 insertions(+), 1 deletion(-) - -diff --git a/modules/core/src/system.cpp b/modules/core/src/system.cpp -index 5a970d5..e9ffdc7 100644 ---- a/modules/core/src/system.cpp -+++ b/modules/core/src/system.cpp -@@ -267,14 +267,17 @@ struct HWFeatures - : "cc" - ); - #else -+ // We need to preserve ebx since we are compiling PIC code. -+ // This means we cannot use "=b" for the 2nd output register. - asm volatile - ( - "pushl %%ebx\n\t" - "movl $7,%%eax\n\t" - "movl $0,%%ecx\n\t" - "cpuid\n\t" -+ "movl %%ebx,%1\n\t" - "popl %%ebx\n\t" -- : "=a"(cpuid_data[0]), "=b"(cpuid_data[1]), "=c"(cpuid_data[2]), "=d"(cpuid_data[3]) -+ : "=a"(cpuid_data[0]), "=r"(cpuid_data[1]), "=c"(cpuid_data[2]), "=d"(cpuid_data[3]) - : - : "cc" - ); --- -2.1.2 - diff --git a/package/opencv/0001-ffmpeg30.patch b/package/opencv/0001-ffmpeg30.patch new file mode 100644 index 0000000000..70b6510b15 --- /dev/null +++ b/package/opencv/0001-ffmpeg30.patch @@ -0,0 +1,638 @@ +From a61b19b524cd2b66a7c43e67edd7cc780bf46cbb Mon Sep 17 00:00:00 2001 +From: Alexander Alekhin +Date: Wed, 2 Mar 2016 17:54:17 +0300 +Subject: [PATCH] backport ffmpeg fixes + +Signed-off-by: Bernd Kuhls +Downloaded from upstream commit: +https://github.com/Itseez/opencv/commit/a61b19b524cd2b66a7c43e67edd7cc780bf46cbb +--- + modules/highgui/src/cap_ffmpeg_impl.hpp | 364 +++++++++++++++++++++++++++----- + 1 file changed, 314 insertions(+), 50 deletions(-) + +diff --git a/modules/highgui/src/cap_ffmpeg_impl.hpp b/modules/highgui/src/cap_ffmpeg_impl.hpp +index 1b79870..6df542a 100644 +--- a/modules/highgui/src/cap_ffmpeg_impl.hpp ++++ b/modules/highgui/src/cap_ffmpeg_impl.hpp +@@ -118,11 +118,6 @@ extern "C" { + #define CV_WARN(message) fprintf(stderr, "warning: %s (%s:%d)\n", message, __FILE__, __LINE__) + #endif + +-/* PIX_FMT_RGBA32 macro changed in newer ffmpeg versions */ +-#ifndef PIX_FMT_RGBA32 +-#define PIX_FMT_RGBA32 PIX_FMT_RGB32 +-#endif +- + #define CALC_FFMPEG_VERSION(a,b,c) ( a<<16 | b<<8 | c ) + + #if defined WIN32 || defined _WIN32 +@@ -132,6 +127,11 @@ extern "C" { + #include + #include + #include ++ #include ++#if defined __APPLE__ ++ #include ++ #include ++#endif + #endif + + #ifndef MIN +@@ -156,6 +156,155 @@ extern "C" { + # define CV_CODEC(name) name + #endif + ++#if LIBAVUTIL_BUILD < (LIBAVUTIL_VERSION_MICRO >= 100 \ ++ ? CALC_FFMPEG_VERSION(51, 74, 100) : CALC_FFMPEG_VERSION(51, 42, 0)) ++#define AVPixelFormat PixelFormat ++#define AV_PIX_FMT_BGR24 PIX_FMT_BGR24 ++#define AV_PIX_FMT_RGB24 PIX_FMT_RGB24 ++#define AV_PIX_FMT_GRAY8 PIX_FMT_GRAY8 ++#define AV_PIX_FMT_YUV422P PIX_FMT_YUV422P ++#define AV_PIX_FMT_YUV420P PIX_FMT_YUV420P ++#define AV_PIX_FMT_YUV444P PIX_FMT_YUV444P ++#define AV_PIX_FMT_YUVJ420P PIX_FMT_YUVJ420P ++#define AV_PIX_FMT_GRAY16LE PIX_FMT_GRAY16LE ++#define AV_PIX_FMT_GRAY16BE PIX_FMT_GRAY16BE ++#endif ++ ++#if LIBAVUTIL_BUILD >= (LIBAVUTIL_VERSION_MICRO >= 100 \ ++ ? CALC_FFMPEG_VERSION(52, 38, 100) : CALC_FFMPEG_VERSION(52, 13, 0)) ++#define USE_AV_FRAME_GET_BUFFER 1 ++#else ++#define USE_AV_FRAME_GET_BUFFER 0 ++#ifndef AV_NUM_DATA_POINTERS // required for 0.7.x/0.8.x ffmpeg releases ++#define AV_NUM_DATA_POINTERS 4 ++#endif ++#endif ++ ++ ++#ifndef USE_AV_INTERRUPT_CALLBACK ++#if LIBAVFORMAT_BUILD >= CALC_FFMPEG_VERSION(53, 21, 0) ++#define USE_AV_INTERRUPT_CALLBACK 1 ++#else ++#define USE_AV_INTERRUPT_CALLBACK 0 ++#endif ++#endif ++ ++#if USE_AV_INTERRUPT_CALLBACK ++#define LIBAVFORMAT_INTERRUPT_TIMEOUT_MS 30000 ++ ++#ifdef WIN32 ++// http://stackoverflow.com/questions/5404277/porting-clock-gettime-to-windows ++ ++static ++inline LARGE_INTEGER get_filetime_offset() ++{ ++ SYSTEMTIME s; ++ FILETIME f; ++ LARGE_INTEGER t; ++ ++ s.wYear = 1970; ++ s.wMonth = 1; ++ s.wDay = 1; ++ s.wHour = 0; ++ s.wMinute = 0; ++ s.wSecond = 0; ++ s.wMilliseconds = 0; ++ SystemTimeToFileTime(&s, &f); ++ t.QuadPart = f.dwHighDateTime; ++ t.QuadPart <<= 32; ++ t.QuadPart |= f.dwLowDateTime; ++ return t; ++} ++ ++static ++inline void get_monotonic_time(timespec *tv) ++{ ++ LARGE_INTEGER t; ++ FILETIME f; ++ double microseconds; ++ static LARGE_INTEGER offset; ++ static double frequencyToMicroseconds; ++ static int initialized = 0; ++ static BOOL usePerformanceCounter = 0; ++ ++ if (!initialized) ++ { ++ LARGE_INTEGER performanceFrequency; ++ initialized = 1; ++ usePerformanceCounter = QueryPerformanceFrequency(&performanceFrequency); ++ if (usePerformanceCounter) ++ { ++ QueryPerformanceCounter(&offset); ++ frequencyToMicroseconds = (double)performanceFrequency.QuadPart / 1000000.; ++ } ++ else ++ { ++ offset = get_filetime_offset(); ++ frequencyToMicroseconds = 10.; ++ } ++ } ++ ++ if (usePerformanceCounter) ++ { ++ QueryPerformanceCounter(&t); ++ } else { ++ GetSystemTimeAsFileTime(&f); ++ t.QuadPart = f.dwHighDateTime; ++ t.QuadPart <<= 32; ++ t.QuadPart |= f.dwLowDateTime; ++ } ++ ++ t.QuadPart -= offset.QuadPart; ++ microseconds = (double)t.QuadPart / frequencyToMicroseconds; ++ t.QuadPart = microseconds; ++ tv->tv_sec = t.QuadPart / 1000000; ++ tv->tv_nsec = (t.QuadPart % 1000000) * 1000; ++} ++#else ++static ++inline void get_monotonic_time(timespec *time) ++{ ++#if defined(__APPLE__) && defined(__MACH__) ++ clock_serv_t cclock; ++ mach_timespec_t mts; ++ host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock); ++ clock_get_time(cclock, &mts); ++ mach_port_deallocate(mach_task_self(), cclock); ++ time->tv_sec = mts.tv_sec; ++ time->tv_nsec = mts.tv_nsec; ++#else ++ clock_gettime(CLOCK_MONOTONIC, time); ++#endif ++} ++#endif ++ ++static ++inline timespec get_monotonic_time_diff(timespec start, timespec end) ++{ ++ timespec temp; ++ if (end.tv_nsec - start.tv_nsec < 0) ++ { ++ temp.tv_sec = end.tv_sec - start.tv_sec - 1; ++ temp.tv_nsec = 1000000000 + end.tv_nsec - start.tv_nsec; ++ } ++ else ++ { ++ temp.tv_sec = end.tv_sec - start.tv_sec; ++ temp.tv_nsec = end.tv_nsec - start.tv_nsec; ++ } ++ return temp; ++} ++ ++static ++inline double get_monotonic_time_diff_ms(timespec time1, timespec time2) ++{ ++ timespec delta = get_monotonic_time_diff(time1, time2); ++ double milliseconds = delta.tv_sec * 1000 + (double)delta.tv_nsec / 1000000.0; ++ ++ return milliseconds; ++} ++#endif // USE_AV_INTERRUPT_CALLBACK ++ + static int get_number_of_cpus(void) + { + #if LIBAVFORMAT_BUILD < CALC_FFMPEG_VERSION(52, 111, 0) +@@ -205,12 +354,36 @@ struct Image_FFMPEG + }; + + ++#if USE_AV_INTERRUPT_CALLBACK ++struct AVInterruptCallbackMetadata ++{ ++ timespec value; ++ unsigned int timeout_after_ms; ++ int timeout; ++}; ++ ++static + inline void _opencv_ffmpeg_free(void** ptr) + { + if(*ptr) free(*ptr); + *ptr = 0; + } + ++static ++inline int _opencv_ffmpeg_interrupt_callback(void *ptr) ++{ ++ AVInterruptCallbackMetadata* metadata = (AVInterruptCallbackMetadata*)ptr; ++ assert(metadata); ++ ++ timespec now; ++ get_monotonic_time(&now); ++ ++ metadata->timeout = get_monotonic_time_diff_ms(metadata->value, now) > metadata->timeout_after_ms; ++ ++ return metadata->timeout ? -1 : 0; ++} ++#endif ++ + + struct CvCapture_FFMPEG + { +@@ -264,6 +437,10 @@ struct CvCapture_FFMPEG + #if LIBAVFORMAT_BUILD >= CALC_FFMPEG_VERSION(52, 111, 0) + AVDictionary *dict; + #endif ++ ++#if USE_AV_INTERRUPT_CALLBACK ++ AVInterruptCallbackMetadata interrupt_metadata; ++#endif + }; + + void CvCapture_FFMPEG::init() +@@ -301,8 +478,10 @@ void CvCapture_FFMPEG::close() + + if( picture ) + { +- // FFmpeg and Libav added avcodec_free_frame in different versions. + #if LIBAVCODEC_BUILD >= (LIBAVCODEC_VERSION_MICRO >= 100 \ ++ ? CALC_FFMPEG_VERSION(55, 45, 101) : CALC_FFMPEG_VERSION(55, 28, 1)) ++ av_frame_free(&picture); ++#elif LIBAVCODEC_BUILD >= (LIBAVCODEC_VERSION_MICRO >= 100 \ + ? CALC_FFMPEG_VERSION(54, 59, 100) : CALC_FFMPEG_VERSION(54, 28, 0)) + avcodec_free_frame(&picture); + #else +@@ -333,11 +512,15 @@ void CvCapture_FFMPEG::close() + ic = NULL; + } + ++#if USE_AV_FRAME_GET_BUFFER ++ av_frame_unref(&rgb_picture); ++#else + if( rgb_picture.data[0] ) + { + free( rgb_picture.data[0] ); + rgb_picture.data[0] = 0; + } ++#endif + + // free last packet if exist + if (packet.data) { +@@ -556,6 +739,16 @@ bool CvCapture_FFMPEG::open( const char* _filename ) + + close(); + ++#if USE_AV_INTERRUPT_CALLBACK ++ /* interrupt callback */ ++ interrupt_metadata.timeout_after_ms = LIBAVFORMAT_INTERRUPT_TIMEOUT_MS; ++ get_monotonic_time(&interrupt_metadata.value); ++ ++ ic = avformat_alloc_context(); ++ ic->interrupt_callback.callback = _opencv_ffmpeg_interrupt_callback; ++ ic->interrupt_callback.opaque = &interrupt_metadata; ++#endif ++ + #if LIBAVFORMAT_BUILD >= CALC_FFMPEG_VERSION(52, 111, 0) + av_dict_set(&dict, "rtsp_transport", "tcp", 0); + int err = avformat_open_input(&ic, _filename, NULL, &dict); +@@ -619,19 +812,18 @@ bool CvCapture_FFMPEG::open( const char* _filename ) + + video_stream = i; + video_st = ic->streams[i]; ++#if LIBAVCODEC_BUILD >= (LIBAVCODEC_VERSION_MICRO >= 100 \ ++ ? CALC_FFMPEG_VERSION(55, 45, 101) : CALC_FFMPEG_VERSION(55, 28, 1)) ++ picture = av_frame_alloc(); ++#else + picture = avcodec_alloc_frame(); +- +- rgb_picture.data[0] = (uint8_t*)malloc( +- avpicture_get_size( PIX_FMT_BGR24, +- enc->width, enc->height )); +- avpicture_fill( (AVPicture*)&rgb_picture, rgb_picture.data[0], +- PIX_FMT_BGR24, enc->width, enc->height ); ++#endif + + frame.width = enc->width; + frame.height = enc->height; + frame.cn = 3; +- frame.step = rgb_picture.linesize[0]; +- frame.data = rgb_picture.data[0]; ++ frame.step = 0; ++ frame.data = NULL; + break; + } + } +@@ -668,6 +860,16 @@ bool CvCapture_FFMPEG::grabFrame() + // get the next frame + while (!valid) + { ++ av_free_packet (&packet); ++ ++#if USE_AV_INTERRUPT_CALLBACK ++ if (interrupt_metadata.timeout) ++ { ++ valid = false; ++ break; ++ } ++#endif ++ + int ret = av_read_frame(ic, &packet); + if (ret == AVERROR(EAGAIN)) continue; + +@@ -703,6 +905,11 @@ bool CvCapture_FFMPEG::grabFrame() + picture_pts = packet.pts != AV_NOPTS_VALUE_ && packet.pts != 0 ? packet.pts : packet.dts; + frame_number++; + valid = true; ++ ++#if USE_AV_INTERRUPT_CALLBACK ++ // update interrupt value ++ get_monotonic_time(&interrupt_metadata.value); ++#endif + } + else + { +@@ -727,38 +934,59 @@ bool CvCapture_FFMPEG::retrieveFrame(int, unsigned char** data, int* step, int* + if( !video_st || !picture->data[0] ) + return false; + +- avpicture_fill((AVPicture*)&rgb_picture, rgb_picture.data[0], PIX_FMT_RGB24, +- video_st->codec->width, video_st->codec->height); +- + if( img_convert_ctx == NULL || + frame.width != video_st->codec->width || +- frame.height != video_st->codec->height ) ++ frame.height != video_st->codec->height || ++ frame.data == NULL ) + { +- if( img_convert_ctx ) +- sws_freeContext(img_convert_ctx); +- +- frame.width = video_st->codec->width; +- frame.height = video_st->codec->height; ++ // Some sws_scale optimizations have some assumptions about alignment of data/step/width/height ++ // Also we use coded_width/height to workaround problem with legacy ffmpeg versions (like n0.8) ++ int buffer_width = video_st->codec->coded_width, buffer_height = video_st->codec->coded_height; + + img_convert_ctx = sws_getCachedContext( +- NULL, +- video_st->codec->width, video_st->codec->height, ++ img_convert_ctx, ++ buffer_width, buffer_height, + video_st->codec->pix_fmt, +- video_st->codec->width, video_st->codec->height, +- PIX_FMT_BGR24, ++ buffer_width, buffer_height, ++ AV_PIX_FMT_BGR24, + SWS_BICUBIC, + NULL, NULL, NULL + ); + + if (img_convert_ctx == NULL) + return false;//CV_Error(0, "Cannot initialize the conversion context!"); ++ ++#if USE_AV_FRAME_GET_BUFFER ++ av_frame_unref(&rgb_picture); ++ rgb_picture.format = AV_PIX_FMT_BGR24; ++ rgb_picture.width = buffer_width; ++ rgb_picture.height = buffer_height; ++ if (0 != av_frame_get_buffer(&rgb_picture, 32)) ++ { ++ CV_WARN("OutOfMemory"); ++ return false; ++ } ++#else ++ int aligns[AV_NUM_DATA_POINTERS]; ++ avcodec_align_dimensions2(video_st->codec, &buffer_width, &buffer_height, aligns); ++ rgb_picture.data[0] = (uint8_t*)realloc(rgb_picture.data[0], ++ avpicture_get_size( AV_PIX_FMT_BGR24, ++ buffer_width, buffer_height )); ++ avpicture_fill( (AVPicture*)&rgb_picture, rgb_picture.data[0], ++ AV_PIX_FMT_BGR24, buffer_width, buffer_height ); ++#endif ++ frame.width = video_st->codec->width; ++ frame.height = video_st->codec->height; ++ frame.cn = 3; ++ frame.data = rgb_picture.data[0]; ++ frame.step = rgb_picture.linesize[0]; + } + + sws_scale( + img_convert_ctx, + picture->data, + picture->linesize, +- 0, video_st->codec->height, ++ 0, video_st->codec->coded_height, + rgb_picture.data, + rgb_picture.linesize + ); +@@ -1099,10 +1327,20 @@ static AVFrame * icv_alloc_picture_FFMPEG(int pix_fmt, int width, int height, bo + uint8_t * picture_buf; + int size; + ++#if LIBAVCODEC_BUILD >= (LIBAVCODEC_VERSION_MICRO >= 100 \ ++ ? CALC_FFMPEG_VERSION(55, 45, 101) : CALC_FFMPEG_VERSION(55, 28, 1)) ++ picture = av_frame_alloc(); ++#else + picture = avcodec_alloc_frame(); ++#endif + if (!picture) + return NULL; +- size = avpicture_get_size( (PixelFormat) pix_fmt, width, height); ++ ++ picture->format = pix_fmt; ++ picture->width = width; ++ picture->height = height; ++ ++ size = avpicture_get_size( (AVPixelFormat) pix_fmt, width, height); + if(alloc){ + picture_buf = (uint8_t *) malloc(size); + if (!picture_buf) +@@ -1111,7 +1349,7 @@ static AVFrame * icv_alloc_picture_FFMPEG(int pix_fmt, int width, int height, bo + return NULL; + } + avpicture_fill((AVPicture *)picture, picture_buf, +- (PixelFormat) pix_fmt, width, height); ++ (AVPixelFormat) pix_fmt, width, height); + } + else { + } +@@ -1211,7 +1449,7 @@ static AVStream *icv_add_video_stream_FFMPEG(AVFormatContext *oc, + #endif + + c->gop_size = 12; /* emit one intra frame every twelve frames at most */ +- c->pix_fmt = (PixelFormat) pixel_format; ++ c->pix_fmt = (AVPixelFormat) pixel_format; + + if (c->codec_id == CV_CODEC(CODEC_ID_MPEG2VIDEO)) { + c->max_b_frames = 2; +@@ -1372,12 +1610,12 @@ bool CvVideoWriter_FFMPEG::writeFrame( const unsigned char* data, int step, int + #endif + + // check parameters +- if (input_pix_fmt == PIX_FMT_BGR24) { ++ if (input_pix_fmt == AV_PIX_FMT_BGR24) { + if (cn != 3) { + return false; + } + } +- else if (input_pix_fmt == PIX_FMT_GRAY8) { ++ else if (input_pix_fmt == AV_PIX_FMT_GRAY8) { + if (cn != 1) { + return false; + } +@@ -1390,13 +1628,13 @@ bool CvVideoWriter_FFMPEG::writeFrame( const unsigned char* data, int step, int + assert( input_picture ); + // let input_picture point to the raw data buffer of 'image' + avpicture_fill((AVPicture *)input_picture, (uint8_t *) data, +- (PixelFormat)input_pix_fmt, width, height); ++ (AVPixelFormat)input_pix_fmt, width, height); + + if( !img_convert_ctx ) + { + img_convert_ctx = sws_getContext(width, + height, +- (PixelFormat)input_pix_fmt, ++ (AVPixelFormat)input_pix_fmt, + c->width, + c->height, + c->pix_fmt, +@@ -1414,7 +1652,7 @@ bool CvVideoWriter_FFMPEG::writeFrame( const unsigned char* data, int step, int + } + else{ + avpicture_fill((AVPicture *)picture, (uint8_t *) data, +- (PixelFormat)input_pix_fmt, width, height); ++ (AVPixelFormat)input_pix_fmt, width, height); + } + + picture->pts = frame_idx; +@@ -1547,10 +1785,10 @@ bool CvVideoWriter_FFMPEG::open( const char * filename, int fourcc, + + /* determine optimal pixel format */ + if (is_color) { +- input_pix_fmt = PIX_FMT_BGR24; ++ input_pix_fmt = AV_PIX_FMT_BGR24; + } + else { +- input_pix_fmt = PIX_FMT_GRAY8; ++ input_pix_fmt = AV_PIX_FMT_GRAY8; + } + + /* Lookup codec_id for given fourcc */ +@@ -1587,21 +1825,21 @@ bool CvVideoWriter_FFMPEG::open( const char * filename, int fourcc, + break; + #endif + case CV_CODEC(CODEC_ID_HUFFYUV): +- codec_pix_fmt = PIX_FMT_YUV422P; ++ codec_pix_fmt = AV_PIX_FMT_YUV422P; + break; + case CV_CODEC(CODEC_ID_MJPEG): + case CV_CODEC(CODEC_ID_LJPEG): +- codec_pix_fmt = PIX_FMT_YUVJ420P; ++ codec_pix_fmt = AV_PIX_FMT_YUVJ420P; + bitrate_scale = 3; + break; + case CV_CODEC(CODEC_ID_RAWVIDEO): +- codec_pix_fmt = input_pix_fmt == PIX_FMT_GRAY8 || +- input_pix_fmt == PIX_FMT_GRAY16LE || +- input_pix_fmt == PIX_FMT_GRAY16BE ? input_pix_fmt : PIX_FMT_YUV420P; ++ codec_pix_fmt = input_pix_fmt == AV_PIX_FMT_GRAY8 || ++ input_pix_fmt == AV_PIX_FMT_GRAY16LE || ++ input_pix_fmt == AV_PIX_FMT_GRAY16BE ? input_pix_fmt : AV_PIX_FMT_YUV420P; + break; + default: + // good for lossy formats, MPEG, etc. +- codec_pix_fmt = PIX_FMT_YUV420P; ++ codec_pix_fmt = AV_PIX_FMT_YUV420P; + break; + } + +@@ -1826,7 +2064,7 @@ struct OutputMediaStream_FFMPEG + void write(unsigned char* data, int size, int keyFrame); + + // add a video output stream to the container +- static AVStream* addVideoStream(AVFormatContext *oc, CV_CODEC_ID codec_id, int w, int h, int bitrate, double fps, PixelFormat pixel_format); ++ static AVStream* addVideoStream(AVFormatContext *oc, CV_CODEC_ID codec_id, int w, int h, int bitrate, double fps, AVPixelFormat pixel_format); + + AVOutputFormat* fmt_; + AVFormatContext* oc_; +@@ -1873,7 +2111,7 @@ void OutputMediaStream_FFMPEG::close() + } + } + +-AVStream* OutputMediaStream_FFMPEG::addVideoStream(AVFormatContext *oc, CV_CODEC_ID codec_id, int w, int h, int bitrate, double fps, PixelFormat pixel_format) ++AVStream* OutputMediaStream_FFMPEG::addVideoStream(AVFormatContext *oc, CV_CODEC_ID codec_id, int w, int h, int bitrate, double fps, AVPixelFormat pixel_format) + { + #if LIBAVFORMAT_BUILD >= CALC_FFMPEG_VERSION(53, 10, 0) + AVStream* st = avformat_new_stream(oc, 0); +@@ -2011,7 +2249,7 @@ bool OutputMediaStream_FFMPEG::open(const char* fileName, int width, int height, + 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; ++ AVPixelFormat codec_pix_fmt = AV_PIX_FMT_YUV420P; + int bitrate_scale = 64; + + // TODO -- safe to ignore output audio stream? +@@ -2150,6 +2388,10 @@ struct InputMediaStream_FFMPEG + AVFormatContext* ctx_; + int video_stream_id_; + AVPacket pkt_; ++ ++#if USE_AV_INTERRUPT_CALLBACK ++ AVInterruptCallbackMetadata interrupt_metadata; ++#endif + }; + + bool InputMediaStream_FFMPEG::open(const char* fileName, int* codec, int* chroma_format, int* width, int* height) +@@ -2160,6 +2402,16 @@ bool InputMediaStream_FFMPEG::open(const char* fileName, int* codec, int* chroma + video_stream_id_ = -1; + memset(&pkt_, 0, sizeof(AVPacket)); + ++#if USE_AV_INTERRUPT_CALLBACK ++ /* interrupt callback */ ++ interrupt_metadata.timeout_after_ms = LIBAVFORMAT_INTERRUPT_TIMEOUT_MS; ++ get_monotonic_time(&interrupt_metadata.value); ++ ++ ctx_ = avformat_alloc_context(); ++ ctx_->interrupt_callback.callback = _opencv_ffmpeg_interrupt_callback; ++ ctx_->interrupt_callback.opaque = &interrupt_metadata; ++#endif ++ + #if LIBAVFORMAT_BUILD >= CALC_FFMPEG_VERSION(53, 13, 0) + avformat_network_init(); + #endif +@@ -2220,15 +2472,15 @@ bool InputMediaStream_FFMPEG::open(const char* fileName, int* codec, int* chroma + + switch (enc->pix_fmt) + { +- case PIX_FMT_YUV420P: ++ case AV_PIX_FMT_YUV420P: + *chroma_format = ::VideoChromaFormat_YUV420; + break; + +- case PIX_FMT_YUV422P: ++ case AV_PIX_FMT_YUV422P: + *chroma_format = ::VideoChromaFormat_YUV422; + break; + +- case PIX_FMT_YUV444P: ++ case AV_PIX_FMT_YUV444P: + *chroma_format = ::VideoChromaFormat_YUV444; + break; + +@@ -2276,11 +2528,23 @@ bool InputMediaStream_FFMPEG::read(unsigned char** data, int* size, int* endOfFi + // get the next frame + for (;;) + { ++#if USE_AV_INTERRUPT_CALLBACK ++ if(interrupt_metadata.timeout) ++ { ++ break; ++ } ++#endif ++ + int ret = av_read_frame(ctx_, &pkt_); + + if (ret == AVERROR(EAGAIN)) + continue; + ++#if USE_AV_INTERRUPT_CALLBACK ++ // update interrupt value ++ get_monotonic_time(&interrupt_metadata.value); ++#endif ++ + if (ret < 0) + { + if (ret == (int)AVERROR_EOF) diff --git a/package/opencv/0002-superres-Fix-return-type-value-VideoFrameSource_GPU.patch b/package/opencv/0002-superres-Fix-return-type-value-VideoFrameSource_GPU.patch deleted file mode 100644 index d71235d424..0000000000 --- a/package/opencv/0002-superres-Fix-return-type-value-VideoFrameSource_GPU.patch +++ /dev/null @@ -1,40 +0,0 @@ -superres: Fix return value VideoFrameSource_GPU - -Signed-off-by: Vicente Olivert Riera - -From 2e393ab83362743ba1825ad4b31d4a2925c606b4 Mon Sep 17 00:00:00 2001 -From: Vicente Olivert Riera -Date: Mon, 27 Oct 2014 13:39:35 +0000 -Subject: [PATCH] superres: Fix return value VideoFrameSource_GPU - -superres module fails to compile with the following error messages: - -[100%] Building CXX object modules/superres/CMakeFiles/opencv_superres.dir/src/super_resolution.cpp.o -/opencv-2.4.10/modules/superres/src/frame_source.cpp: In function 'cv::Ptr cv::superres::createFrameSource_Video_GPU(const string&)': -/opencv-2.4.10/modules/superres/src/frame_source.cpp:263:16: error: expected type-specifier before 'VideoFrameSource' -/opencv-2.4.10/modules/superres/src/frame_source.cpp:263:16: error: could not convert '(int*)operator new(4ul)' from 'int*' to 'cv::Ptr' -/opencv-2.4.10/modules/superres/src/frame_source.cpp:263:16: error: expected ';' before 'VideoFrameSource' -/opencv-2.4.10/modules/superres/src/frame_source.cpp:263:41: error: 'VideoFrameSource' was not declared in this scope -/opencv-2.4.10/modules/superres/src/frame_source.cpp:264:1: error: control reaches end of non-void function [-Werror=return-type] -cc1plus: some warnings being treated as errors -make[3]: *** [modules/superres/CMakeFiles/opencv_superres.dir/src/frame_source.cpp.o] Error 1 -make[3]: *** Waiting for unfinished jobs.... - -This is caused because the return value of the createFrameSource_Video_GPU function should be a VideoFrameSource_GPU object. ---- - modules/superres/src/frame_source.cpp | 2 +- - 1 file changed, 1 insertion(+), 1 deletion(-) - -diff --git a/modules/superres/src/frame_source.cpp b/modules/superres/src/frame_source.cpp -index 5f59a98..c5b2e76 100644 ---- a/modules/superres/src/frame_source.cpp -+++ b/modules/superres/src/frame_source.cpp -@@ -260,7 +260,7 @@ namespace - - Ptr cv::superres::createFrameSource_Video_GPU(const string& fileName) - { -- return new VideoFrameSource(fileName); -+ return new VideoFrameSource_GPU(fileName); - } - - #endif // HAVE_OPENCV_GPU diff --git a/package/opencv/0003-cmake-OpenCVGenPkgconfig.cmake-rework-opencv.pc-gene.patch b/package/opencv/0003-cmake-OpenCVGenPkgconfig.cmake-rework-opencv.pc-gene.patch deleted file mode 100644 index 768f08d778..0000000000 --- a/package/opencv/0003-cmake-OpenCVGenPkgconfig.cmake-rework-opencv.pc-gene.patch +++ /dev/null @@ -1,156 +0,0 @@ -From eceada586bbf18fc267e437522ec4f1f23ddc656 Mon Sep 17 00:00:00 2001 -From: Samuel Martin -Date: Fri, 3 Oct 2014 00:32:40 +0200 -Subject: [PATCH] cmake/OpenCVGenPkgconfig.cmake: rework opencv.pc generation - -Using absolute path to locate the components in the "Libs:" field of the -*.pc can badly break cross-compilation, especially when building -statically linked objects. - -Indeed, pkg-config automatically replaces the '-I...' and '-L...' paths -when the PKG_CONFIG_SYSROOT_DIR and PKG_CONFIG_LIBDIR environment -variables are set [1]. This feature is very helpful and common in -cross-compilation framework like Buildroot [2,3]. - -When there are absolute paths in the *.pc files, pkg-config won't be -able to do the path substitions for these paths when the afromentioned -environment variables are set. -In such case, since the prefix is the target one, not the sysroot one, -these libraries' abolute paths will point to: -- in the best case: a non-existing file (i.e. these files do not exists - on the host system; -- at worst: the host system's libraries. This will make the linking - failed because these host system's libraries will most likely not be - build for the target architecture [4]. - -So, this patch replace the components' absolute paths by the form: - -L -l - -This way, the linker will be able to resolve each dependency path, -whatever the kind of objects/build (shared object or static build) it -is dealing with. - -Note that for static link, the library order does matter [5]. The order -of the opencv components has been carefully chosen to comply with this -requirement. - -Fixes #3931 - -[1] http://linux.die.net/man/1/pkg-config -[2] http://buildroot.org/ -[3] http://git.buildroot.net/buildroot/tree/package/pkgconf/pkg-config.in -[4] http://autobuild.buildroot.net/results/e8a/e8a859276db34aff87ef181b0cce98916b0afc90/build-end.log -[5] http://stackoverflow.com/questions/45135/linker-order-gcc - -Signed-off-by: Samuel Martin - ---- -Note: this patch properly applies on top of the master branch, though it - has been written on top of the 2.4 branch. ---- - cmake/OpenCVGenPkgconfig.cmake | 64 +++++++++++++++++++++++++++--------------- - 1 file changed, 42 insertions(+), 22 deletions(-) - -diff --git a/cmake/OpenCVGenPkgconfig.cmake b/cmake/OpenCVGenPkgconfig.cmake -index fa57db9..183c56d 100644 ---- a/cmake/OpenCVGenPkgconfig.cmake -+++ b/cmake/OpenCVGenPkgconfig.cmake -@@ -8,10 +8,6 @@ - # - # ${BIN_DIR}/unix-install/opencv.pc -> For use *with* "make install" - # ------------------------------------------------------------------------------------------- --set(prefix "${CMAKE_INSTALL_PREFIX}") --set(exec_prefix "\${prefix}") --set(libdir "") #TODO: need link paths for OpenCV_EXTRA_COMPONENTS --set(includedir "\${prefix}/${OPENCV_INCLUDE_INSTALL_PATH}") - - if(CMAKE_BUILD_TYPE MATCHES "Release") - set(ocv_optkind OPT) -@@ -35,42 +31,66 @@ ocv_list_reverse(OpenCV_LIB_COMPONENTS) - ocv_list_reverse(OpenCV_EXTRA_COMPONENTS) - - #build the list of components --set(OpenCV_LIB_COMPONENTS_ "") --foreach(CVLib ${OpenCV_LIB_COMPONENTS}) -- get_target_property(libpath ${CVLib} LOCATION_${CMAKE_BUILD_TYPE}) -- get_filename_component(libname "${libpath}" NAME) - -- if(INSTALL_TO_MANGLED_PATHS) -- set(libname "${libname}.${OPENCV_VERSION}") -- endif() -+# Note: -+# when linking against static libraries, if libfoo depends on libbar, then -+# libfoo must come first in the linker flags. -+ -+# world is a special target whose library should come first, especially for -+# static link. -+if(OpenCV_LIB_COMPONENTS MATCHES "opencv_world") -+ list(REMOVE_ITEM OpenCV_LIB_COMPONENTS "opencv_world") -+ list(INSERT OpenCV_LIB_COMPONENTS 0 "opencv_world") -+endif() -+ -+set(OpenCV_LIB_COMPONENTS_) -+foreach(CVLib ${OpenCV_LIB_COMPONENTS}) - -- #need better solution.... -- if(libpath MATCHES "3rdparty") -- set(installDir "share/OpenCV/3rdparty/${OPENCV_LIB_INSTALL_PATH}") -+ get_target_property(libloc ${CVLib} LOCATION_${CMAKE_BUILD_TYPE}) -+ if(libloc MATCHES "3rdparty") -+ set(libpath "\${exec_prefix}/share/OpenCV/3rdparty/${OPENCV_LIB_INSTALL_PATH}") - else() -- set(installDir "${OPENCV_LIB_INSTALL_PATH}") -+ set(libpath "\${exec_prefix}/${OPENCV_LIB_INSTALL_PATH}") - endif() -+ list(APPEND OpenCV_LIB_COMPONENTS_ "-L${libpath}") -+ -+ get_filename_component(libname ${CVLib} NAME_WE) -+ string(REGEX REPLACE "^lib" "" libname "${libname}") -+ list(APPEND OpenCV_LIB_COMPONENTS_ "-l${libname}") - -- set(OpenCV_LIB_COMPONENTS_ "${OpenCV_LIB_COMPONENTS_} \${exec_prefix}/${installDir}/${libname}") - endforeach() - - # add extra dependencies required for OpenCV --set(OpenCV_LIB_COMPONENTS ${OpenCV_LIB_COMPONENTS_}) - if(OpenCV_EXTRA_COMPONENTS) - foreach(extra_component ${OpenCV_EXTRA_COMPONENTS}) - -- if(extra_component MATCHES "^-[lL]" OR extra_component MATCHES "[\\/]") -- set(maybe_l_prefix "") -+ if(extra_component MATCHES "^-[lL]") -+ set(libprefix "") -+ set(libname "${extra_component}") -+ elseif(extra_component MATCHES "[\\/]") -+ get_filename_component(libdir "${extra_component}" PATH) -+ list(APPEND OpenCV_LIB_COMPONENTS_ "-L${libdir}") -+ get_filename_component(libname "${extra_component}" NAME_WE) -+ string(REGEX REPLACE "^lib" "" libname "${libname}") -+ set(libprefix "-l") - else() -- set(maybe_l_prefix "-l") -+ set(libprefix "-l") -+ set(libname "${extra_component}") - endif() -- -- set(OpenCV_LIB_COMPONENTS "${OpenCV_LIB_COMPONENTS} ${maybe_l_prefix}${extra_component}") -+ list(APPEND OpenCV_LIB_COMPONENTS_ "${libprefix}${libname}") - - endforeach() - endif() - -+list(REMOVE_DUPLICATES OpenCV_LIB_COMPONENTS_) -+string(REPLACE ";" " " OpenCV_LIB_COMPONENTS "${OpenCV_LIB_COMPONENTS_}") -+ - #generate the .pc file -+set(prefix "${CMAKE_INSTALL_PREFIX}") -+set(exec_prefix "\${prefix}") -+set(libdir "\${exec_prefix}/${OPENCV_LIB_INSTALL_PATH}") -+set(includedir "\${prefix}/${OPENCV_INCLUDE_INSTALL_PATH}") -+ - if(INSTALL_TO_MANGLED_PATHS) - set(OPENCV_PC_FILE_NAME "opencv-${OPENCV_VERSION}.pc") - else() --- -2.4.1 - diff --git a/package/opencv/opencv.mk b/package/opencv/opencv.mk index 21c0268a00..2ae95a08b0 100644 --- a/package/opencv/opencv.mk +++ b/package/opencv/opencv.mk @@ -4,7 +4,7 @@ # ################################################################################ -OPENCV_VERSION = 2.4.10 +OPENCV_VERSION = 2.4.12.3 OPENCV_SITE = $(call github,itseez,opencv,$(OPENCV_VERSION)) OPENCV_INSTALL_STAGING = YES OPENCV_LICENSE = BSD-3c