March 2015 - ffmpeg-devel - lists.ffmpeg.org

Evolution of lavfi's design and API
by Nicolas George 07 Jun '18

07 Jun '18

[ CCing Anton, as most that is written here also apply to libav too, and this would be a good occasion to try a cross-fork cooperation; if that is not wanted, please let us know so we can drop the cc. ] 1. Problems with the current design 1.1. Mixed input-/output-driven model Currently, lavfi is designed to work in a mixed input-driven and output-driven model. That means the application needs sometimes to add input to buffersources and sometimes request output to buffersinks. This is a bit of a nuisance, because it requires the application to do it properly: adding input on the wrong input or requesting a frame on the wrong output will cause extra memory consumption or latency. With the libav API, it can not work at all since there is no mechanism to determine which input needs a frame in order to proceed. The libav API is clearly designed for a more output-driven implementation, with FIFOs anywhere to prevent input-driven frames to reach unready filters. Unfortunately, since it is impossible from the outside to guess what output will get a frame next, that can cause frames to accumulate anywhere in the filter graph, eating a lot of memory unnecessarily. FFmpeg's API has eliminated FIFOs in favour of queues in filters that need it, but these queues can not be controlled for unusual filter graphs with extreme needs. Also, there still is an implicit FIFO inside buffersink. 1.2. Recursive implementation All work in a filter graph is triggered by recursive invocations of the filters' methods. It makes debugging harder. It also can lead to large stack usage and makes frame- and filter-level multithreading harder to implement. It also prevents some diagnosis from working reliably. 1.3. EOF handling Currently, EOF is propagated only through the return value of the request_frame() method. That means it only works in an output-driven scheme. It also means that it has no timestamp attached to it; this is an issue for filters where the duration of the last frame is relevant, like vf_fps. 1.4. Latency Some filters need to know the timestamp of the next frame in order to know when the current frame will stop and be able to process it: overlay, fps are two examples. These filters will introduce a latency of one input frame that could otherwise be avoided. 1.5. Timestamps Some filters do not care about timestamps at all. Some check and have a proper handling of NOPTS values. Some filters just assume the frames will have timestamps, and possibly make extra assumptions on that: monotony, consistency, etc. That is an inconsistent mess. 1.6. Sparse streams There is a more severe instance of the latency issue when the input comes from an interleaved sparse stream: in that case, waiting for the next frame in order to find the end of the current one may require demuxing a large chunk of input, in turn provoking a lot of activity on other inputs of the graph. 2. Proposed API changes To fix/enhance all these issues, I believe a complete rethink of the scheduling design of the library is necessary. I propose the following changes. Note: some of these changes are not 100% related to the issues I raised, but looked like a good idea while thinking on an API rework. 2.1. AVFrame.duration Add a duration field to AVFrame; if set, it indicates the duration of the frame. Thus, it becomes unnecessary to wait for the next frame to know when the current frame stops, reducing the latency. Another solution would be to add a dedicated function on buffersrc to inject a timestamp for end or activity on a link. That would avoid the need of adding a field to AVFrame. 2.2. Add some fields to AVFilterLink AVFilterLink.pts: current timestamp of the link, i.e. end timestamp of the last forwarede frame, assuming the duration was correct. This is somewhat redundant with the fields in AVFrame, but can carry the information even when there is no actual frame. AVFilterLink.status: if not 0, gives the return status of trying to pass a frame on this link. The typical use would be EOF. 2.3. AVFilterLink.need_ts Add a field to AVFilterLink to specify that the output filter requires reliable timestamps on its input. More precisely, specify how reliable the timestamps need to be: is the duration necessary? do the timestamps need to be monotonic? continuous? For audio streams, consistency between timestamps and the number of samples may also be tested. For video streams, constant frame rate may be enforced, but I am not sure about this one. A "fixpts" filter should be provided to allow the user to tweak how the timestamps are fixed (change the timestamps to match the duration or change the duration to match the timestamps?). When no explicit filter is inserted, the framework should do the work of fixing them automatically. I am not sure whether that should be done directly or by automatically inserting the fixpts filter. The later solution is more elegant, but it requires more changes to the framework and the filters (because the correctness of the timestamps would need to be merged just like formats), so I am rather for the former. Note that for a lot of filters, the actual duration or end timestamp is not required, only a lower bound for it. For sparse interleaved streams, that is very relevant as we may not know the exact time for the next frame until we reach it, but we can know it is later than the other streams' timestamps minus the interleaving delta. 2.4. Build FIFOs directly in AVFilterLink Instead of automatically insert an additional filter like libav, handle the FIFO operation directly in the framework using fields in AVFilterLink. The main benefit is that the framework can examine the inside of the FIFOs to make scheduling decisions. It can also do so to provide the user with more accurate diagnostics. An extra benefit: the memory pool for the FIFOed frames can more easily be shared, across the whole filter graph or the whole application. Memory management becomes easier: just take a good heuristics (half the RAM?), no need to guess what FIFOs will actually need a lot of memory and what FIFOs are just there mostly useless. Last but not least, FIFOs now become potential thread communication / synchronization points, making filter-level multithreading easier. For audio streams, framing (i.e. ensuring all frame have an exact / minimum / maximum number of samples) can be merged with FIFOs. 2.5. Allow status change pseudo-frames inside FIFOs To propagate EOF and possibly other status changes (errors) in input-driven model, allow FIFOs to contain not only frames but also kind of pseudo-frames with a timestamp and metadata attached. Depending on the filters, these pseudo-frames may be directly passed to the filter's methods, or they may be interpreted by the framework to just change fields on the AVFilterLink structure. 2.6. Change the scheduling logic for filters From the outside of a filter with several outputs, it is usually not possible to guess what output will get a frame next. Requesting a frame on output #0 may cause activity on the filter graph that produce a frame on output #1 instead, or possibly on a completely different filter. Therefore, having a request_frame() method on all outputs seems pointless. Instead, use a global AVFilter.activate() method that causes the filter to do one step of work if it can. This method is called each time something is changed to the filter: new frame on input, output ready, status change. It returns as soon at it could do something, either producing output and/or consuming input, or nothing if nothing can be done. 2.7. Add fields to AVFilterLink for flow control. Add to AVFilterLinks a few field to help filters decide if they need to process something, and if relevant in what order. The most obvious idea would be AVFilterLink.frames_needed, counting how many frames are probably needed on a link before anything can be done. For example, with concat, after input has been consumed, the frames_needed fields on the current input are set according to the corresponding output. 2.8. Activate the filters iteratively Keep a global (per graph) priority queue of filters that are supposed to be ready and call the activate() method on them. 2.9. AVFrame.stream_id Add an integer (or pointer: intptr_t maybe?) field to AVFrame to allow passing frames related to distinct streams on the same link. That would allow to multiplex all outputs of a graph into a single output, making the application simpler. Not sure this is really useful or necessary: for the graph outputs, a convenience function iterating on all of them and returning the frame and the output index separately would do the trick too. 2.10. buffersrc.callback and buffersink.callback Add a callback on both buffersource and buffersink, called respectively when a frame is necessary on input and a frame has arrived on output. This allows pure input-driven and pure output-driven design to work. 2.11. Links groups Links that carry frames from related interleaved streams should be explicitly connected together so that the framework can use the information. The typical use would be to group all the links from buffersrc that come from the same interleaved input file. When a frame is passed on a link, all links in the same group(s) that are too late (according to an interleaving tolerance that can be set) are activated using a dummy frame. 2.12. FIFOs with compression and external storage All FIFOs should be able to off-load some of their memory requirements by either compressing the frames (using a lossless or optionally lossy codec) and/or storing them on mass storage. The options for that should be changeable globally or on a per-link basis. 2.13. AVFrame.owner Add a owner field (probably with type "AVObject", i.e. "void *" pointing to AVClass *) to AVFrame, and update it whenever the frame is passed from one filter to the other. That way, inconsistent ref/unref operations can be detected. Regards, -- Nicolas George

