November 2016 - ffmpeg-devel - lists.ffmpeg.org

[PATCH] checkasm: add fixed_dsp tests
by James Almer 11 Apr '17

11 Apr '17

Signed-off-by: James Almer <jamrial(a)gmail.com> --- tests/checkasm/Makefile | 3 + tests/checkasm/checkasm.c | 3 + tests/checkasm/checkasm.h | 1 + tests/checkasm/fixed_dsp.c | 169 +++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 176 insertions(+) create mode 100644 tests/checkasm/fixed_dsp.c diff --git a/tests/checkasm/Makefile b/tests/checkasm/Makefile index e38d15b..698ceef 100644 --- a/tests/checkasm/Makefile +++ b/tests/checkasm/Makefile @@ -11,7 +11,10 @@ AVCODECOBJS-$(CONFIG_PIXBLOCKDSP) += pixblockdsp.o AVCODECOBJS-$(CONFIG_V210_ENCODER) += v210enc.o AVCODECOBJS-$(CONFIG_VP9_DECODER) += vp9dsp.o +AVUTILOBJS += fixed_dsp.o + CHECKASMOBJS-$(CONFIG_AVCODEC) += $(AVCODECOBJS-yes) +CHECKASMOBJS-$(CONFIG_AVUTIL) += $(AVUTILOBJS) -include $(SRC_PATH)/tests/checkasm/$(ARCH)/Makefile diff --git a/tests/checkasm/checkasm.c b/tests/checkasm/checkasm.c index 7f2cf8e..1da085c 100644 --- a/tests/checkasm/checkasm.c +++ b/tests/checkasm/checkasm.c @@ -58,6 +58,9 @@ static const struct { const char *name; void (*func)(void); } tests[] = { +#if CONFIG_AVUTIL + { "fixed_dsp", checkasm_check_fixed_dsp }, +#endif #if CONFIG_AVCODEC #if CONFIG_ALAC_DECODER { "alacdsp", checkasm_check_alacdsp }, diff --git a/tests/checkasm/checkasm.h b/tests/checkasm/checkasm.h index 69416e9..dc3519d 100644 --- a/tests/checkasm/checkasm.h +++ b/tests/checkasm/checkasm.h @@ -33,6 +33,7 @@ void checkasm_check_alacdsp(void); void checkasm_check_bswapdsp(void); void checkasm_check_dcadsp(void); +void checkasm_check_fixed_dsp(void); void checkasm_check_flacdsp(void); void checkasm_check_fmtconvert(void); void checkasm_check_h264pred(void); diff --git a/tests/checkasm/fixed_dsp.c b/tests/checkasm/fixed_dsp.c new file mode 100644 index 0000000..ac7a0b4 --- /dev/null +++ b/tests/checkasm/fixed_dsp.c @@ -0,0 +1,169 @@ +/* + * Copyright (c) 2015 James Almer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with FFmpeg; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include "checkasm.h" +#include "libavutil/common.h" +#include "libavutil/fixed_dsp.h" +#include "libavutil/internal.h" +#include "libavutil/intreadwrite.h" +#include "libavutil/mem.h" + +#define BUF_SIZE 256 + +#define randomize_buffers() \ + do { \ + int i; \ + for (i = 0; i < BUF_SIZE; i++) { \ + src0[i] = sign_extend(rnd(), 24); \ + src1[i] = sign_extend(rnd(), 24); \ + src2[i] = sign_extend(rnd(), 24); \ + } \ + } while (0) + +static void check_vector_fmul(const int *src0, const int *src1, const char *name) +{ + LOCAL_ALIGNED_32(int, ref, [BUF_SIZE]); + LOCAL_ALIGNED_32(int, new, [BUF_SIZE]); + + declare_func(void, int *dst, const int *src0, const int *src1, int len); + + call_ref(ref, src0, src1, BUF_SIZE); + call_new(new, src0, src1, BUF_SIZE); + if (memcmp(ref, new, BUF_SIZE * sizeof(int))) + fail(); + bench_new(new, src0, src1, BUF_SIZE); + + report(name); +} + +static void check_vector_fmul_window_scaled(const int32_t *src0, const int32_t *src1, const int32_t *win) +{ + LOCAL_ALIGNED_16(int16_t, ref, [BUF_SIZE]); + LOCAL_ALIGNED_16(int16_t, new, [BUF_SIZE]); + + declare_func(void, int16_t *dst, const int32_t *src0, const int32_t *src1, const int32_t *win, int len, uint8_t bits); + + call_ref(ref, src0, src1, win, BUF_SIZE / 2, 2); + call_new(new, src0, src1, win, BUF_SIZE / 2, 2); + if (memcmp(ref, new, BUF_SIZE * sizeof(int16_t))) + fail(); + bench_new(new, src0, src1, win, BUF_SIZE / 2, 2); + + report("vector_fmul_window_scaled"); +} + +static void check_vector_fmul_window(const int32_t *src0, const int32_t *src1, const int32_t *win) +{ + LOCAL_ALIGNED_32(int32_t, ref, [BUF_SIZE]); + LOCAL_ALIGNED_32(int32_t, new, [BUF_SIZE]); + + declare_func(void, int32_t *dst, const int32_t *src0, const int32_t *src1, const int32_t *win, int len); + + call_ref(ref, src0, src1, win, BUF_SIZE / 2); + call_new(new, src0, src1, win, BUF_SIZE / 2); + if (memcmp(ref, new, BUF_SIZE * sizeof(int32_t))) + fail(); + bench_new(new, src0, src1, win, BUF_SIZE / 2); + + report("vector_fmul_window"); +} + +static void check_vector_fmul_add(const int *src0, const int *src1, const int *src2) +{ + LOCAL_ALIGNED_32(int, ref, [BUF_SIZE]); + LOCAL_ALIGNED_32(int, new, [BUF_SIZE]); + + declare_func(void, int *dst, const int *src0, const int *src1, const int *src2, int len); + + call_ref(ref, src0, src1, src2, BUF_SIZE); + call_new(new, src0, src1, src2, BUF_SIZE); + if (memcmp(ref, new, BUF_SIZE * sizeof(int))) + fail(); + bench_new(new, src0, src1, src2, BUF_SIZE); + + report("vector_fmul_add"); +} + +static void check_butterflies(const int *src0, const int *src1) +{ + LOCAL_ALIGNED_16(int, ref0, [BUF_SIZE]); + LOCAL_ALIGNED_16(int, ref1, [BUF_SIZE]); + LOCAL_ALIGNED_16(int, new0, [BUF_SIZE]); + LOCAL_ALIGNED_16(int, new1, [BUF_SIZE]); + + declare_func(void, int *av_restrict src0, int *av_restrict src1, int len); + + memcpy(ref0, src0, BUF_SIZE * sizeof(*src0)); + memcpy(ref1, src1, BUF_SIZE * sizeof(*src1)); + memcpy(new0, src0, BUF_SIZE * sizeof(*src0)); + memcpy(new1, src1, BUF_SIZE * sizeof(*src1)); + + call_ref(ref0, ref1, BUF_SIZE); + call_new(new0, new1, BUF_SIZE); + if (memcmp(ref0, new0, BUF_SIZE * sizeof(*ref0)) || + memcmp(ref1, new1, BUF_SIZE * sizeof(*ref1))) + fail(); + memcpy(new0, src0, BUF_SIZE * sizeof(*src0)); + memcpy(new1, src1, BUF_SIZE * sizeof(*src1)); + bench_new(new0, new1, BUF_SIZE); + + report("butterflies_fixed"); +} + +static void check_scalarproduct_fixed(const int *src0, const int *src1) +{ + int ref, new; + + declare_func(int, const int *src0, const int *src1, int len); + + ref = call_ref(src0, src1, BUF_SIZE); + new = call_new(src0, src1, BUF_SIZE); + if (ref != new) + fail(); + bench_new(src0, src1, BUF_SIZE); + + report("scalarproduct_fixed"); +} + +void checkasm_check_fixed_dsp(void) +{ + LOCAL_ALIGNED_32(int32_t, src0, [BUF_SIZE]); + LOCAL_ALIGNED_32(int32_t, src1, [BUF_SIZE]); + LOCAL_ALIGNED_32(int32_t, src2, [BUF_SIZE]); + AVFixedDSPContext *fdsp = avpriv_alloc_fixed_dsp(1); + + randomize_buffers(); + if (check_func(fdsp->vector_fmul, "vector_fmul")) + check_vector_fmul(src0, src1, "vector_fmul"); + if (check_func(fdsp->vector_fmul_reverse, "vector_fmul_reverse")) + check_vector_fmul(src0, src1, "vector_fmul_reverse"); + if (check_func(fdsp->vector_fmul_window_scaled, "vector_fmul_window_scaled")) + check_vector_fmul_window_scaled(src0, src1, src2); + if (check_func(fdsp->vector_fmul_window, "vector_fmul_window")) + check_vector_fmul_window(src0, src1, src2); + if (check_func(fdsp->vector_fmul_add, "vector_fmul_add")) + check_vector_fmul_add(src0, src1, src2); + if (check_func(fdsp->butterflies_fixed, "butterflies_fixed")) + check_butterflies(src0, src1); + if (check_func(fdsp->scalarproduct_fixed, "scalarproduct_fixed")) + check_scalarproduct_fixed(src0, src1); + + av_freep(&fdsp); +} -- 2.7.0

3 5

[PATCH] ffprobe: Support adding av_log output to frames
by Michael Niedermayer 27 Mar '17

27 Mar '17

adding demuxer and other logs should be easy This forces single threaded decoding for simplicity It also requires pthreads, this could be avoided either with some lockless tricks or simply by assuming av_log would never be called from another thread. doc/ffprobe.xsd update missing (TODO & help welcome) Fixes Ticket5521 Signed-off-by: Michael Niedermayer <michael(a)niedermayer.cc> --- ffprobe.c | 154 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 153 insertions(+), 1 deletion(-) diff --git a/ffprobe.c b/ffprobe.c index a7e329c..07b61ec 100644 --- a/ffprobe.c +++ b/ffprobe.c @@ -49,6 +49,19 @@ #include "libpostproc/postprocess.h" #include "cmdutils.h" +#if HAVE_PTHREADS +# include <pthread.h> +#else +# ifdef pthread_mutex_lock +# undef pthread_mutex_lock +# endif +# define pthread_mutex_lock(a) +# ifdef pthread_mutex_unlock +# undef pthread_mutex_unlock +# endif +# define pthread_mutex_unlock(a) +#endif + typedef struct InputStream { AVStream *st; @@ -84,6 +97,7 @@ static int do_show_library_versions = 0; static int do_show_pixel_formats = 0; static int do_show_pixel_format_flags = 0; static int do_show_pixel_format_components = 0; +static int do_show_log = 0; static int do_show_chapter_tags = 0; static int do_show_format_tags = 0; @@ -92,6 +106,7 @@ static int do_show_program_tags = 0; static int do_show_stream_tags = 0; static int do_show_packet_tags = 0; + static int show_value_unit = 0; static int use_value_prefix = 0; static int use_byte_value_binary_prefix = 0; @@ -146,6 +161,8 @@ typedef enum { SECTION_ID_FRAME_TAGS, SECTION_ID_FRAME_SIDE_DATA_LIST, SECTION_ID_FRAME_SIDE_DATA, + SECTION_ID_FRAME_LOG, + SECTION_ID_FRAME_LOGS, SECTION_ID_LIBRARY_VERSION, SECTION_ID_LIBRARY_VERSIONS, SECTION_ID_PACKET, @@ -185,10 +202,12 @@ static struct section sections[] = { [SECTION_ID_FORMAT] = { SECTION_ID_FORMAT, "format", 0, { SECTION_ID_FORMAT_TAGS, -1 } }, [SECTION_ID_FORMAT_TAGS] = { SECTION_ID_FORMAT_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "format_tags" }, [SECTION_ID_FRAMES] = { SECTION_ID_FRAMES, "frames", SECTION_FLAG_IS_ARRAY, { SECTION_ID_FRAME, SECTION_ID_SUBTITLE, -1 } }, - [SECTION_ID_FRAME] = { SECTION_ID_FRAME, "frame", 0, { SECTION_ID_FRAME_TAGS, SECTION_ID_FRAME_SIDE_DATA_LIST, -1 } }, + [SECTION_ID_FRAME] = { SECTION_ID_FRAME, "frame", 0, { SECTION_ID_FRAME_TAGS, SECTION_ID_FRAME_SIDE_DATA_LIST, SECTION_ID_FRAME_LOGS, -1 } }, [SECTION_ID_FRAME_TAGS] = { SECTION_ID_FRAME_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "frame_tags" }, [SECTION_ID_FRAME_SIDE_DATA_LIST] ={ SECTION_ID_FRAME_SIDE_DATA_LIST, "side_data_list", SECTION_FLAG_IS_ARRAY, { SECTION_ID_FRAME_SIDE_DATA, -1 } }, [SECTION_ID_FRAME_SIDE_DATA] = { SECTION_ID_FRAME_SIDE_DATA, "side_data", 0, { -1 } }, + [SECTION_ID_FRAME_LOGS] = { SECTION_ID_FRAME_LOGS, "logs", SECTION_FLAG_IS_ARRAY, { SECTION_ID_FRAME_LOG, -1 } }, + [SECTION_ID_FRAME_LOG] = { SECTION_ID_FRAME_LOG, "log", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 } }, [SECTION_ID_LIBRARY_VERSIONS] = { SECTION_ID_LIBRARY_VERSIONS, "library_versions", SECTION_FLAG_IS_ARRAY, { SECTION_ID_LIBRARY_VERSION, -1 } }, [SECTION_ID_LIBRARY_VERSION] = { SECTION_ID_LIBRARY_VERSION, "library_version", 0, { -1 } }, [SECTION_ID_PACKETS] = { SECTION_ID_PACKETS, "packets", SECTION_FLAG_IS_ARRAY, { SECTION_ID_PACKET, -1} }, @@ -255,11 +274,73 @@ static uint64_t *nb_streams_packets; static uint64_t *nb_streams_frames; static int *selected_streams; +#if HAVE_PTHREADS +pthread_mutex_t log_mutex; +#endif +typedef struct LogBuffer { + char *context_name; + int log_level; + char *log_message; + AVClassCategory category; + char *parent_name; + AVClassCategory parent_category; +}LogBuffer; + +static LogBuffer *log_buffer; +static int log_buffer_size; + +static void log_callback(void *ptr, int level, const char *fmt, va_list vl) +{ + AVClass* avc = ptr ? *(AVClass **) ptr : NULL; + va_list vl2; + char line[1024]; + static int print_prefix = 1; + void *new_log_buffer; + + va_copy(vl2, vl); + av_log_default_callback(ptr, level, fmt, vl); + av_log_format_line(ptr, level, fmt, vl2, line, sizeof(line), &print_prefix); + va_end(vl2); + +#if HAVE_PTHREADS + pthread_mutex_lock(&log_mutex); + + new_log_buffer = av_realloc_array(log_buffer, log_buffer_size + 1, sizeof(*log_buffer)); + if (new_log_buffer) { + log_buffer = new_log_buffer; + memset(&log_buffer[log_buffer_size], 0, sizeof(log_buffer[log_buffer_size])); + log_buffer[log_buffer_size].context_name= avc ? av_strdup(avc->item_name(ptr)) : NULL; + if (avc) { + if (avc->get_category) log_buffer[log_buffer_size].category = avc->get_category(ptr); + else log_buffer[log_buffer_size].category = avc->category; + } + log_buffer[log_buffer_size].log_level = level; + log_buffer[log_buffer_size].log_message = av_strdup(line); + if (avc && avc->parent_log_context_offset) { + AVClass** parent = *(AVClass ***) (((uint8_t *) ptr) + + avc->parent_log_context_offset); + if (parent && *parent) { + log_buffer[log_buffer_size].parent_name = av_strdup((*parent)->item_name(parent)); + log_buffer[log_buffer_size].parent_category = + (*parent)->get_category ? (*parent)->get_category(parent) :(*parent)->category; + } + } + log_buffer_size ++; + } + + pthread_mutex_unlock(&log_mutex); +#endif +} + static void ffprobe_cleanup(int ret) { int i; for (i = 0; i < FF_ARRAY_ELEMS(sections); i++) av_dict_free(&(sections[i].entries_to_show)); + +#if HAVE_PTHREADS + pthread_mutex_destroy(&log_mutex); +#endif } struct unit_value { @@ -1759,6 +1840,56 @@ static inline int show_tags(WriterContext *w, AVDictionary *tags, int section_id return ret; } +static void clear_log(int need_lock) +{ + int i; + + if (need_lock) + pthread_mutex_lock(&log_mutex); + for (i=0; i<log_buffer_size; i++) { + av_freep(&log_buffer[i].context_name); + av_freep(&log_buffer[i].log_message); + } + log_buffer_size = 0; + if(need_lock) + pthread_mutex_unlock(&log_mutex); +} + +static int show_log(WriterContext *w, int section_ids, int section_id, int log_level) +{ + int i; + pthread_mutex_lock(&log_mutex); + if (!log_buffer_size) { + pthread_mutex_unlock(&log_mutex); + return 0; + } + writer_print_section_header(w, section_ids); + + for (i=0; i<log_buffer_size; i++) { + if (log_buffer[i].log_level <= log_level) { + writer_print_section_header(w, section_id); + print_str("context", log_buffer[i].context_name); + print_int("level", log_buffer[i].log_level); + print_int("category", log_buffer[i].category); + if (log_buffer[i].parent_name) { + print_str("parent_context", log_buffer[i].parent_name); + print_int("parent_category", log_buffer[i].parent_category); + } else { + print_str_opt("parent_context", "N/A"); + print_str_opt("parent_category", "N/A"); + } + print_str("message", log_buffer[i].log_message); + writer_print_section_footer(w); + } + } + clear_log(0); + pthread_mutex_unlock(&log_mutex); + + writer_print_section_footer(w); + + return 0; +} + static void show_packet(WriterContext *w, InputFile *ifile, AVPacket *pkt, int packet_idx) { char val_str[128]; @@ -1917,6 +2048,8 @@ static void show_frame(WriterContext *w, AVFrame *frame, AVStream *stream, } if (do_show_frame_tags) show_tags(w, av_frame_get_metadata(frame), SECTION_ID_FRAME_TAGS); + if (do_show_log) + show_log(w, SECTION_ID_FRAME_LOGS, SECTION_ID_FRAME_LOG, do_show_log); if (frame->nb_side_data) { writer_print_section_header(w, SECTION_ID_FRAME_SIDE_DATA_LIST); for (i = 0; i < frame->nb_side_data; i++) { @@ -1956,6 +2089,7 @@ static av_always_inline int process_frame(WriterContext *w, AVSubtitle sub; int ret = 0, got_frame = 0; + clear_log(1); if (dec_ctx && dec_ctx->codec) { switch (par->codec_type) { case AVMEDIA_TYPE_VIDEO: @@ -2604,6 +2738,13 @@ static int open_input_file(InputFile *ifile, const char *filename) if (err < 0) exit(1); + if (do_show_log) { + // For loging it is needed to disable at least frame threads as otherwise + // the log information would need to be reordered and matches up to contexts and frames + // That is in fact possible but not trivial + av_dict_set(&codec_opts, "threads", "1", 0); + } + ist->dec_ctx->pkt_timebase = stream->time_base; #if FF_API_LAVF_AVCTX ist->dec_ctx->time_base = stream->codec->time_base; @@ -3191,6 +3332,9 @@ static const OptionDef real_options[] = { "show a particular entry from the format/container info", "entry" }, { "show_entries", HAS_ARG, {.func_arg = opt_show_entries}, "show a set of specified entries", "entry_list" }, +#if HAVE_PTHREADS + { "show_log", OPT_INT|HAS_ARG, {(void*)&do_show_log}, "show log" }, +#endif { "show_packets", 0, {(void*)&opt_show_packets}, "show packets info" }, { "show_programs", 0, {(void*)&opt_show_programs}, "show programs info" }, { "show_streams", 0, {(void*)&opt_show_streams}, "show streams info" }, @@ -3235,6 +3379,14 @@ int main(int argc, char **argv) char *w_name = NULL, *w_args = NULL; int ret, i; +#if HAVE_PTHREADS + ret = pthread_mutex_init(&log_mutex, NULL); + if (ret != 0) { + goto end; + } +#endif + av_log_set_callback(log_callback); + av_log_set_flags(AV_LOG_SKIP_REPEATED); register_exit(ffprobe_cleanup); -- 1.7.9.5

4 13

[PATCH] libavcodec/dnxhd: add support more dnxhr header prefixes
by Mark Reid 21 Mar '17

21 Mar '17

Hi, The following patch adds support for detecting more dnxhr header prefixes. After generating many random resolution dnxhr files via quicktime, I have deduced that second 4 bytes in prefix is the header size or data offset to the end of the scan table. On heights smaller then 1080 the header size is always 0x0280 here are some samples with prefixes that aren't currently supported. https://dl.dropboxusercontent.com/u/170952/ffmpeg_samples/new_header_prefix… https://dl.dropboxusercontent.com/u/170952/ffmpeg_samples/new_header_prefix… https://dl.dropboxusercontent.com/u/170952/ffmpeg_samples/new_header_prefix… https://dl.dropboxusercontent.com/u/170952/ffmpeg_samples/new_header_prefix… Mark Reid (1): libavcodec/dnxhd: add support more dnxhr header prefixes libavcodec/dnxhddata.h | 15 +++++++++++---- libavcodec/dnxhddec.c | 2 +- 2 files changed, 12 insertions(+), 5 deletions(-) -- 2.7.3

3 6

[PATCH]lavf/mpeg: Identify sub-stream ID 0xa1 as mlp
by Carl Eugen Hoyos 02 Mar '17

02 Mar '17

Hi! Attached patch (still) fixes ticket #4786 for me. Autodetection seems impossible to me and the following page suggests that this patch is likely correct: http://dvd-audio.sourceforge.net/spec/aob.shtml Please comment, Carl Eugen

3 3

Re: [FFmpeg-devel] TR-03 implementation
by Ali KIZIL 16 Feb '17

16 Feb '17

2016-11-11 0:24 GMT+03:00 Kieran Kunhya <kierank(a)obe.tv>: > > > > sure, ffmpeg has support for many pixel formats and adding more > > pixfmts is not a problem. > > > > my best answer would be to look at commits which add other pixel > > formats and just follow how they were added to libswscale. make some > > fate tests, and it should be done. > > > > hopefully you have test samples made of these pixfmts you want to add. > > that makes testing for us easier, as we can test on multiple cpu > > arch's to make sure the code is safe and works. > > > > Sorry Compn, nothing personal here, but you are responding exactly in the > way I thought you would and why I even wrote that certain people would > encourage in spite of the technical issues. > > You don't understand the complexity of this problem either. The pixel > formats are the least of his problems. Samples don't exist, it's not a file > based format, it's a network stream etc. Please listen to what Ros and I > said, we worked on this painfully for months. > > Regards, > Kieran > _______________________________________________ > ffmpeg-devel mailing list > ffmpeg-devel(a)ffmpeg.org > http://ffmpeg.org/mailman/listinfo/ffmpeg-devel > Hi all, I very rarely send patches to FFmpeg. Maybe I am the last one in the row to say something about the topic, but I belive it is not good idea to break motivation of contributors even the idea is good or bad or wrong. If someone wants to try, he can give a try, release a patch, it can be discussed in a discussion level. I really find saying such comments like " We don't need more broadcasting shit in ffmpeg." and "....and it is why FFmpeg is full of broken things and has a bad name in the professional world." annoying. Frankly speaking, as my own, I start to think maybe some people try to give intentional directions to FFmpeg. Belive me; Cisco, Ateme, Siemens etc. use FFmpeg in their products and solutions. For me, FFmpeg is great as its contributors. ------------- A part from the topic; there are several useful patches released but not applied yet, such as: https://trac.ffmpeg.org/attachment/ticket/4155/underflow_overflow_fix.diff http://ffmpeg.org/pipermail/ffmpeg-devel/2016-June/194856.html http://ffmpeg.org/pipermail/ffmpeg-devel/2016-November/202587.html I wanted to mention this under contributor's motivation sunbjec, maybe https://patchwork.ffmpeg.org can be used to upload missed patches. Kind Regards, Ali KIZIL

4 3

[rfc] ffmpeg security issue mailing list
by compn 09 Feb '17

09 Feb '17

hello, some of you know that we have a list for security / CVE issues. some of you did not know this. i think it is a private list due to not wanting people to make exploits before we have a chance to fix them. of course, if no one is subscribed to review/fix issues then they will never get fixed. so if you are a regular developer who wants access to this list, please speak up. i do not run nor admin the security email/list (nor do i know who does) so please dont ask me questions about it. -compn

6 12

[PATCH] avformat/hls: Added subtitle support
by Franklin Phillips 05 Feb '17

05 Feb '17

This patch is a fix for ticket #2833. Each subtitle segment is its own WebVTT file and has to demuxed individually. The timing of the subtitles are not perfect but it is the best I could do and it also does not take into account the X-TIMESTAMP-MAP header in the WebVTT files which is needed to conform to the specification (https://tools.ietf.org/html/draft-pantos-http-live-streaming-20#section-3.5) Signed-off-by: Franklin Phillips <franklinphillips(a)gmx.com> --- libavformat/hls.c | 178 ++++++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 159 insertions(+), 19 deletions(-) diff --git a/libavformat/hls.c b/libavformat/hls.c index 3ae3c7c..bf13be4 100644 --- a/libavformat/hls.c +++ b/libavformat/hls.c @@ -153,6 +153,8 @@ struct playlist { * playlist, if any. */ int n_init_sections; struct segment **init_sections; + + int is_subtitle; /* Indicates if the playlist is for subtitles */ }; /* @@ -312,6 +314,8 @@ static struct playlist *new_playlist(HLSContext *c, const char *url, pls->is_id3_timestamped = -1; pls->id3_mpegts_timestamp = AV_NOPTS_VALUE; + pls->is_subtitle = 0; + dynarray_add(&c->playlists, &c->n_playlists, pls); return pls; } @@ -482,11 +486,6 @@ static struct rendition *new_rendition(HLSContext *c, struct rendition_info *inf if (type == AVMEDIA_TYPE_SUBTITLE && !info->uri[0]) return NULL; - /* TODO: handle subtitles (each segment has to parsed separately) */ - if (c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) - if (type == AVMEDIA_TYPE_SUBTITLE) - return NULL; - rend = av_mallocz(sizeof(struct rendition)); if (!rend) return NULL; @@ -501,9 +500,14 @@ static struct rendition *new_rendition(HLSContext *c, struct rendition_info *inf /* add the playlist if this is an external rendition */ if (info->uri[0]) { rend->playlist = new_playlist(c, info->uri, url_base); - if (rend->playlist) + if (rend->playlist) { dynarray_add(&rend->playlist->renditions, &rend->playlist->n_renditions, rend); + if (type == AVMEDIA_TYPE_SUBTITLE) { + rend->playlist->is_subtitle = 1; + rend->playlist->is_id3_timestamped = 0; + } + } } if (info->assoc_language[0]) { @@ -1349,6 +1353,136 @@ reload: goto restart; } +static int nested_io_open(AVFormatContext *s, AVIOContext **pb, const char *url, + int flags, AVDictionary **opts) +{ + av_log(s, AV_LOG_ERROR, + "A HLS playlist item '%s' referred to an external file '%s'. " + "Opening this file was forbidden for security reasons\n", + s->filename, url); + return AVERROR(EPERM); +} + +static int read_data_simple(void *opaque, uint8_t *buf, int buf_size) +{ + struct playlist *v = opaque; + HLSContext *c = v->parent->priv_data; + struct segment *seg; + + if (v->cur_seq_no >= v->start_seq_no + v->n_segments) { + return AVERROR_EOF; + } else { + seg = current_segment(v); + } + + if (!v->input) { + open_input(c, v, seg); + } + + return read_from_url(v, seg, buf, buf_size, READ_NORMAL); +} + +static int read_packet_subtitle(struct playlist *v, AVPacket *pkt) +{ + HLSContext *c = v->parent->priv_data; + int ret, i; + +restart: + if (!v->needed) + return AVERROR_EOF; + + if (!v->input) { + int64_t reload_interval; + + /* Check that the playlist is still needed before opening a new + * segment. */ + if (v->ctx && v->ctx->nb_streams) { + v->needed = 0; + for (i = 0; i < v->n_main_streams; i++) { + if (v->main_streams[i]->discard < AVDISCARD_ALL) { + v->needed = 1; + break; + } + } + } + if (!v->needed) { + av_log(v->parent, AV_LOG_INFO, "No longer receiving playlist %d\n", + v->index); + return AVERROR_EOF; + } + + /* If this is a live stream and the reload interval has elapsed since + * the last playlist reload, reload the playlists now. */ + reload_interval = default_reload_interval(v); + + if (!v->finished && + av_gettime_relative() - v->last_load_time >= reload_interval) { + if ((ret = parse_playlist(c, v->url, v, NULL)) < 0) { + av_log(v->parent, AV_LOG_WARNING, "Failed to reload playlist %d\n", + v->index); + return ret; + } + /* If we need to reload the playlist again below (if + * there's still no more segments), switch to a reload + * interval of half the target duration. */ + reload_interval = v->target_duration / 2; + } + if (v->cur_seq_no < v->start_seq_no) { + av_log(NULL, AV_LOG_WARNING, + "skipping %d segments ahead, expired from subtitle playlists\n", + v->start_seq_no - v->cur_seq_no); + v->cur_seq_no = v->start_seq_no; + } + if (v->cur_seq_no >= v->start_seq_no + v->n_segments) { + return AVERROR_EOF; + } + } + + if (v->ctx == NULL) { + AVInputFormat *in_fmt; + + if (!(v->ctx = avformat_alloc_context())) { + return AVERROR(ENOMEM); + } + + v->read_buffer = av_malloc(INITIAL_BUFFER_SIZE); + if (!v->read_buffer){ + avformat_free_context(v->ctx); + v->ctx = NULL; + return AVERROR(ENOMEM); + } + + ffio_init_context(&v->pb, v->read_buffer, INITIAL_BUFFER_SIZE, 0, v, + read_data_simple, NULL, NULL); + v->pb.seekable = 0; + v->ctx->pb = &v->pb; + v->ctx->io_open = nested_io_open; + + ret = ff_copy_whiteblacklists(v->ctx, v->parent); + if (ret < 0) { + return ret; + } + + in_fmt = av_find_input_format("webvtt"); + ret = avformat_open_input(&v->ctx, current_segment(v)->url, in_fmt, NULL); + if (ret < 0) { + return ret; + } + } + + ret = av_read_frame(v->ctx, pkt); + if (ret < 0) { + ff_format_io_close(v->parent, &v->input); + avformat_close_input(&v->ctx); + if (ret == AVERROR_EOF) { + v->cur_seq_no++; + goto restart; + } + } + + return ret; +} + static void add_renditions_to_variant(HLSContext *c, struct variant *var, enum AVMediaType type, const char *group_id) { @@ -1492,16 +1626,6 @@ static int save_avio_options(AVFormatContext *s) return ret; } -static int nested_io_open(AVFormatContext *s, AVIOContext **pb, const char *url, - int flags, AVDictionary **opts) -{ - av_log(s, AV_LOG_ERROR, - "A HLS playlist item '%s' referred to an external file '%s'. " - "Opening this file was forbidden for security reasons\n", - s->filename, url); - return AVERROR(EPERM); -} - static void add_stream_to_programs(AVFormatContext *s, struct playlist *pls, AVStream *stream) { HLSContext *c = s->priv_data; @@ -1744,8 +1868,14 @@ static int hls_read_header(AVFormatContext *s) pls->ctx = NULL; goto fail; } - ffio_init_context(&pls->pb, pls->read_buffer, INITIAL_BUFFER_SIZE, 0, pls, - read_data, NULL, NULL); + + if (pls->is_subtitle) { + ffio_init_context(&pls->pb, pls->read_buffer, INITIAL_BUFFER_SIZE, 0, pls, + read_data_simple, NULL, NULL); + } else { + ffio_init_context(&pls->pb, pls->read_buffer, INITIAL_BUFFER_SIZE, 0, pls, + read_data, NULL, NULL); + } pls->pb.seekable = 0; ret = av_probe_input_buffer(&pls->pb, &in_fmt, pls->segments[0]->url, NULL, 0, 0); @@ -1843,6 +1973,8 @@ static int recheck_discard_flags(AVFormatContext *s, int first) } else if (first && !pls->cur_needed && pls->needed) { if (pls->input) ff_format_io_close(pls->parent, &pls->input); + if (pls->is_subtitle) + avformat_close_input(&pls->ctx); pls->needed = 0; changed = 1; av_log(s, AV_LOG_INFO, "No longer receiving playlist %d\n", i); @@ -1909,7 +2041,12 @@ static int hls_read_packet(AVFormatContext *s, AVPacket *pkt) while (1) { int64_t ts_diff; AVRational tb; - ret = av_read_frame(pls->ctx, &pls->pkt); + if (pls->is_subtitle) { + ret = read_packet_subtitle(pls, &pls->pkt); + } else { + ret = av_read_frame(pls->ctx, &pls->pkt); + } + if (ret < 0) { if (!avio_feof(&pls->pb) && ret != AVERROR_EOF) return ret; @@ -2087,6 +2224,9 @@ static int hls_read_seek(AVFormatContext *s, int stream_index, /* Flush the packet queue of the subdemuxer. */ ff_read_frame_flush(pls->ctx); + if (pls->is_subtitle) + avformat_close_input(&pls->ctx); + pls->seek_timestamp = seek_timestamp; pls->seek_flags = flags; -- 2.1.4

4 18

[PATCH] avfilter: add threshold filter
by Paul B Mahol 30 Jan '17

30 Jan '17

Hi, patch attached.

1 1

[PATCH 1/3] tools: add loudnorm script example to use loudnorm
by Marton Balint 22 Jan '17

22 Jan '17

From: Kyle Swanson <k(a)ylo.ph> Signed-off-by: Kyle Swanson <k(a)ylo.ph> Signed-off-by: Marton Balint <cus(a)passwd.hu> --- tools/loudnorm.rb | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 60 insertions(+) create mode 100755 tools/loudnorm.rb diff --git a/tools/loudnorm.rb b/tools/loudnorm.rb new file mode 100755 index 0000000..39deb70 --- /dev/null +++ b/tools/loudnorm.rb @@ -0,0 +1,60 @@ +#!/usr/bin/env ruby + +require 'open3' +require 'json' + +ffmpeg_bin = 'ffmpeg' +target_il = -24.0 +target_lra = +11.0 +target_tp = -2.0 +samplerate = '48k' + +if ARGF.argv.count != 2 + puts "Usage: #{$PROGRAM_NAME} input.wav output.wav" + exit 1 +end + +ff_string = "#{ffmpeg_bin} -hide_banner " +ff_string += "-i #{ARGF.argv[0]} " +ff_string += '-af loudnorm=' +ff_string += "I=#{target_il}:" +ff_string += "LRA=#{target_lra}:" +ff_string += "tp=#{target_tp}:" +ff_string += 'print_format=json ' +ff_string += '-f null -' + +_stdin, _stdout, stderr, wait_thr = Open3.popen3(ff_string) + +if wait_thr.value.success? + stats = JSON.parse(stderr.read.lines[-12, 12].join) + loudnorm_string = '-af loudnorm=' + loudnorm_string += 'print_format=summary:' + loudnorm_string += 'linear=true:' + loudnorm_string += "I=#{target_il}:" + loudnorm_string += "LRA=#{target_lra}:" + loudnorm_string += "tp=#{target_tp}:" + loudnorm_string += "measured_I=#{stats['input_i']}:" + loudnorm_string += "measured_LRA=#{stats['input_lra']}:" + loudnorm_string += "measured_tp=#{stats['input_tp']}:" + loudnorm_string += "measured_thresh=#{stats['input_thresh']}:" + loudnorm_string += "offset=#{stats['target_offset']}" +else + puts stderr.read + exit 1 +end + +ff_string = "#{ffmpeg_bin} -y -hide_banner " +ff_string += "-i #{ARGF.argv[0]} " +ff_string += "#{loudnorm_string} " +ff_string += "-ar #{samplerate} " +ff_string += ARGF.argv[1].to_s + +_stdin, _stdout, stderr, wait_thr = Open3.popen3(ff_string) + +if wait_thr.value.success? + puts stderr.read.lines[-12, 12].join + exit 0 +else + puts stderr.read + exit 1 +end -- 2.6.6

11 35

CNG (consistent noise generation) patch for AC-3 decoder
by Jonathan Campbell 22 Jan '17

22 Jan '17

I finished the consistent noise generation patch for AC-3 decoding. Set AVOption "cons_noisegen" to 1 (true) to enable it. Git repository: https://github.com/joncampbell123/FFmpeg.git commit dbd086586f0ad1591ea2013293bbb6e4dbfd0455 Author: Jonathan Campbell <jonathan(a)castus.tv> Date: Thu Sep 1 18:46:16 2016 -0700 AC-3 consistent noise generation: avopt -cons_noisegen <number> When -cons_noisegen 1, the linear feedback generator used for AC-3 dithering is seeded with the contents of the AC-3 frame. Seeding from the AC-3 frame ensures the dithering noise comes out exactly the same when given the same AC-3 frame data, which can then be used by non-linear editing software to reliably decode discontinuous segments of an AC-3 bitstream without gaps or discontinuities. Jonathan Campbell Patch follows, hope Thunderbird doesn't garble it: diff --git a/libavcodec/ac3dec.c b/libavcodec/ac3dec.c index fac189b..28048d7 100644 --- a/libavcodec/ac3dec.c +++ b/libavcodec/ac3dec.c @@ -1419,6 +1419,19 @@ static int ac3_decode_frame(AVCodecContext * avctx, void *data, (const uint16_t *) buf, cnt); } else memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE)); + + /* if consistent noise generation is enabled, seed the linear feedback generator + * with the contents of the AC-3 frame so that the noise is identical across + * decodes given the same AC-3 frame data, for use with non-linear edititing software. */ + if (s->consistent_noise_generation) { + const AVCRC *avcrc = av_crc_get_table(AV_CRC_32_IEEE); + + if (avcrc != NULL) + av_lfg_init(&s->dith_state, av_crc(avcrc, 0, s->input_buffer, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE))); + else + av_log(avctx, AV_LOG_ERROR, "CNG unable to seed from frame"); + } + buf = s->input_buffer; /* initialize the GetBitContext with the start of valid AC-3 Frame */ if ((ret = init_get_bits8(&s->gbc, buf, buf_size)) < 0) diff --git a/libavcodec/ac3dec.h b/libavcodec/ac3dec.h index c2b867e..98184e9 100644 --- a/libavcodec/ac3dec.h +++ b/libavcodec/ac3dec.h @@ -177,6 +177,10 @@ typedef struct AC3DecodeContext { int end_freq[AC3_MAX_CHANNELS]; ///< end frequency bin (endmant) ///@} +///@name Consistent noise generation + int consistent_noise_generation; ///< seed noise generation with AC-3 frame on decode +///@} + ///@name Rematrixing int num_rematrixing_bands; ///< number of rematrixing bands (nrematbnd) int rematrixing_flags[4]; ///< rematrixing flags (rematflg) diff --git a/libavcodec/ac3dec_fixed.c b/libavcodec/ac3dec_fixed.c index 6416da4..1f79ade 100644 --- a/libavcodec/ac3dec_fixed.c +++ b/libavcodec/ac3dec_fixed.c @@ -168,6 +168,7 @@ static void ac3_downmix_c_fixed16(int16_t **samples, int16_t (*matrix)[2], #include "ac3dec.c" static const AVOption options[] = { + { "cons_noisegen", "enable consistent noise generation", OFFSET(consistent_noise_generation), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, PAR }, { "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, 0.0, 6.0, PAR }, { "heavy_compr", "enable heavy dynamic range compression", OFFSET(heavy_compression), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, PAR }, { NULL}, diff --git a/libavcodec/ac3dec_float.c b/libavcodec/ac3dec_float.c index 0a5319a..b85a4ce 100644 --- a/libavcodec/ac3dec_float.c +++ b/libavcodec/ac3dec_float.c @@ -32,6 +32,7 @@ #include "ac3dec.c" static const AVOption options[] = { + { "cons_noisegen", "enable consistent noise generation", OFFSET(consistent_noise_generation), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, PAR }, { "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, 0.0, 6.0, PAR }, { "heavy_compr", "enable heavy dynamic range compression", OFFSET(heavy_compression), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, PAR }, { "target_level", "target level in -dBFS (0 not applied)", OFFSET(target_level), AV_OPT_TYPE_INT, {.i64 = 0 }, -31, 0, PAR },

6 28