diff mbox series

[FFmpeg-devel,26/35] lavf/udp: switch to new FIFO API

Message ID 20220111204610.14262-26-anton@khirnov.net
State New
Headers show
Series [FFmpeg-devel,01/35] lavu/fifo: disallow overly large fifo sizes | expand

Checks

Context Check Description
andriy/configurex86 warning Failed to apply patch
andriy/configureppc warning Failed to apply patch
andriy/configureaarch64_jetson warning Failed to apply patch

Commit Message

Anton Khirnov Jan. 11, 2022, 8:46 p.m. UTC
---
 libavformat/udp.c | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

Comments

Andreas Rheinhardt Jan. 13, 2022, 6:45 p.m. UTC | #1
Anton Khirnov:
> ---
>  libavformat/udp.c | 28 ++++++++++++++--------------
>  1 file changed, 14 insertions(+), 14 deletions(-)
> 
> diff --git a/libavformat/udp.c b/libavformat/udp.c
> index 83c042d079..4c8f104d9d 100644
> --- a/libavformat/udp.c
> +++ b/libavformat/udp.c
> @@ -500,7 +500,7 @@ static void *circular_buffer_task_rx( void *_URLContext)
>              continue;
>          AV_WL32(s->tmp, len);
>  
> -        if(av_fifo_space(s->fifo) < len + 4) {
> +        if (av_fifo_can_write(s->fifo) < len + 4) {
>              /* No Space left */
>              if (s->overrun_nonfatal) {
>                  av_log(h, AV_LOG_WARNING, "Circular buffer overrun. "
> @@ -514,7 +514,7 @@ static void *circular_buffer_task_rx( void *_URLContext)
>                  goto end;
>              }
>          }
> -        av_fifo_generic_write(s->fifo, s->tmp, len+4, NULL);
> +        av_fifo_write(s->fifo, s->tmp, len + 4);
>          pthread_cond_signal(&s->cond);
>      }
>  
> @@ -548,22 +548,22 @@ static void *circular_buffer_task_tx( void *_URLContext)
>          uint8_t tmp[4];
>          int64_t timestamp;
>  
> -        len = av_fifo_size(s->fifo);
> +        len = av_fifo_can_read(s->fifo);

len should be made size_t (although the values always fit into an int).

>  
>          while (len<4) {
>              if (s->close_req)
>                  goto end;
>              pthread_cond_wait(&s->cond, &s->mutex);
> -            len = av_fifo_size(s->fifo);
> +            len = av_fifo_can_read(s->fifo);
>          }
>  
> -        av_fifo_generic_read(s->fifo, tmp, 4, NULL);
> +        av_fifo_read(s->fifo, tmp, 4);
>          len = AV_RL32(tmp);
>  
>          av_assert0(len >= 0);
>          av_assert0(len <= sizeof(s->tmp));
>  
> -        av_fifo_generic_read(s->fifo, s->tmp, len, NULL);
> +        av_fifo_read(s->fifo, s->tmp, len);
>  
>          pthread_mutex_unlock(&s->mutex);
>  
> @@ -906,7 +906,7 @@ static int udp_open(URLContext *h, const char *uri, int flags)
>  
>      if ((!is_output && s->circular_buffer_size) || (is_output && s->bitrate && s->circular_buffer_size)) {
>          /* start the task going */
> -        s->fifo = av_fifo_alloc(s->circular_buffer_size);
> +        s->fifo = av_fifo_alloc2(s->circular_buffer_size, 1, 0);
>          if (!s->fifo) {
>              ret = AVERROR(ENOMEM);
>              goto fail;
> @@ -970,19 +970,19 @@ static int udp_read(URLContext *h, uint8_t *buf, int size)
>      if (s->fifo) {
>          pthread_mutex_lock(&s->mutex);
>          do {
> -            avail = av_fifo_size(s->fifo);
> +            avail = av_fifo_can_read(s->fifo);
>              if (avail) { // >=size) {
>                  uint8_t tmp[4];
>  
> -                av_fifo_generic_read(s->fifo, tmp, 4, NULL);
> +                av_fifo_read(s->fifo, tmp, 4);
>                  avail = AV_RL32(tmp);
>                  if(avail > size){
>                      av_log(h, AV_LOG_WARNING, "Part of datagram lost due to insufficient buffer size\n");
>                      avail = size;
>                  }
>  
> -                av_fifo_generic_read(s->fifo, buf, avail, NULL);
> -                av_fifo_drain(s->fifo, AV_RL32(tmp) - avail);
> +                av_fifo_read(s->fifo, buf, avail);
> +                av_fifo_drain2(s->fifo, AV_RL32(tmp) - avail);
>                  pthread_mutex_unlock(&s->mutex);
>                  return avail;
>              } else if(s->circular_buffer_error){
> @@ -1043,14 +1043,14 @@ static int udp_write(URLContext *h, const uint8_t *buf, int size)
>              return err;
>          }
>  
> -        if(av_fifo_space(s->fifo) < size + 4) {
> +        if (av_fifo_can_write(s->fifo) < size + 4) {
>              /* What about a partial packet tx ? */
>              pthread_mutex_unlock(&s->mutex);
>              return AVERROR(ENOMEM);
>          }
>          AV_WL32(tmp, size);
> -        av_fifo_generic_write(s->fifo, tmp, 4, NULL); /* size of packet */
> -        av_fifo_generic_write(s->fifo, (uint8_t *)buf, size, NULL); /* the data */
> +        av_fifo_write(s->fifo, tmp, 4); /* size of packet */
> +        av_fifo_write(s->fifo, (uint8_t *)buf, size); /* the data */

The cast can now be dropped.

>          pthread_cond_signal(&s->cond);
>          pthread_mutex_unlock(&s->mutex);
>          return size;
>
diff mbox series

Patch

diff --git a/libavformat/udp.c b/libavformat/udp.c
index 83c042d079..4c8f104d9d 100644
--- a/libavformat/udp.c
+++ b/libavformat/udp.c
@@ -500,7 +500,7 @@  static void *circular_buffer_task_rx( void *_URLContext)
             continue;
         AV_WL32(s->tmp, len);
 
-        if(av_fifo_space(s->fifo) < len + 4) {
+        if (av_fifo_can_write(s->fifo) < len + 4) {
             /* No Space left */
             if (s->overrun_nonfatal) {
                 av_log(h, AV_LOG_WARNING, "Circular buffer overrun. "
@@ -514,7 +514,7 @@  static void *circular_buffer_task_rx( void *_URLContext)
                 goto end;
             }
         }
-        av_fifo_generic_write(s->fifo, s->tmp, len+4, NULL);
+        av_fifo_write(s->fifo, s->tmp, len + 4);
         pthread_cond_signal(&s->cond);
     }
 
@@ -548,22 +548,22 @@  static void *circular_buffer_task_tx( void *_URLContext)
         uint8_t tmp[4];
         int64_t timestamp;
 
-        len = av_fifo_size(s->fifo);
+        len = av_fifo_can_read(s->fifo);
 
         while (len<4) {
             if (s->close_req)
                 goto end;
             pthread_cond_wait(&s->cond, &s->mutex);
-            len = av_fifo_size(s->fifo);
+            len = av_fifo_can_read(s->fifo);
         }
 
-        av_fifo_generic_read(s->fifo, tmp, 4, NULL);
+        av_fifo_read(s->fifo, tmp, 4);
         len = AV_RL32(tmp);
 
         av_assert0(len >= 0);
         av_assert0(len <= sizeof(s->tmp));
 
-        av_fifo_generic_read(s->fifo, s->tmp, len, NULL);
+        av_fifo_read(s->fifo, s->tmp, len);
 
         pthread_mutex_unlock(&s->mutex);
 
@@ -906,7 +906,7 @@  static int udp_open(URLContext *h, const char *uri, int flags)
 
     if ((!is_output && s->circular_buffer_size) || (is_output && s->bitrate && s->circular_buffer_size)) {
         /* start the task going */
-        s->fifo = av_fifo_alloc(s->circular_buffer_size);
+        s->fifo = av_fifo_alloc2(s->circular_buffer_size, 1, 0);
         if (!s->fifo) {
             ret = AVERROR(ENOMEM);
             goto fail;
@@ -970,19 +970,19 @@  static int udp_read(URLContext *h, uint8_t *buf, int size)
     if (s->fifo) {
         pthread_mutex_lock(&s->mutex);
         do {
-            avail = av_fifo_size(s->fifo);
+            avail = av_fifo_can_read(s->fifo);
             if (avail) { // >=size) {
                 uint8_t tmp[4];
 
-                av_fifo_generic_read(s->fifo, tmp, 4, NULL);
+                av_fifo_read(s->fifo, tmp, 4);
                 avail = AV_RL32(tmp);
                 if(avail > size){
                     av_log(h, AV_LOG_WARNING, "Part of datagram lost due to insufficient buffer size\n");
                     avail = size;
                 }
 
-                av_fifo_generic_read(s->fifo, buf, avail, NULL);
-                av_fifo_drain(s->fifo, AV_RL32(tmp) - avail);
+                av_fifo_read(s->fifo, buf, avail);
+                av_fifo_drain2(s->fifo, AV_RL32(tmp) - avail);
                 pthread_mutex_unlock(&s->mutex);
                 return avail;
             } else if(s->circular_buffer_error){
@@ -1043,14 +1043,14 @@  static int udp_write(URLContext *h, const uint8_t *buf, int size)
             return err;
         }
 
-        if(av_fifo_space(s->fifo) < size + 4) {
+        if (av_fifo_can_write(s->fifo) < size + 4) {
             /* What about a partial packet tx ? */
             pthread_mutex_unlock(&s->mutex);
             return AVERROR(ENOMEM);
         }
         AV_WL32(tmp, size);
-        av_fifo_generic_write(s->fifo, tmp, 4, NULL); /* size of packet */
-        av_fifo_generic_write(s->fifo, (uint8_t *)buf, size, NULL); /* the data */
+        av_fifo_write(s->fifo, tmp, 4); /* size of packet */
+        av_fifo_write(s->fifo, (uint8_t *)buf, size); /* the data */
         pthread_cond_signal(&s->cond);
         pthread_mutex_unlock(&s->mutex);
         return size;