7 35

[PATCH 1/2] img2: added support for %t output pattern
by Yuval Adam 05 Dec '16

05 Dec '16

From: Yuval Adam <yuv.adm(a)gmail.com> The image2 muxer now supports timestamps in output filenames. When used in an output patterm '%t' will be replaced with the frames timestamp in hours, minutes and seconds (hh:mm:ss). Signed-off-by: Yuval Adam <yuv.adm(a)gmail.com> --- doc/muxers.texi | 5 +++++ libavformat/avformat.h | 6 ++++-- libavformat/img2.c | 13 ++++++++----- libavformat/utils.c | 32 +++++++++++++++++++++++++------- 4 files changed, 42 insertions(+), 14 deletions(-) diff --git a/doc/muxers.texi b/doc/muxers.texi index 60a72d6..72212fe 100644 --- a/doc/muxers.texi +++ b/doc/muxers.texi @@ -109,6 +109,11 @@ If the pattern contains "%d" or "%0@var{N}d", the first filename of the file list specified will contain the number 1, all the following numbers will be sequential. +The pattern may also contain "%t", this string specifies the timestamp +of the frame in hours, minutes and seconds. Note that if two frames are written at the +same second, they will be overwritten, yielding a maximum output of 1 fps. +The "%t" and "%d" patterns may not be used simultaneously. + The pattern may contain a suffix which is used to automatically determine the format of the image files to write. diff --git a/libavformat/avformat.h b/libavformat/avformat.h index 2ed6b56..a9ab0cc 100644 --- a/libavformat/avformat.h +++ b/libavformat/avformat.h @@ -2067,7 +2067,8 @@ attribute_deprecated int find_info_tag(char *arg, int arg_size, const char *tag1 #endif /** - * Return in 'buf' the path with '%d' replaced by a number. + * Return in 'buf' the path with '%d' replaced by the frame number, + * and '%t' replaced by the frame timestamp. * * Also handles the '%0nd' format where 'n' is the total number * of digits and '%%'. @@ -2076,10 +2077,11 @@ attribute_deprecated int find_info_tag(char *arg, int arg_size, const char *tag1 * @param buf_size destination buffer size * @param path numbered sequence string * @param number frame number + * @param ts frame timestamp in seconds * @return 0 if OK, -1 on format error */ int av_get_frame_filename(char *buf, int buf_size, - const char *path, int number); + const char *path, int number, int ts); /** * Check whether filename actually is a numbered sequence generator. diff --git a/libavformat/img2.c b/libavformat/img2.c index bc35591..8012e5b 100644 --- a/libavformat/img2.c +++ b/libavformat/img2.c @@ -142,7 +142,7 @@ static int find_image_range(int *pfirst_index, int *plast_index, /* find the first image */ for(first_index = 0; first_index < 5; first_index++) { - if (av_get_frame_filename(buf, sizeof(buf), path, first_index) < 0){ + if (av_get_frame_filename(buf, sizeof(buf), path, first_index, 0) < 0){ *pfirst_index = *plast_index = 1; if (avio_check(buf, AVIO_FLAG_READ) > 0) @@ -165,7 +165,7 @@ static int find_image_range(int *pfirst_index, int *plast_index, else range1 = 2 * range; if (av_get_frame_filename(buf, sizeof(buf), path, - last_index + range1) < 0) + last_index + range1, 0) < 0) goto fail; if (avio_check(buf, AVIO_FLAG_READ) <= 0) break; @@ -310,7 +310,7 @@ static int read_packet(AVFormatContext *s1, AVPacket *pkt) if (s->img_number > s->img_last) return AVERROR_EOF; if (av_get_frame_filename(filename, sizeof(filename), - s->path, s->img_number)<0 && s->img_number > 1) + s->path, s->img_number, 0)<0 && s->img_number > 1) return AVERROR(EIO); for(i=0; i<3; i++){ if (avio_open2(&f[i], filename, AVIO_FLAG_READ, @@ -389,12 +389,15 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt) VideoData *img = s->priv_data; AVIOContext *pb[3]; char filename[1024]; - AVCodecContext *codec= s->streams[ pkt->stream_index ]->codec; + AVStream *stream = s->streams[ pkt->stream_index ]; + AVCodecContext *codec = stream->codec; int i; + int ts = av_rescale_q(pkt->pts, stream->time_base, AV_TIME_BASE_Q) / AV_TIME_BASE; + if (!img->is_pipe) { if (av_get_frame_filename(filename, sizeof(filename), - img->path, img->img_number) < 0 && img->img_number>1 && !img->updatefirst) { + img->path, img->img_number, ts) < 0 && img->img_number>1 && !img->updatefirst) { av_log(s, AV_LOG_ERROR, "Could not get frame filename number %d from pattern '%s'\n", img->img_number, img->path); diff --git a/libavformat/utils.c b/libavformat/utils.c index f0df759..6db2db0 100644 --- a/libavformat/utils.c +++ b/libavformat/utils.c @@ -319,7 +319,7 @@ int av_append_packet(AVIOContext *s, AVPacket *pkt, int size) int av_filename_number_test(const char *filename) { char buf[1024]; - return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0); + return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1, 0)>=0); } AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened, int *score_ret) @@ -3774,15 +3774,16 @@ int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info) #endif int av_get_frame_filename(char *buf, int buf_size, - const char *path, int number) + const char *path, int number, int ts) { const char *p; char *q, buf1[20], c; - int nd, len, percentd_found; + int nd, len, percent_found; + int hours, mins, secs; q = buf; p = path; - percentd_found = 0; + percent_found = 0; for(;;) { c = *p++; if (c == '\0') @@ -3800,9 +3801,9 @@ int av_get_frame_filename(char *buf, int buf_size, case '%': goto addchar; case 'd': - if (percentd_found) + if (percent_found) goto fail; - percentd_found = 1; + percent_found = 1; snprintf(buf1, sizeof(buf1), "%0*d", nd, number); len = strlen(buf1); if ((q - buf + len) > buf_size - 1) @@ -3810,6 +3811,23 @@ int av_get_frame_filename(char *buf, int buf_size, memcpy(q, buf1, len); q += len; break; + case 't': + if (percent_found) + goto fail; + percent_found = 1; + secs = ts % 60; + ts /= 60; + mins = ts % 60; + ts /= 60; + hours = ts; + snprintf(buf1, sizeof(buf1), + "%02d:%02d:%02d", hours, mins, secs); + len = strlen(buf1); + if ((q - buf + len) > buf_size - 1) + goto fail; + memcpy(q, buf1, len); + q += len; + break; default: goto fail; } @@ -3819,7 +3837,7 @@ int av_get_frame_filename(char *buf, int buf_size, *q++ = c; } } - if (!percentd_found) + if (!percent_found) goto fail; *q = '\0'; return 0; -- 1.7.2.2

4 22

[PATCH] Wideband Single-bit Data (WSD) demuxer
by Peter Ross 29 Apr '16

29 Apr '16

Signed-off-by: Peter Ross <pross(a)xvid.org> --- samples: www.acoust.rise.waseda.ac.jp/1bitcons/data.html Changelog | 1 + doc/general.texi | 1 + libavformat/Makefile | 1 + libavformat/allformats.c | 1 + libavformat/wsddec.c | 171 +++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 175 insertions(+) create mode 100644 libavformat/wsddec.c diff --git a/Changelog b/Changelog index 6b46df3..09f015b 100644 --- a/Changelog +++ b/Changelog @@ -18,6 +18,7 @@ version <next>: - alternative rendition support for HTTP Live Streaming - AVFoundation input device - Direct Stream Digital (DSD) decoder +- Wideband Single-bit Data (WSD) demuxer version 2.2: diff --git a/doc/general.texi b/doc/general.texi index 8bf0379..2c9c1b5 100644 --- a/doc/general.texi +++ b/doc/general.texi @@ -470,6 +470,7 @@ library: @tab Multimedia format used in Westwood Studios games. @item Westwood Studios VQA @tab @tab X @tab Multimedia format used in Westwood Studios games. +@item Wideband Single-bit Data (WSD) @tab @tab X @item XMV @tab @tab X @tab Microsoft video container used in Xbox games. @item xWMA @tab @tab X diff --git a/libavformat/Makefile b/libavformat/Makefile index 38b7f9a..ca6820e 100644 --- a/libavformat/Makefile +++ b/libavformat/Makefile @@ -418,6 +418,7 @@ OBJS-$(CONFIG_WEBM_MUXER) += matroskaenc.o matroska.o \ OBJS-$(CONFIG_WEBVTT_DEMUXER) += webvttdec.o subtitles.o OBJS-$(CONFIG_WEBVTT_MUXER) += webvttenc.o OBJS-$(CONFIG_WSAUD_DEMUXER) += westwood_aud.o +OBJS-$(CONFIG_WSD_DEMUXER) += wsddec.o OBJS-$(CONFIG_WSVQA_DEMUXER) += westwood_vqa.o OBJS-$(CONFIG_WTV_DEMUXER) += wtvdec.o wtv_common.o asfdec.o asf.o asfcrypt.o \ avlanguage.o mpegts.o isom.o diff --git a/libavformat/allformats.c b/libavformat/allformats.c index f6d78ae..780019d 100644 --- a/libavformat/allformats.c +++ b/libavformat/allformats.c @@ -305,6 +305,7 @@ void av_register_all(void) REGISTER_MUXER (WEBM, webm); REGISTER_MUXDEMUX(WEBVTT, webvtt); REGISTER_DEMUXER (WSAUD, wsaud); + REGISTER_DEMUXER (WSD, wsd); REGISTER_DEMUXER (WSVQA, wsvqa); REGISTER_MUXDEMUX(WTV, wtv); REGISTER_MUXDEMUX(WV, wv); diff --git a/libavformat/wsddec.c b/libavformat/wsddec.c new file mode 100644 index 0000000..7b127d9 --- /dev/null +++ b/libavformat/wsddec.c @@ -0,0 +1,171 @@ +/* + * Wideband Single-bit Data (WSD) demuxer + * Copyright (c) 2014 Peter Ross + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser 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 "libavutil/intreadwrite.h" +#include "libavutil/timecode.h" +#include "avformat.h" +#include "internal.h" +#include "rawdec.h" + +static int wsd_probe(AVProbeData *p) +{ + if (p->buf_size < 45 || memcmp(p->buf, "1bit", 4) || + !AV_RB32(p->buf + 36) || !p->buf[44] || + (p->buf[0] >= 0x10 && (AV_RB32(p->buf + 20) < 0x80 || AV_RB32(p->buf + 24) < 0x80))) + return 0; + return AVPROBE_SCORE_MAX; +} + +static int empty_string(const char *buf, unsigned size) +{ + while (size--) { + if (*buf++ != ' ') + return 0; + } + return 1; +} + +static int wsd_to_av_channel_layoyt(AVFormatContext *s, int bit) +{ + switch (bit) { + case 2: return AV_CH_BACK_RIGHT; + case 3: + avpriv_request_sample(s, "Rr-middle"); + break; + case 4: return AV_CH_BACK_CENTER; + case 5: + avpriv_request_sample(s, "Lr-middle"); + break; + case 6: return AV_CH_BACK_LEFT; + case 24: return AV_CH_LOW_FREQUENCY; + case 26: return AV_CH_FRONT_RIGHT; + case 27: return AV_CH_FRONT_RIGHT_OF_CENTER; + case 28: return AV_CH_FRONT_CENTER; + case 29: return AV_CH_FRONT_LEFT_OF_CENTER; + case 30: return AV_CH_FRONT_LEFT; + default: + av_log(s, AV_LOG_WARNING, "reserved channel assignment\n"); + break; + } + return 0; +} + +static int get_metadata(AVFormatContext *s, const char *const tag, const unsigned size) +{ + uint8_t *buf; + if (!(size + 1)) + return AVERROR(ENOMEM); + + buf = av_malloc(size + 1); + if (!buf) + return AVERROR(ENOMEM); + + if (avio_read(s->pb, buf, size) != size) { + av_free(buf); + return AVERROR(EIO); + } + + if (empty_string(buf, size)) { + av_free(buf); + return 0; + } + + buf[size] = 0; + av_dict_set(&s->metadata, tag, buf, AV_DICT_DONT_STRDUP_VAL); + return 0; +} + +static int wsd_read_header(AVFormatContext *s) +{ + AVIOContext *pb = s->pb; + AVStream *st; + int version; + uint32_t text_offset, data_offset, channel_assign; + char playback_time[AV_TIMECODE_STR_SIZE]; + + st = avformat_new_stream(s, NULL); + if (!st) + return AVERROR(ENOMEM); + + avio_skip(pb, 8); + version = avio_r8(pb); + av_log(s, AV_LOG_DEBUG, "version: %i.%i\n", version >> 4, version & 0xF); + avio_skip(pb, 11); + + if (version < 0x10) { + text_offset = 0x80; + data_offset = 0x800; + avio_skip(pb, 8); + } else { + text_offset = avio_rb32(pb); + data_offset = avio_rb32(pb); + } + + avio_skip(pb, 4); + av_timecode_make_smpte_tc_string(playback_time, avio_rb32(pb), 0); + av_dict_set(&s->metadata, "playback_time", playback_time, 0); + + st->codec->codec_type = AVMEDIA_TYPE_AUDIO; + st->codec->codec_id = s->iformat->raw_codec_id; + st->codec->sample_rate = avio_rb32(pb) / 8; + avio_skip(pb, 4); + st->codec->channels = avio_r8(pb) & 0xF; + if (!st->codec->channels) + return AVERROR_INVALIDDATA; + + avio_skip(pb, 3); + channel_assign = avio_rb32(pb); + if (!(channel_assign & 1)) { + int i; + for (i = 1; i < 32; i++) + if (channel_assign & (1 << i)) + st->codec->channel_layout |= wsd_to_av_channel_layoyt(s, i); + } + + avio_skip(pb, 16); + if (avio_rb32(pb)) + avpriv_request_sample(s, "emphasis"); + + if (avio_seek(pb, text_offset, SEEK_SET) >= 0) { + get_metadata(s, "title", 128); + get_metadata(s, "composer", 128); + get_metadata(s, "song_writer", 128); + get_metadata(s, "artist", 128); + get_metadata(s, "album", 128); + get_metadata(s, "genre", 32); + get_metadata(s, "date", 32); + get_metadata(s, "location", 32); + get_metadata(s, "comment", 512); + get_metadata(s, "user", 512); + } + + return avio_seek(pb, data_offset, SEEK_SET); +} + +AVInputFormat ff_wsd_demuxer = { + .name = "wsd", + .long_name = NULL_IF_CONFIG_SMALL("Wideband Single-bit Data (WSD)"), + .read_probe = wsd_probe, + .read_header = wsd_read_header, + .read_packet = ff_raw_read_partial_packet, + .flags = AVFMT_GENERIC_INDEX | AVFMT_NO_BYTE_SEEK, + .raw_codec_id = AV_CODEC_ID_DSD_MSBF, +}; -- 1.8.3.2 -- Peter (A907 E02F A6E5 0CD2 34CD 20D2 6760 79C5 AC40 DD6B)

4 6

Re: [FFmpeg-devel] [PATCH] Flush last frame in WMA lossless decoder
by Mashiat Sarker Shakkhar 10 Apr '16

10 Apr '16

On 5/2/2012 11:56 AM, Michael Niedermayer wrote: > On Wed, May 02, 2012 at 03:42:41AM +0600, Mashiat Sarker Shakkhar wrote: >> On 5/2/2012 2:49 AM, Michael Niedermayer wrote: >>> On Sun, Apr 29, 2012 at 10:43:47PM +0200, Jakub Stachowski wrote: >>>> Hello >>>> >>>> Here is cleaned up version of my patches to flush last frames and >>>> skip right number of samples in WMA lossless decoder. This causes >>>> ffmpeg to output the same number of samples as wmal2pcm.exe which I >>>> use as reference. [...] Hi The patch looks OK to the extent of my apprehension. And for the record, I have tested this patch and it fixes luckynight.wma. Patch has cosmetic issues, but that's another matter. Shakkhar P.S. Jakub, why did you use git send-email to send the patch? I tried and failed to review your patch on Gmane.

3 9

[PATCH 1/3] web: In README, CSS generated for ffmpeg repo not merged anymore due to copyright requirements
by db0company 10 Nov '15

10 Nov '15

--- README | 5 +++-- 1 files changed, 3 insertions(+), 2 deletions(-) diff --git a/README b/README index ca70560..5076719 100644 --- a/README +++ b/README @@ -18,8 +18,9 @@ GENERATE THE DOCUMENTATION To generate the documentation pages, just `./generate-doc.sh <ffmpeg-src>`. In case of a major CSS update, please also update the `style.min.css` file in -the main FFmpeg repo: - $ cat /path/to/ffmpeg-web/src/css_credit /path/to/ffmpeg-web/htdocs/css/{bootstrap.min.css,style.min.css} > /path/to/ffmpeg/doc/style.min.css +the main FFmpeg repo + $ cp htdocs/css/{bootstrap.min.css,style.min.css} /path/to/ffmpeg/doc/ + WEBSITE DEVELOPERS INSTRUCTIONS -- 1.7.0.4

5 10

Adding Webvtt in hls muxer
by Anshul 26 Jul '15

26 Jul '15

Hi I have attached the patch. Thanks Anshul Maheshwari

5 12

Windows deprecated stdin reading method
by Peter 24 Jul '15

24 Jul '15

So trying to compile on VS2015 now works fine for the libraries. However the command-line tool does not compile successfully. The issue is this patch https://github.com/FFmpeg/FFmpeg/commit/ca4d71b149ebe32aeaf617ffccf362624b9… which uses a member of the FILE struct which is not available in the new C runtime (it's now just a struct with a void*). I do not quite know the semantics of the stdin->_cnt > 0 check. So I tried a few approaches, like using the deprecated function that is called after the #ifdef block anyway: https://github.com/Bigpet/FFmpeg/commit/b167e17e6f8839e1b4ce0edad2708ff4237… (I'm kind of worried about this since using "read(0, &ch, 1);" instead of "getch" with that if condition actually blocks in some cases, so it's not 100% equivalent) Or trying to understand what the non-deprecated Win32 API calls would look like: https://github.com/Bigpet/FFmpeg/commit/8d9cae13f389ab7dddc736ecac3feb01843… But in the end I don't understand the purpose of the original piece of code, so it's hard to know what it should be replaced by. And finding documentation on it seems fruitless as well, since it used a non-public API to begin with. Any help from people knowledgeable about the windows API would be appreciated.

3 9

[PATCH] Support Ctrl+Break in ffmpeg.exe on Windows as if it was Ctrl+C
by Joe Wreschnig 30 Jun '15

30 Jun '15

On Windows, the Ctrl+Break key combination usually does what Ctrl+C does. It is more common for processes to send other processes Ctrl+Break rather than Ctrl+C, because sending Ctrl+C / SIGINT doesn't work if you started a child in a new process group. This patch makes ffmpeg.exe register what Windows calls a console control event handler, which allows it to intercept Ctrl+Break. It hands it off directly to the usual SIGINT/SIGTERM handler. The same function also processes closing the console window, mapping it to SIGTERM. Obviously, this is only enabled if compiling for a platform where SetConsoleCtrlHandler is available (i.e. modern Windows). (I've also submitted this as a ticket at https://ffmpeg.org/trac/ffmpeg/ticket/1463 but it was recommended I post it here also.)

5 17

[PATCH 1/2] lavfi/ebur128: add support for smaller video sizes
by Marton Balint 27 Jun '15

27 Jun '15

Signed-off-by: Marton Balint <cus(a)passwd.hu> --- doc/filters.texi | 4 ++-- libavfilter/f_ebur128.c | 11 ++++++++--- 2 files changed, 10 insertions(+), 5 deletions(-) diff --git a/doc/filters.texi b/doc/filters.texi index 53f4cb2..713989c 100644 --- a/doc/filters.texi +++ b/doc/filters.texi @@ -10146,8 +10146,8 @@ activated. Default is @code{0}. @item size Set the video size. This option is for video only. For the syntax of this -option, check the "Video size" section in the ffmpeg-utils manual. Default -and minimum resolution is @code{640x480}. +option, check the "Video size" section in the ffmpeg-utils manual. The default +resolution is @code{640x480}, the minimum is @code{480x102}. @item meter Set the EBU scale meter. Default is @code{9}. Common values are @code{9} and diff --git a/libavfilter/f_ebur128.c b/libavfilter/f_ebur128.c index c18ae79..8780062 100644 --- a/libavfilter/f_ebur128.c +++ b/libavfilter/f_ebur128.c @@ -114,6 +114,7 @@ typedef struct { int scale_range; ///< the range of LU values according to the meter int y_zero_lu; ///< the y value (pixel position) for 0 LU int *y_line_ref; ///< y reference values for drawing the LU lines in the graph and the gauge + int line_step; ///< LU steps for drawn lines /* audio */ int nb_channels; ///< number of channels in the input @@ -257,9 +258,9 @@ static int config_video_output(AVFilterLink *outlink) AVFrame *outpicref; /* check if there is enough space to represent everything decently */ - if (ebur128->w < 640 || ebur128->h < 480) { + if (ebur128->w < 480 || ebur128->h < 102) { av_log(ctx, AV_LOG_ERROR, "Video size %dx%d is too small, " - "minimum size is 640x480\n", ebur128->w, ebur128->h); + "minimum size is 480x102\n", ebur128->w, ebur128->h); return AVERROR(EINVAL); } outlink->w = ebur128->w; @@ -285,6 +286,9 @@ static int config_video_output(AVFilterLink *outlink) ebur128->graph.w = ebur128->gauge.x - ebur128->graph.x - PAD; ebur128->graph.h = ebur128->gauge.h; + /* compute line step based on graph height and needed lines */ + ebur128->line_step = (ebur128->scale_range * 8 - 1) / (ebur128->graph.h) + 1; + /* graph and gauge share the LU-to-pixel code */ av_assert0(ebur128->graph.h == ebur128->gauge.h); @@ -309,8 +313,9 @@ static int config_video_output(AVFilterLink *outlink) for (i = ebur128->meter; i >= -ebur128->meter * 2; i--) { y = lu_to_y(ebur128, i); x = PAD + (i < 10 && i > -10) * 8; - ebur128->y_line_ref[y] = i; + ebur128->y_line_ref[y] = ((i % ebur128->line_step == 0) ? i : 0); y -= 4; // -4 to center vertically + if (i % ebur128->line_step == 0) drawtext(outpicref, x, y + ebur128->graph.y, FONT8, font_colors+3, "%c%d", i < 0 ? '-' : i > 0 ? '+' : ' ', FFABS(i)); } -- 2.1.2

4 6

jpeg2000: unsupported marker 0xFF5F at pos 0x73
by Wolfgang Woehl 12 Jun '15

12 Jun '15

See fdfcde74_excerpt_000000-000023 (on ftp://upload.ffmpeg.org/MPlayer/incoming/ as suggested by ffplay). The dir contains a MXF (DCI specs) with 24 4K frames and a 1/4-sized proxy video of that segment. The source MXF is real-world and currently in distribution. It was apparently generated with a Clipster system and asdcp-info says http://pastebin.com/raw.php?i=FFnHrW6K about it. ffplay (3e0c78b as of today) says http://pastebin.com/raw.php?i=df5sJDth when trying to play the excerpt MXF and fails to generate frames -- essentially the same as for the source MXF. Yes, the console output is that garbled. Wolfgang

3 9