[FFmpeg-devel] [PATCH 07/35] lavu/fifo: add new FIFO writing functions

[Andreas Rheinhardt]

Anton Khirnov:
> Use separate functions for writing from a buffer and a callback, since
> the overwhelming majority of callers use a buffer and should not be
> forced to pass extra NULL parameters or use a longer name.
> 
> Consistently use size_t for sizes.
> ---
>  doc/APIchanges   |  2 +-
>  libavutil/fifo.c | 58 ++++++++++++++++++++++++++++++++++++++++++++++++
>  libavutil/fifo.h | 46 ++++++++++++++++++++++++++++++++++++++
>  3 files changed, 105 insertions(+), 1 deletion(-)
> 
> diff --git a/doc/APIchanges b/doc/APIchanges
> index f2769d4165..0b179c30e5 100644
> --- a/doc/APIchanges
> +++ b/doc/APIchanges
> @@ -19,7 +19,7 @@ API changes, most recent first:
>    Operations on FIFOs created with this function on these elements
>    rather than bytes.
>    Add av_fifo_elem_size(), av_fifo_can_read(), av_fifo_can_write(),
> -  av_fifo_grow2(), av_fifo_drain2().
> +  av_fifo_grow2(), av_fifo_drain2(), av_fifo_write(), av_fifo_write_from_cb().
>  
>  2022-01-xx - xxxxxxxxxx - lavu fifo.h
>    Access to all AVFifoBuffer members is deprecated. The struct will
> diff --git a/libavutil/fifo.c b/libavutil/fifo.c
> index e9f439e219..1d94fff457 100644
> --- a/libavutil/fifo.c
> +++ b/libavutil/fifo.c
> @@ -207,6 +207,64 @@ void av_fifo_drain2(AVFifoBuffer *f, size_t size)
>  #endif
>  }
>  
> +static int fifo_write_common(AVFifoBuffer *f, const uint8_t *buf, size_t *nb_elems,
> +                             AVFifoCB read_cb, void *opaque)

Should be write_cb.

> +{
> +    FifoBuffer  *fb = (FifoBuffer*)f;
> +    size_t to_write = *nb_elems;

How about calling this "left"?

> +    size_t offset_w = fb->offset_w;
> +    int         ret = 0;
> +#if FF_API_FIFO_PUBLIC
> +    uint32_t wndx= f->wndx;
> +#endif
> +
> +    if (to_write > av_fifo_can_write(f))
> +        return AVERROR(ENOSPC);
> +
> +    do {
> +        size_t    len = FFMIN(fb->nb_elems - offset_w, to_write);
> +        uint8_t *wptr = f->buffer + offset_w * fb->elem_size;
> +
> +        if (read_cb) {
> +            ret = read_cb(opaque, wptr, &len);
> +            if (ret < 0 || len == 0)
> +                break;
> +        } else {
> +            memcpy(wptr, buf, len * fb->elem_size);
> +            buf += len * fb->elem_size;
> +        }
> +        offset_w += len;
> +        if (offset_w >= fb->nb_elems)
> +            offset_w = 0;
> +#if FF_API_FIFO_PUBLIC
> +        wndx    += len;
> +#endif
> +        to_write    -= len;
> +    } while (to_write > 0);
> +#if FF_API_FIFO_PUBLIC
> +    f->wndx= wndx;
> +    f->wptr= f->buffer + offset_w * fb->elem_size;
> +#endif
> +    fb->offset_w = offset_w;
> +
> +    if (*nb_elems - to_write > 0)

to_write < *nb_elems

> +        fb->is_empty = 0;
> +    *nb_elems -= to_write;
> +
> +    return ret;
> +}
> +
> +int av_fifo_write(AVFifoBuffer *f, const void *buf, size_t nb_elems)
> +{
> +    return fifo_write_common(f, buf, &nb_elems, NULL, NULL);
> +}
> +
> +int av_fifo_write_from_cb(AVFifoBuffer *f, AVFifoCB read_cb,
> +                          void *opaque, size_t *nb_elems)
> +{
> +    return fifo_write_common(f, NULL, nb_elems, read_cb, opaque);
> +}
> +
>  int av_fifo_realloc2(AVFifoBuffer *f, unsigned int new_size)
>  {
>      FifoBuffer *fb = (FifoBuffer*)f;
> diff --git a/libavutil/fifo.h b/libavutil/fifo.h
> index d593304edb..ac1245ff39 100644
> --- a/libavutil/fifo.h
> +++ b/libavutil/fifo.h
> @@ -44,6 +44,24 @@ typedef struct AVFifoBuffer
>  #endif
>  AVFifoBuffer;
>  
> +/**
> + * Callback for writing or reading from a FIFO, passed to (and invoked from) the
> + * av_fifo_*_cb() functions. It may be invoked multiple times from a single
> + * av_fifo_*_cb() call and may process less data than the maximum size indicated
> + * by nb_elems.
> + *
> + * @param opaque the opaque pointer provided to the av_fifo_*_cb() function
> + * @param buf the buffer for reading or writing the data, depending on which
> + *            av_fifo_*_cb function is called
> + * @param nb_elems On entry contains the maximum number of elements that can be
> + *                 read from / written into buf. On success, the callback should
> + *                 update it to contain the number of elements actually written.

The last sentence is write-only, although this callback is also used for
reading.

> + *
> + * @return 0 on success, a negative error code on failure (will be returned from
> + *         the invoking av_fifo_*_cb() function)
> + */
> +typedef int AVFifoCB(void *opaque, void *buf, size_t *nb_elems);
> +
>  /**
>   * Initialize an AVFifoBuffer.
>   * @param size of FIFO
> @@ -143,6 +161,34 @@ size_t av_fifo_can_write(const AVFifoBuffer *f);
>   */
>  int av_fifo_grow2(AVFifoBuffer *f, size_t inc);
>  
> +/**
> + * Write data into a FIFO.
> + *
> + * @param f the FIFO buffer
> + * @param buf Data to be written. nb_elems * av_fifo_elem_size(f) bytes will be
> + *            read from buf.
> + * @param nb_elems number of elements to write into FIFO
> + *
> + * @return a non-negative number on success, a negative error code on failure
> + */
> +int av_fifo_write(AVFifoBuffer *f, const void *buf, size_t nb_elems);
> +
> +/**
> + * Write data from a user-provided callback into a FIFO.
> + *
> + * @param f the FIFO buffer
> + * @param read_cb Callback supplying the data to the FIFO. May be called
> + *                multiple times.
> + * @param opaque opaque user data to be provided to read_cb
> + * @param nb_elems Should point to the maximum number of elements that can be
> + *                 written. Will be updated to contain the number of elements
> + *                 actually written.
> + *
> + * @return non-negative number on success, a negative error code on failure
> + */
> +int av_fifo_write_from_cb(AVFifoBuffer *f, AVFifoCB read_cb,

s/read_cb/write_cb/
(also above)

> +                          void *opaque, size_t *nb_elems);
> +
>  /**
>   * Discard the specified amount of data from an AVFifoBuffer.
>   * @param size number of elements to discard, MUST NOT be larger than
>