March 2014 - ffmpeg-devel - lists.ffmpeg.org

[PATCH 1/3] lavfi/ebur128: add sample and true peak metering.
by Jean First 11 May '14

11 May '14

From: Clément Bœsch <ubitux(a)gmail.com> Metadata injection and logging. Not yet present visually. Signed-off-by: Jean First <jeanfirst(a)gmail.com> --- doc/filters.texi | 21 ++++++++ libavfilter/f_ebur128.c | 140 +++++++++++++++++++++++++++++++++++++++++++----- 2 files changed, 149 insertions(+), 12 deletions(-) diff --git a/doc/filters.texi b/doc/filters.texi index 242602c..d4eca32 100644 --- a/doc/filters.texi +++ b/doc/filters.texi @@ -9308,6 +9308,27 @@ verbose logging level By default, the logging level is set to @var{info}. If the @option{video} or the @option{metadata} options are set, it switches to @var{verbose}. + +@item peak +Set peak mode(s). + +Available modes can be cumulated (the option is a @code{flag} type). Possible +values are: +@table @samp +@item none +Disable any peak mode (default). +@item sample +Enable sample-peak mode. + +Simple peak mode looking for the higher sample value. +@item true +Enable true-peak mode. + +If enabled, the peak lookup is done on an over-sampled version of the input +stream for better peak accuracy. This mode requires a build with +@code{libswresample}. +@end table + @end table @subsection Examples diff --git a/libavfilter/f_ebur128.c b/libavfilter/f_ebur128.c index a2c6160..503d87a 100644 --- a/libavfilter/f_ebur128.c +++ b/libavfilter/f_ebur128.c @@ -37,6 +37,7 @@ #include "libavutil/xga_font_data.h" #include "libavutil/opt.h" #include "libavutil/timestamp.h" +#include "libswresample/swresample.h" #include "audio.h" #include "avfilter.h" #include "formats.h" @@ -92,6 +93,16 @@ struct rect { int x, y, w, h; }; typedef struct { const AVClass *class; ///< AVClass context for log and options purpose + /* peak metering */ + int peak_mode; ///< enabled peak modes + double *true_peaks; ///< true peaks per channel + double *sample_peaks; ///< sample peaks per channel +#if CONFIG_SWRESAMPLE + SwrContext *swr_ctx; ///< over-sampling context for true peak metering + double *swr_buf; ///< resampled audio data for true peak metering + int swr_linesize; +#endif + /* video */ int do_video; ///< 1 if video output enabled, 0 otherwise int w, h; ///< size of the video output @@ -130,6 +141,12 @@ typedef struct { int metadata; ///< whether or not to inject loudness results in frames } EBUR128Context; +enum { + PEAK_MODE_NONE = 0, + PEAK_MODE_SAMPLES_PEAKS = 1<<1, + PEAK_MODE_TRUE_PEAKS = 1<<2, +}; + #define OFFSET(x) offsetof(EBUR128Context, x) #define A AV_OPT_FLAG_AUDIO_PARAM #define V AV_OPT_FLAG_VIDEO_PARAM @@ -142,7 +159,11 @@ static const AVOption ebur128_options[] = { { "info", "information logging level", 0, AV_OPT_TYPE_CONST, {.i64 = AV_LOG_INFO}, INT_MIN, INT_MAX, A|V|F, "level" }, { "verbose", "verbose logging level", 0, AV_OPT_TYPE_CONST, {.i64 = AV_LOG_VERBOSE}, INT_MIN, INT_MAX, A|V|F, "level" }, { "metadata", "inject metadata in the filtergraph", OFFSET(metadata), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, A|V|F }, - { NULL } + { "peak", "set peak mode", OFFSET(peak_mode), AV_OPT_TYPE_FLAGS, {.i64 = PEAK_MODE_NONE}, 0, INT_MAX, A|F, "mode" }, + { "none", "disable any peak mode", 0, AV_OPT_TYPE_CONST, {.i64 = PEAK_MODE_NONE}, INT_MIN, INT_MAX, A|F, "mode" }, + { "sample", "enable peak-sample mode", 0, AV_OPT_TYPE_CONST, {.i64 = PEAK_MODE_SAMPLES_PEAKS}, INT_MIN, INT_MAX, A|F, "mode" }, + { "true", "enable true-peak mode", 0, AV_OPT_TYPE_CONST, {.i64 = PEAK_MODE_TRUE_PEAKS}, INT_MIN, INT_MAX, A|F, "mode" }, + { NULL }, }; AVFILTER_DEFINE_CLASS(ebur128); @@ -326,9 +347,13 @@ static int config_audio_input(AVFilterLink *inlink) AVFilterContext *ctx = inlink->dst; EBUR128Context *ebur128 = ctx->priv; - /* force 100ms framing in case of metadata injection: the frames must have - * a granularity of the window overlap to be accurately exploited */ - if (ebur128->metadata) + /* Force 100ms framing in case of metadata injection: the frames must have + * a granularity of the window overlap to be accurately exploited. + * As for the true peaks mode, it just simplifies the resampling buffer + * allocation and the lookup in it (since sample buffers differ in size, it + * can be more complex to integrate in the one-sample loop of + * filter_frame()). */ + if (ebur128->metadata || (ebur128->peak_mode & PEAK_MODE_TRUE_PEAKS)) inlink->min_samples = inlink->max_samples = inlink->partial_buf_size = inlink->sample_rate / 10; @@ -383,6 +408,36 @@ static int config_audio_output(AVFilterLink *outlink) outlink->flags |= FF_LINK_FLAG_REQUEST_LOOP; +#if CONFIG_SWRESAMPLE + if (ebur128->peak_mode & PEAK_MODE_TRUE_PEAKS) { + int ret; + + ebur128->swr_buf = av_malloc(19200 * nb_channels * sizeof(double)); + ebur128->true_peaks = av_calloc(nb_channels, sizeof(*ebur128->true_peaks)); + ebur128->swr_ctx = swr_alloc(); + if (!ebur128->swr_buf || !ebur128->true_peaks || !ebur128->swr_ctx) + return AVERROR(ENOMEM); + + av_opt_set_int(ebur128->swr_ctx, "in_channel_layout", outlink->channel_layout, 0); + av_opt_set_int(ebur128->swr_ctx, "in_sample_rate", outlink->sample_rate, 0); + av_opt_set_sample_fmt(ebur128->swr_ctx, "in_sample_fmt", outlink->format, 0); + + av_opt_set_int(ebur128->swr_ctx, "out_channel_layout", outlink->channel_layout, 0); + av_opt_set_int(ebur128->swr_ctx, "out_sample_rate", 192000, 0); + av_opt_set_sample_fmt(ebur128->swr_ctx, "out_sample_fmt", outlink->format, 0); + + ret = swr_init(ebur128->swr_ctx); + if (ret < 0) + return ret; + } +#endif + + if (ebur128->peak_mode & PEAK_MODE_SAMPLES_PEAKS) { + ebur128->sample_peaks = av_calloc(nb_channels, sizeof(*ebur128->sample_peaks)); + if (!ebur128->sample_peaks) + return AVERROR(ENOMEM); + } + return 0; } @@ -416,6 +471,12 @@ static av_cold int init(AVFilterContext *ctx) ebur128->loglevel = AV_LOG_INFO; } + if (!CONFIG_SWRESAMPLE && (ebur128->peak_mode & PEAK_MODE_TRUE_PEAKS)) { + av_log(ctx, AV_LOG_ERROR, + "True-peak mode requires libswresample to be performed\n"); + return AVERROR(EINVAL); + } + // if meter is +9 scale, scale range is from -18 LU to +9 LU (or 3*9) // if meter is +18 scale, scale range is from -36 LU to +18 LU (or 3*18) ebur128->scale_range = 3 * ebur128->meter; @@ -491,6 +552,22 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *insamples) const double *samples = (double *)insamples->data[0]; AVFrame *pic = ebur128->outpicref; +#if CONFIG_SWRESAMPLE + if (ebur128->peak_mode & PEAK_MODE_TRUE_PEAKS) { + const double *swr_samples = ebur128->swr_buf; + int ret = swr_convert(ebur128->swr_ctx, (uint8_t**)&ebur128->swr_buf, 19200, + (const uint8_t **)insamples->data, nb_samples); + if (ret < 0) + return ret; + for (idx_insample = 0; idx_insample < ret; idx_insample++) { + for (ch = 0; ch < nb_channels; ch++) { + ebur128->true_peaks[ch] = FFMAX(ebur128->true_peaks[ch], FFABS(*swr_samples)); + swr_samples++; + } + } + } +#endif + for (idx_insample = 0; idx_insample < nb_samples; idx_insample++) { const int bin_id_400 = ebur128->i400.cache_pos; const int bin_id_3000 = ebur128->i3000.cache_pos; @@ -509,6 +586,9 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *insamples) for (ch = 0; ch < nb_channels; ch++) { double bin; + if (ebur128->peak_mode & PEAK_MODE_SAMPLES_PEAKS) + ebur128->sample_peaks[ch] = FFMAX(ebur128->sample_peaks[ch], FFABS(*samples)); + ebur128->x[ch * 3] = *samples++; // set X[i] if (!ebur128->ch_weighting[ch]) @@ -677,22 +757,52 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *insamples) if (ebur128->metadata) { /* happens only once per filter_frame call */ char metabuf[128]; +#define META_PREFIX "lavfi.r128." + #define SET_META(name, var) do { \ snprintf(metabuf, sizeof(metabuf), "%.3f", var); \ - av_dict_set(&insamples->metadata, "lavfi.r128." name, metabuf, 0); \ + av_dict_set(&insamples->metadata, name, metabuf, 0); \ } while (0) - SET_META("M", loudness_400); - SET_META("S", loudness_3000); - SET_META("I", ebur128->integrated_loudness); - SET_META("LRA", ebur128->loudness_range); - SET_META("LRA.low", ebur128->lra_low); - SET_META("LRA.high", ebur128->lra_high); + +#define SET_META_PEAK(name, ptype) do { \ + if (ebur128->peak_mode & PEAK_MODE_ ## ptype ## _PEAKS) { \ + char key[64]; \ + for (ch = 0; ch < nb_channels; ch++) { \ + snprintf(key, sizeof(key), \ + META_PREFIX AV_STRINGIFY(name) "_peaks_ch%d", ch); \ + SET_META(key, ebur128->name##_peaks[ch]); \ + } \ + } \ +} while (0) + + SET_META(META_PREFIX "M", loudness_400); + SET_META(META_PREFIX "S", loudness_3000); + SET_META(META_PREFIX "I", ebur128->integrated_loudness); + SET_META(META_PREFIX "LRA", ebur128->loudness_range); + SET_META(META_PREFIX "LRA.low", ebur128->lra_low); + SET_META(META_PREFIX "LRA.high", ebur128->lra_high); + + SET_META_PEAK(sample, SAMPLES); + SET_META_PEAK(true, TRUE); } - av_log(ctx, ebur128->loglevel, "t: %-10s " LOG_FMT "\n", + av_log(ctx, ebur128->loglevel, "t: %-10s " LOG_FMT, av_ts2timestr(pts, &outlink->time_base), loudness_400, loudness_3000, ebur128->integrated_loudness, ebur128->loudness_range); + +#define PRINT_PEAKS(str, sp, ptype) do { \ + if (ebur128->peak_mode & PEAK_MODE_ ## ptype ## _PEAKS) { \ + av_log(ctx, ebur128->loglevel, " [" str ":"); \ + for (ch = 0; ch < nb_channels; ch++) \ + av_log(ctx, ebur128->loglevel, " %.5f", sp[ch]); \ + av_log(ctx, ebur128->loglevel, "]"); \ + } \ +} while (0) + + PRINT_PEAKS("SPK", ebur128->sample_peaks, SAMPLES); + PRINT_PEAKS("TPK", ebur128->true_peaks, TRUE); + av_log(ctx, ebur128->loglevel, "\n"); } } @@ -764,6 +874,8 @@ static av_cold void uninit(AVFilterContext *ctx) av_freep(&ebur128->y_line_ref); av_freep(&ebur128->ch_weighting); + av_freep(&ebur128->true_peaks); + av_freep(&ebur128->sample_peaks); av_freep(&ebur128->i400.histogram); av_freep(&ebur128->i3000.histogram); for (i = 0; i < ebur128->nb_channels; i++) { @@ -773,6 +885,10 @@ static av_cold void uninit(AVFilterContext *ctx) for (i = 0; i < ctx->nb_outputs; i++) av_freep(&ctx->output_pads[i].name); av_frame_free(&ebur128->outpicref); +#if CONFIG_SWRESAMPLE + av_freep(&ebur128->swr_buf); + swr_free(&ebur128->swr_ctx); +#endif } static const AVFilterPad ebur128_inputs[] = { -- 1.7.12.4 (Apple Git-37)

