ffserver.c/lmhttp.c/publisher.c/publisher.h: Adopt new AVFifo API in favor of deprecated AVFifoBuffer API.

Signed-off-by: Stephan Holljes <[email protected]>

Author: klaxa

ffserver.c

@@ -367,14 +367,14 @@ void write_segment(struct Client *c)
     int pkt_count = 0;
     AVRational tb = {1, AV_TIME_BASE};
     pthread_mutex_lock(&c->buffer_lock);
-    if (av_fifo_size(c->buffer) > 0) {
+    if (av_fifo_can_read(c->buffer)) {
         AVFormatContext *fmt_ctx;
         AVIOContext *avio_ctx;
         AVPacket pkt;
         struct SegmentReadInfo info;
         unsigned char *avio_buffer;
 
-        av_fifo_generic_peek(c->buffer, &seg, sizeof(seg), NULL);
+        av_fifo_peek(c->buffer, &seg, 1, 0);
         pthread_mutex_unlock(&c->buffer_lock);
         c->current_segment_id = seg->id;
         info.buf = seg->buf;
@@ -453,7 +453,7 @@ void write_segment(struct Client *c)
         avformat_close_input(&fmt_ctx);
         avio_context_free(&avio_ctx);
         pthread_mutex_lock(&c->buffer_lock);
-        av_fifo_drain(c->buffer, sizeof(seg));
+        av_fifo_drain2(c->buffer, 1);
         pthread_mutex_unlock(&c->buffer_lock);
         segment_unref(seg);
         client_set_state(c, WRITABLE);

lmhttpd.c

@@ -40,11 +40,11 @@
 
 struct MHDServer {
     struct MHD_Daemon *daemon;
-    AVFifoBuffer *clients;
+    AVFifo *clients;
 };
 
 struct ConnectionInfo {
-    AVFifoBuffer *buffer;
+    AVFifo *buffer;
     pthread_mutex_t buffer_lock;
     struct MHD_Connection *connection;
     int close_connection;
@@ -59,15 +59,15 @@ ssize_t helper_callback(void *cls, uint64_t pos, char *buf, size_t max)
 {
     struct ConnectionInfo *cinfo = (struct ConnectionInfo*) cls;
     pthread_mutex_lock(&cinfo->buffer_lock);
-    int buf_size = av_fifo_size(cinfo->buffer);
+    int buf_size = av_fifo_can_read(cinfo->buffer);
     if (buf_size > 0) {
         max = max > buf_size ? buf_size : max;
-        av_fifo_generic_read(cinfo->buffer, buf, max, NULL);
+        av_fifo_read(cinfo->buffer, buf, max);
     } else {
         max = 0;
     }
     if (max == 0 && cinfo->close_connection) {
-        av_fifo_free(cinfo->buffer);
+        av_fifo_freep2(&cinfo->buffer);
         pthread_mutex_unlock(&cinfo->buffer_lock);
         av_free(cinfo);
         return MHD_CONTENT_READER_END_OF_STREAM;
@@ -123,8 +123,8 @@ static enum MHD_Result answer_to_connection (void *cls, struct MHD_Connection *c
     // no locking needed, running on the same thread
 
     if (!strcmp("GET", method)) {
-        if (av_fifo_space(server->clients) > sizeof(struct HTTPClient*)) {
-            cinfo->buffer = av_fifo_alloc(INITIAL_BUFSIZE);
+        if (av_fifo_can_write(server->clients) > sizeof(struct HTTPClient*)) {
+            cinfo->buffer = av_fifo_alloc2(INITIAL_BUFSIZE, 1, 0);
             cinfo->connection = connection;
             cinfo->close_connection = 0;
 
@@ -134,7 +134,7 @@ static enum MHD_Result answer_to_connection (void *cls, struct MHD_Connection *c
             client->resource = av_strdup(url);
             client->method = av_strdup(method);
             client->httpd_data = cinfo;
-            av_fifo_generic_write(server->clients, &client, sizeof(struct HTTPClient*), NULL);
+            av_fifo_write(server->clients, &client, 1);
         }
         response = MHD_create_response_from_callback(MHD_SIZE_UNKNOWN,
                                                     1024,
@@ -166,7 +166,7 @@ int lmhttpd_init(void **server, struct HTTPDConfig config) {
         av_log(NULL, AV_LOG_ERROR, "Could not allocate MHDServer struct\n");
         return -1;
     }
-    server_p->clients = av_fifo_alloc_array(sizeof(struct HTTPClient), MAX_CLIENTS);
+    server_p->clients = av_fifo_alloc2(MAX_CLIENTS, sizeof(struct HTTPClient), 0);
     server_p->daemon = MHD_start_daemon (0, config.port, NULL, NULL,
                              &answer_to_connection, server_p, MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 10, MHD_OPTION_END);
     if (!server_p->daemon || !server_p->clients) {
@@ -208,8 +208,8 @@ int lmhttpd_accept(void *server, struct HTTPClient **client, const char **valid_
     // run read and write operations
     if (MHD_run_from_select(s->daemon, &rs, &ws, &es) != MHD_YES)
         return HTTPD_OTHER_ERROR;
-    if(av_fifo_size(s->clients)) {
-        av_fifo_generic_read(s->clients, client, sizeof(struct HTTPClient*), NULL);
+    if(av_fifo_can_read(s->clients)) {
+        av_fifo_read(s->clients, client, 1);
 
         return 0;
     }
@@ -225,8 +225,8 @@ int lmhttpd_write(void *server, struct HTTPClient *client, const unsigned char *
     struct ConnectionInfo* cinfo = (struct ConnectionInfo*) client->httpd_data;
     int ret;
     pthread_mutex_lock(&cinfo->buffer_lock);
-    if (!cinfo->close_connection && av_fifo_space(cinfo->buffer) >= size) {
-        ret = av_fifo_generic_write(cinfo->buffer, (void*) buf, size, NULL);
+    if (!cinfo->close_connection && av_fifo_can_write(cinfo->buffer) >= size) {
+        ret = av_fifo_write(cinfo->buffer, (void*) buf, size);
 
     } else {
         ret = -1;
@@ -296,7 +296,7 @@ void lmhttpd_shutdown(void *server)
     }
 
     MHD_stop_daemon(mhd_server->daemon);
-    av_fifo_free(mhd_server->clients);
+    av_fifo_freep2(&mhd_server->clients);
     av_free(mhd_server);
 }
 

publisher.c

@@ -62,8 +62,8 @@ void client_disconnect(struct Client *c, int write_trailer)
     c->ofmt_ctx = NULL;
     c->ffinfo = NULL;
     pthread_mutex_lock(&c->buffer_lock);
-    while(av_fifo_size(c->buffer)) {
-        av_fifo_generic_read(c->buffer, &seg, sizeof(struct Segment*), NULL);
+    while(av_fifo_can_read(c->buffer)) {
+        av_fifo_read(c->buffer, &seg, 1);
         segment_unref(seg);
     }
     pthread_mutex_unlock(&c->buffer_lock);
@@ -81,14 +81,14 @@ void client_set_state(struct Client *c, enum State state)
 void client_push_segment(struct Client *c, struct Segment *seg)
 {
     pthread_mutex_lock(&c->buffer_lock);
-    if (av_fifo_space(c->buffer) == 0) {
+    if (av_fifo_can_write(c->buffer) == 0) {
         av_log(NULL, AV_LOG_WARNING, "Client buffer full, dropping Segment.\n");
         client_set_state(c, BUFFER_FULL);
         pthread_mutex_unlock(&c->buffer_lock);
         return;
     }
     segment_ref(seg);
-    av_fifo_generic_write(c->buffer, &seg, sizeof(struct Segment*), NULL);
+    av_fifo_write(c->buffer, &seg, 1);
     pthread_mutex_unlock(&c->buffer_lock);
     client_set_state(c, WRITABLE);
 }
@@ -105,24 +105,24 @@ void publisher_init(struct PublisherContext **pub, char *stream_name)
     pc->stream_name = stream_name;
     pc->current_segment_id = -1;
     pc->shutdown = 0;
-    pc->buffer = av_fifo_alloc_array(sizeof(struct Segment), MAX_SEGMENTS);
+    pc->buffer = av_fifo_alloc2(MAX_SEGMENTS, sizeof(struct Segment*), 0);
     if (!pc->buffer) {
         av_log(NULL, AV_LOG_ERROR, "Could not allocate publisher buffer.\n");
         av_free(pc);
         return;
     }
-    pc->fs_buffer = av_fifo_alloc_array(sizeof(struct Segment), MAX_SEGMENTS);
+    pc->fs_buffer = av_fifo_alloc2(MAX_SEGMENTS, sizeof(struct Segment*), 0);
     if (!pc->fs_buffer) {
         av_log(NULL, AV_LOG_ERROR, "Could not allocate publisher fast-start buffer.\n");
-        av_fifo_free(pc->buffer);
+        av_fifo_freep2(&pc->buffer);
         av_free(pc);
         return;
     }
     pthread_mutex_init(&pc->buffer_lock, NULL);
     pthread_mutex_init(&pc->fs_buffer_lock, NULL);
     for (i = 0; i < MAX_CLIENTS; i++) {
         struct Client *c = &pc->clients[i];
-        c->buffer = av_fifo_alloc_array(sizeof(struct Segment), MAX_SEGMENTS);
+        c->buffer = av_fifo_alloc2(MAX_SEGMENTS, sizeof(struct Segment*), 0);
         if (!c->buffer) {
             av_log(NULL, AV_LOG_ERROR, "Could not allocate client buffer.\n");
             publisher_free(pc);
@@ -144,13 +144,13 @@ void publisher_push_segment(struct PublisherContext *pub, struct Segment *seg)
     struct Segment *drop;
     pthread_mutex_lock(&pub->buffer_lock);
     pthread_mutex_lock(&pub->fs_buffer_lock);
-    av_fifo_generic_write(pub->buffer, &seg, sizeof(struct Segment*), NULL);
+    av_fifo_write(pub->buffer, &seg, 1);
     segment_ref(seg);
-    if (av_fifo_size(pub->fs_buffer) >= BUFFER_SEGMENTS * sizeof(struct Segment*)) {
-        av_fifo_generic_read(pub->fs_buffer, &drop, sizeof(struct Segment*), NULL);
+    if (av_fifo_can_read(pub->fs_buffer) >= BUFFER_SEGMENTS) {
+        av_fifo_read(pub->fs_buffer, &drop, 1);
         segment_unref(drop);
     }
-    av_fifo_generic_write(pub->fs_buffer, &seg, sizeof(struct Segment*), NULL);
+    av_fifo_write(pub->fs_buffer, &seg, 1);
     pthread_mutex_unlock(&pub->buffer_lock);
     pthread_mutex_unlock(&pub->fs_buffer_lock);
     segment_ref(seg);
@@ -192,9 +192,9 @@ void client_push_prebuffer(struct PublisherContext *pub, struct Client *c)
     int size;
     struct Segment *seg;
     pthread_mutex_lock(&pub->fs_buffer_lock);
-    size = av_fifo_size(pub->fs_buffer);
-    for (off = 0; off < size; off += sizeof(struct Segment*)) {
-        av_fifo_generic_peek_at(pub->fs_buffer, &seg, off, sizeof(struct Segment*), NULL);
+    size = av_fifo_can_read(pub->fs_buffer);
+    for (off = 0; off < size; off++) {
+        av_fifo_peek(pub->fs_buffer, &seg, 1, off);
         client_push_segment(c, seg);
     }
     pthread_mutex_unlock(&pub->fs_buffer_lock);
@@ -222,21 +222,21 @@ void publisher_free(struct PublisherContext *pub)
     int i;
     struct Segment *seg;
     pthread_mutex_lock(&pub->buffer_lock);
-    while(av_fifo_size(pub->buffer)) {
-        av_fifo_generic_read(pub->buffer, &seg, sizeof(struct Segment*), NULL);
+    while(av_fifo_can_read(pub->buffer)) {
+        av_fifo_read(pub->buffer, &seg, 1);
         segment_unref(seg);
     }
-    av_fifo_freep(&pub->buffer);
+    av_fifo_freep2(&pub->buffer);
     pthread_mutex_unlock(&pub->buffer_lock);
-    
+
     pthread_mutex_lock(&pub->fs_buffer_lock);
-    while(av_fifo_size(pub->fs_buffer)) {
-        av_fifo_generic_read(pub->fs_buffer, &seg, sizeof(struct Segment*), NULL);
+    while(av_fifo_can_read(pub->fs_buffer)) {
+        av_fifo_read(pub->fs_buffer, &seg, 1);
         segment_unref(seg);
     }
-    av_fifo_freep(&pub->fs_buffer);
+    av_fifo_freep2(&pub->fs_buffer);
     for (i = 0; i < MAX_CLIENTS; i++) {
-        av_fifo_freep(&pub->clients[i].buffer);
+        av_fifo_freep2(&pub->clients[i].buffer);
     }
     pthread_mutex_unlock(&pub->fs_buffer_lock);
     av_free(pub);
@@ -256,18 +256,18 @@ void publish(struct PublisherContext *pub)
     struct Segment *seg;
     char filename[128] = {0};
     pthread_mutex_lock(&pub->buffer_lock);
-    av_log(NULL, AV_LOG_DEBUG, "pub->buffer size: %d\n", av_fifo_size(pub->buffer));
-    if (av_fifo_size(pub->buffer) == 0) {
+    av_log(NULL, AV_LOG_DEBUG, "pub->buffer size: %ld\n", av_fifo_can_read(pub->buffer));
+    if (av_fifo_can_read(pub->buffer) == 0) {
         pthread_mutex_unlock(&pub->buffer_lock);
         return;
     }
-    av_fifo_generic_read(pub->buffer, &seg, sizeof(struct Segment*), NULL);
+    av_fifo_read(pub->buffer, &seg, 1);
     pthread_mutex_unlock(&pub->buffer_lock);
     if (seg) {
         pub->current_segment_id = seg->id;
         snprintf(filename, 127, "segment-%04d.mkv", seg->id);
 //        segment_save(seg, filename);
-        
+
         for (i = 0; i < MAX_CLIENTS; i++) {
             switch(pub->clients[i].state) {
                 case BUFFER_FULL:
@@ -304,7 +304,7 @@ void publisher_gen_status_json(struct PublisherContext *pub, char *status)
         }
         states[c->state]++;
     }
-    
+
 
     snprintf(status, 4095,
     "{\n\t\"free\": %d,\n"

publisher.h

@@ -44,7 +44,7 @@ enum State {
 
 struct Client {
     AVFormatContext *ofmt_ctx; // writable AVFormatContext, basically our tcp connection to the client
-    AVFifoBuffer *buffer; // Client buffer of Segment references
+    AVFifo *buffer; // Client buffer of Segment references
     char *method;
     char *resource;
     struct FFServerInfo *ffinfo;
@@ -57,8 +57,8 @@ struct Client {
 
 struct PublisherContext {
     struct Client clients[MAX_CLIENTS]; // currently compile-time configuration, easly made dynamic with malloc?
-    AVFifoBuffer *buffer; // publisher buffer for new Segments
-    AVFifoBuffer *fs_buffer; // fast start buffer
+    AVFifo *buffer; // publisher buffer for new Segments
+    AVFifo *fs_buffer; // fast start buffer
     pthread_mutex_t buffer_lock;
     pthread_mutex_t fs_buffer_lock;
     int nb_threads;