3 5

[PATCH] rtpdec: make the NTP time values unsigned.
by flameeyes＠gmail.com 09 May '14

09 May '14

As per RFC3550, section 4, the NTP time is provided as 64-bit unsigned integer, so follow the same logic here. --- libavformat/rtpdec.h | 4 ++-- 1 files changed, 2 insertions(+), 2 deletions(-) diff --git a/libavformat/rtpdec.h b/libavformat/rtpdec.h index 86af2b9..87fd419 100644 --- a/libavformat/rtpdec.h +++ b/libavformat/rtpdec.h @@ -148,8 +148,8 @@ struct RTPDemuxContext { RTPStatistics statistics; ///< Statistics for this stream (used by RTCP receiver reports) /* rtcp sender statistics receive */ - int64_t last_rtcp_ntp_time; // TODO: move into statistics - int64_t first_rtcp_ntp_time; // TODO: move into statistics + uint64_t last_rtcp_ntp_time; // TODO: move into statistics + uint64_t first_rtcp_ntp_time; // TODO: move into statistics uint32_t last_rtcp_timestamp; // TODO: move into statistics /* rtcp sender statistics */ -- 1.7.1.1

4 3

Patch: Inline asm fixes for Intel compiler on Windows
by Matt Oliver 04 May '14

04 May '14

Hey, I made a patch that changes some of the inline asm found in FFmpeg so that it will compile under windows natively using the Intel compiler. The Intel compiler supports AT&T inline assembly syntax but doesnt have all the functionality that GAS has. A result is that a few things need to be slightly tweaked. Mostly this just involves changing direct symbol references to asm-interfaces. The attached patch should not change the functionality of FFmpeg in any way as it just changes the syntax of some instructions so that it will compile. That said there are a few sections where the code required slightly more complicated changes in order to work. These are x86/cabac.h in the BRANCHLESS_GET_CABAC macro and mlpdsp.c. The macro in cabac.h just requires some slightly more complicated asm-interface conversions that someone more familiar with the code may want to have a look at. mlpdsp.c uses some runtime jump lists that would require an almost complete rewrite to work on Intel which is probably not worth it. So at the moment both of these are simply skipped if the Intel compile is detected. All other asm works fine though. Code was compiled on Windows in Intel and using gcc 4.8 to ensure compatibility. All code was tested and past FATE. Matt

7 115

[PATCH] avcodec/h264: mark recovery_cnt==0 frames as keyframes
by Michael Niedermayer 03 May '14

03 May '14

Fixes Ticket3063 Signed-off-by: Michael Niedermayer <michaelni(a)gmx.at> --- libavcodec/h264.c | 4 ++++ libavcodec/mpegvideo.h | 1 + 2 files changed, 5 insertions(+) diff --git a/libavcodec/h264.c b/libavcodec/h264.c index d0d32d3..06a9453 100644 --- a/libavcodec/h264.c +++ b/libavcodec/h264.c @@ -365,6 +365,7 @@ static int ref_picture(H264Context *h, Picture *dst, Picture *src) dst->crop_left = src->crop_left; dst->crop_top = src->crop_top; dst->recovered = src->recovered; + dst->sei_recovery_frame_cnt = src->sei_recovery_frame_cnt; return 0; fail: @@ -1963,6 +1964,7 @@ static int h264_frame_start(H264Context *h) pic->f.key_frame = 0; pic->mmco_reset = 0; pic->recovered = 0; + pic->sei_recovery_frame_cnt = h->sei_recovery_frame_cnt; if ((ret = alloc_picture(h, pic)) < 0) return ret; @@ -5043,6 +5045,8 @@ static int output_frame(H264Context *h, AVFrame *dst, Picture *srcp) av_dict_set(&dst->metadata, "stereo_mode", ff_h264_sei_stereo_mode(h), 0); + if (srcp->sei_recovery_frame_cnt == 0) + dst->key_frame = 1; if (!srcp->crop) return 0; diff --git a/libavcodec/mpegvideo.h b/libavcodec/mpegvideo.h index 8ba1321..66449ae 100644 --- a/libavcodec/mpegvideo.h +++ b/libavcodec/mpegvideo.h @@ -177,6 +177,7 @@ typedef struct Picture{ int reference; int shared; int recovered; ///< Picture at IDR or recovery point + recovery count + int sei_recovery_frame_cnt; int crop; int crop_left; -- 1.7.9.5

2 2

[PATCH 1/3] ff_put_wav_header: remove manual byte counting
by Daniel Verkamp 30 Apr '14

30 Apr '14

--- libavformat/riffenc.c | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/libavformat/riffenc.c b/libavformat/riffenc.c index 2af2b7f..c3e3e66 100644 --- a/libavformat/riffenc.c +++ b/libavformat/riffenc.c @@ -54,7 +54,8 @@ void ff_end_tag(AVIOContext *pb, int64_t start) int ff_put_wav_header(AVIOContext *pb, AVCodecContext *enc) { int bps, blkalign, bytespersec, frame_size; - int hdrsize = 18; + int hdrsize; + int64_t hdrstart = avio_tell(pb); int waveformatextensible; uint8_t temp[256]; uint8_t *riff_extradata = temp; @@ -135,14 +136,12 @@ int ff_put_wav_header(AVIOContext *pb, AVCodecContext *enc) avio_wl16(pb, blkalign); /* block align */ avio_wl16(pb, bps); /* bits per sample */ if (enc->codec_id == AV_CODEC_ID_MP3) { - hdrsize += 12; bytestream_put_le16(&riff_extradata, 1); /* wID */ bytestream_put_le32(&riff_extradata, 2); /* fdwFlags */ bytestream_put_le16(&riff_extradata, 1152); /* nBlockSize */ bytestream_put_le16(&riff_extradata, 1); /* nFramesPerBlock */ bytestream_put_le16(&riff_extradata, 1393); /* nCodecDelay */ } else if (enc->codec_id == AV_CODEC_ID_MP2) { - hdrsize += 22; /* fwHeadLayer */ bytestream_put_le16(&riff_extradata, 2); /* dwHeadBitrate */ @@ -160,23 +159,19 @@ int ff_put_wav_header(AVIOContext *pb, AVCodecContext *enc) /* dwPTSHigh */ bytestream_put_le32(&riff_extradata, 0); } else if (enc->codec_id == AV_CODEC_ID_G723_1) { - hdrsize += 20; bytestream_put_le32(&riff_extradata, 0x9ace0002); /* extradata needed for msacm g723.1 codec */ bytestream_put_le32(&riff_extradata, 0xaea2f732); bytestream_put_le16(&riff_extradata, 0xacde); } else if (enc->codec_id == AV_CODEC_ID_GSM_MS || enc->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV) { - hdrsize += 2; /* wSamplesPerBlock */ bytestream_put_le16(&riff_extradata, frame_size); } else if (enc->extradata_size) { riff_extradata_start = enc->extradata; riff_extradata = enc->extradata + enc->extradata_size; - hdrsize += enc->extradata_size; } /* write WAVEFORMATEXTENSIBLE extensions */ if (waveformatextensible) { - hdrsize += 22; /* 22 is WAVEFORMATEXTENSIBLE size */ avio_wl16(pb, riff_extradata - riff_extradata_start + 22); /* ValidBitsPerSample || SamplesPerBlock || Reserved */ @@ -196,6 +191,7 @@ int ff_put_wav_header(AVIOContext *pb, AVCodecContext *enc) avio_wl16(pb, riff_extradata - riff_extradata_start); /* cbSize */ } avio_write(pb, riff_extradata_start, riff_extradata - riff_extradata_start); + hdrsize = avio_tell(pb) - hdrstart; if (hdrsize & 1) { hdrsize++; avio_w8(pb, 0); -- 1.9.0

5 20

[PATCH] Add log severity level to default log formatting
by hjiodjf 97xgw46 30 Apr '14

30 Apr '14

This patch adds the severity of log events to the default format string. Currently, it is not possible to distinguish info/warning/error/fatal messages if coloring is not enabled.

5 12

[PATCH] doc/examples/muxing: make compatible with C++
by Michael Niedermayer 29 Apr '14

29 Apr '14

Signed-off-by: Michael Niedermayer <michaelni(a)gmx.at> --- doc/examples/muxing.c | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/doc/examples/muxing.c b/doc/examples/muxing.c index ad8e027..4e1d72b 100644 --- a/doc/examples/muxing.c +++ b/doc/examples/muxing.c @@ -29,6 +29,11 @@ * @example muxing.c */ +#ifdef __cplusplus + extern "C" { +#endif +#define __STDC_FORMAT_MACROS +#define __STDC_CONSTANT_MACROS #include <stdlib.h> #include <stdio.h> #include <string.h> @@ -40,6 +45,9 @@ #include <libavformat/avformat.h> #include <libswscale/swscale.h> #include <libswresample/swresample.h> +#ifdef __cplusplus + } // extern "C" +#endif static int audio_is_eof, video_is_eof; @@ -63,8 +71,8 @@ static void log_packet(const AVFormatContext *fmt_ctx, const AVPacket *pkt) static int write_frame(AVFormatContext *fmt_ctx, const AVRational *time_base, AVStream *st, AVPacket *pkt) { /* rescale output packet timestamp values from codec to stream timebase */ - pkt->pts = av_rescale_q_rnd(pkt->pts, *time_base, st->time_base, AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX); - pkt->dts = av_rescale_q_rnd(pkt->dts, *time_base, st->time_base, AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX); + pkt->pts = av_rescale_q_rnd(pkt->pts, *time_base, st->time_base, (enum AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX)); + pkt->dts = av_rescale_q_rnd(pkt->dts, *time_base, st->time_base, (enum AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX)); pkt->duration = av_rescale_q(pkt->duration, *time_base, st->time_base); pkt->stream_index = st->index; -- 1.7.9.5

10 41

[PATCH] ffmpeg: print an error at the end if convertion failed
by Michael Niedermayer 28 Apr '14

28 Apr '14

Fixes Ticket3477 Signed-off-by: Michael Niedermayer <michaelni(a)gmx.at> --- ffmpeg.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ffmpeg.c b/ffmpeg.c index 25001f5..d6ef4e9 100644 --- a/ffmpeg.c +++ b/ffmpeg.c @@ -516,6 +516,8 @@ static void ffmpeg_cleanup(int ret) if (received_sigterm) { av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n", (int) received_sigterm); + } else if (ret) { + av_log(NULL, AV_LOG_INFO, "Convertion failed!\n"); } term_exit(); } -- 1.7.9.5

3 4

[PATCH] Add support for drawing PTS in HHMMSSms format to vf_drawtext
by hjiodjf 97xgw46 25 Apr '14

25 Apr '14

There is support in vf_drawtext to draw the video time as SMPTE timestamp. However, no corresponding support exists for wall time. This patch adds to vf_drawtext a "timecodems" argument with similar syntax to the "timecode" argument.

2 4

[PATCH 1/2] lavu: add thread message API.
by Nicolas George 22 Apr '14

22 Apr '14

TODO minor bump and APIchanges entry. Signed-off-by: Nicolas George <george(a)nsup.org> --- libavutil/Makefile | 2 + libavutil/threadmessage.c | 172 ++++++++++++++++++++++++++++++++++++++++++++++ libavutil/threadmessage.h | 92 +++++++++++++++++++++++++ 3 files changed, 266 insertions(+) create mode 100644 libavutil/threadmessage.c create mode 100644 libavutil/threadmessage.h diff --git a/libavutil/Makefile b/libavutil/Makefile index e4ee47c..4b173d8 100644 --- a/libavutil/Makefile +++ b/libavutil/Makefile @@ -50,6 +50,7 @@ HEADERS = adler32.h \ sha.h \ sha512.h \ stereo3d.h \ + threadmessage.h \ time.h \ timecode.h \ timestamp.h \ @@ -115,6 +116,7 @@ OBJS = adler32.o \ sha.o \ sha512.o \ stereo3d.o \ + threadmessage.o \ time.o \ timecode.o \ tree.o \ diff --git a/libavutil/threadmessage.c b/libavutil/threadmessage.c new file mode 100644 index 0000000..5389246 --- /dev/null +++ b/libavutil/threadmessage.c @@ -0,0 +1,172 @@ +/* + * Copyright (c) 2014 Nicolas George + * + * 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 <pthread.h> +#include "fifo.h" +#include "threadmessage.h" + +#include <pthread.h> +#include "fifo.h" + +struct AVThreadMessageQueue { + AVFifoBuffer *fifo; + pthread_mutex_t lock; + pthread_cond_t cond; + int err_send; + int err_recv; + unsigned elsize; +}; + +int av_thread_message_queue_alloc(AVThreadMessageQueue **mq, + unsigned elsize, + unsigned nelem) +{ +#if HAVE_THREADS + AVThreadMessageQueue *rmq; + int ret = 0; + + if (nelem > INT_MAX / elsize) + return AVERROR(EINVAL); + if (!(rmq = av_mallocz(sizeof(*rmq)))) + return AVERROR(ENOMEM); + if ((ret = pthread_mutex_init(&rmq->lock, NULL))) { + av_free(rmq); + return AVERROR(ret); + } + if ((ret = pthread_cond_init(&rmq->cond, NULL))) { + pthread_mutex_destroy(&rmq->lock); + av_free(rmq); + return AVERROR(ret); + } + if (!(rmq->fifo = av_fifo_alloc(elsize * nelem))) { + pthread_cond_destroy(&rmq->cond); + pthread_mutex_destroy(&rmq->lock); + av_free(rmq); + return AVERROR(ret); + } + rmq->elsize = elsize; + *mq = rmq; + return 0; +#else + return AVERROR(ENOSYS); +#endif /* HAVE_THREADS */ +} + +void av_thread_message_queue_free(AVThreadMessageQueue **mq) +{ + if (*mq) { + av_fifo_free((*mq)->fifo); +#if HAVE_THREADS + pthread_cond_destroy(&(*mq)->cond); + pthread_mutex_destroy(&(*mq)->lock); +#endif + av_freep(mq); + } +} + +#if HAVE_THREADS + +static int av_thread_message_queue_send_locked(AVThreadMessageQueue *mq, + void *msg, + unsigned flags) +{ + while (!mq->err_send && av_fifo_space(mq->fifo) < mq->elsize) { + if ((flags & AV_THREAD_MESSAGE_NONBLOCK)) + return AVERROR(EAGAIN); + pthread_cond_wait(&mq->cond, &mq->lock); + } + if (mq->err_send) + return mq->err_send; + av_fifo_generic_write(mq->fifo, msg, mq->elsize, NULL); + pthread_cond_signal(&mq->cond); + return 0; +} + +static int av_thread_message_queue_recv_locked(AVThreadMessageQueue *mq, + void *msg, + unsigned flags) +{ + while (!mq->err_recv && av_fifo_size(mq->fifo) < mq->elsize) { + if ((flags & AV_THREAD_MESSAGE_NONBLOCK)) + return AVERROR(EAGAIN); + pthread_cond_wait(&mq->cond, &mq->lock); + } + if (av_fifo_size(mq->fifo) < mq->elsize) + return mq->err_recv; + av_fifo_generic_read(mq->fifo, msg, mq->elsize, NULL); + pthread_cond_signal(&mq->cond); + return 0; +} + +#endif /* HAVE_THREADS */ + +int av_thread_message_queue_send(AVThreadMessageQueue *mq, + void *msg, + unsigned flags) +{ +#if HAVE_THREADS + int ret; + + pthread_mutex_lock(&mq->lock); + ret = av_thread_message_queue_send_locked(mq, msg, flags); + pthread_mutex_unlock(&mq->lock); + return ret; +#else + return AVERROR(ENOSYS); +#endif /* HAVE_THREADS */ +} + +int av_thread_message_queue_recv(AVThreadMessageQueue *mq, + void *msg, + unsigned flags) +{ +#if HAVE_THREADS + int ret; + + pthread_mutex_lock(&mq->lock); + ret = av_thread_message_queue_recv_locked(mq, msg, flags); + pthread_mutex_unlock(&mq->lock); + return ret; +#else + return AVERROR(ENOSYS); +#endif /* HAVE_THREADS */ +} + +void av_thread_message_queue_set_err_send(AVThreadMessageQueue *mq, + int err) +{ +#if HAVE_THREADS + pthread_mutex_lock(&mq->lock); + mq->err_send = err; + pthread_cond_broadcast(&mq->cond); + pthread_mutex_unlock(&mq->lock); +#endif /* HAVE_THREADS */ +} + +void av_thread_message_queue_set_err_recv(AVThreadMessageQueue *mq, + int err) +{ +#if HAVE_THREADS + pthread_mutex_lock(&mq->lock); + mq->err_recv = err; + pthread_cond_broadcast(&mq->cond); + pthread_mutex_unlock(&mq->lock); +#endif /* HAVE_THREADS */ +} diff --git a/libavutil/threadmessage.h b/libavutil/threadmessage.h new file mode 100644 index 0000000..0c77bcf --- /dev/null +++ b/libavutil/threadmessage.h @@ -0,0 +1,92 @@ +/* + * 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 + */ + +#ifndef AVUTIL_THREADMESSAGE_H +#define AVUTIL_THREADMESSAGE_H + +#include <pthread.h> +#include "fifo.h" + +typedef struct AVThreadMessageQueue AVThreadMessageQueue; + +typedef enum AVThreadMessageFlags { + + /** + * Perform non-blocking operation. + * If this flag is set, send and recv operations are non-blocking and + * return AVERROR(EAGAIN) immediately if they can not proceed. + */ + AV_THREAD_MESSAGE_NONBLOCK = 1, + +} AVThreadMessageFlags; + +/** + * Allocate a new message queue. + * + * @param mq pointer to the message queue + * @param elsize size of each element in the queue + * @param nelem minimum number of elements in the queue + * @return >=0 for success; <0 for error, in particular AVERROR(ENOSYS) if + * lavu was built without thread support + */ +int av_thread_message_queue_alloc(AVThreadMessageQueue **mq, + unsigned elsize, + unsigned nelem); + +/** + * Free a message queue. + */ +void av_thread_message_queue_free(AVThreadMessageQueue **mq); + +/** + * Send a message on the queue. + */ +int av_thread_message_queue_send(AVThreadMessageQueue *mq, + void *msg, + unsigned flags); + +/** + * Receive a message from the queue. + */ +int av_thread_message_queue_recv(AVThreadMessageQueue *mq, + void *msg, + unsigned flags); + +/** + * Set the sending error code. + * + * If the error code is set to non-zero, av_thread_message_queue_recv() will + * return it immediately when there are no longer available messages. + * Conventional values, such as AVERROR_EOF or AVERROR(EAGAIN), can be used + * to cause the receiving thread to stop or suspend its operation. + */ +void av_thread_message_queue_set_err_send(AVThreadMessageQueue *mq, + int err); + +/** + * Set the receiving error code. + * + * If the error code is set to non-zero, av_thread_message_queue_send() will + * return it immediately. Conventional values, such as AVERROR_EOF or + * AVERROR(EAGAIN), can be used to cause the sending thread to stop or + * suspend its operation. + */ +void av_thread_message_queue_set_err_recv(AVThreadMessageQueue *mq, + int err); + +#endif /* AVUTIL_THREADMESSAGE_H */ -- 1.8.5.3

4 17