LCOV - code coverage report
Current view: top level - libavformat/tests - fifo_muxer.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 75 125 60.0 %
Date: 2018-04-21 10:11:13 Functions: 6 6 100.0 %

          Line data    Source code
       1             : /*
       2             :  * FIFO pseudo-muxer
       3             :  * Copyright (c) 2016 Jan Sebechlebsky
       4             :  *
       5             :  * This file is part of FFmpeg.
       6             :  *
       7             :  * FFmpeg is free software; you can redistribute it and/or
       8             :  * modify it under the terms of the GNU Lesser General Public License
       9             :  * as published by the Free Software Foundation; either
      10             :  * version 2.1 of the License, or (at your option) any later version.
      11             :  *
      12             :  * FFmpeg is distributed in the hope that it will be useful,
      13             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15             :  * GNU Lesser General Public License for more details.
      16             :  *
      17             :  * You should have received a copy of the GNU Lesser General Public License
      18             :  * along with FFmpeg; if not, write to the Free Software * Foundation, Inc.,
      19             :  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      20             :  */
      21             : 
      22             : #include <stdlib.h>
      23             : #include "libavutil/opt.h"
      24             : #include "libavutil/time.h"
      25             : #include "libavutil/avassert.h"
      26             : #include "libavformat/avformat.h"
      27             : #include "libavformat/url.h"
      28             : #include "libavformat/network.h"
      29             : 
      30             : #define MAX_TST_PACKETS 128
      31             : #define SLEEPTIME_50_MS 50000
      32             : #define SLEEPTIME_10_MS 10000
      33             : 
      34             : /* This is structure of data sent in packets to
      35             :  * failing muxer */
      36             : typedef struct FailingMuxerPacketData {
      37             :     int ret;             /* return value of write_packet call*/
      38             :     int recover_after;   /* set ret to zero after this number of recovery attempts */
      39             :     unsigned sleep_time; /* sleep for this long in write_packet to simulate long I/O operation */
      40             : } FailingMuxerPacketData;
      41             : 
      42          51 : static int prepare_packet(AVPacket *pkt, const FailingMuxerPacketData *pkt_data, int64_t pts)
      43             : {
      44             :     int ret;
      45          51 :     FailingMuxerPacketData *data = av_malloc(sizeof(*data));
      46          51 :     if (!data) {
      47           0 :         return AVERROR(ENOMEM);
      48             :     }
      49          51 :     memcpy(data, pkt_data, sizeof(FailingMuxerPacketData));
      50          51 :     ret = av_packet_from_data(pkt, (uint8_t*) data, sizeof(*data));
      51             : 
      52          51 :     pkt->pts = pkt->dts = pts;
      53          51 :     pkt->duration = 1;
      54             : 
      55          51 :     return ret;
      56             : }
      57             : 
      58           4 : static int initialize_fifo_tst_muxer_chain(AVFormatContext **oc)
      59             : {
      60           4 :     int ret = 0;
      61             :     AVStream *s;
      62             : 
      63           4 :     ret = avformat_alloc_output_context2(oc, NULL, "fifo", "-");
      64           4 :     if (ret) {
      65           0 :         fprintf(stderr, "Failed to create format context: %s\n",
      66           0 :                 av_err2str(ret));
      67           0 :         return EXIT_FAILURE;
      68             :     }
      69             : 
      70           4 :     s = avformat_new_stream(*oc, NULL);
      71           4 :     if (!s) {
      72           0 :         fprintf(stderr, "Failed to create stream: %s\n",
      73           0 :                 av_err2str(ret));
      74           0 :         ret = AVERROR(ENOMEM);
      75             :     }
      76             : 
      77           4 :     return ret;
      78             : }
      79             : 
      80           3 : static int fifo_basic_test(AVFormatContext *oc, AVDictionary **opts,
      81             :                              const FailingMuxerPacketData *pkt_data)
      82             : {
      83           3 :     int ret = 0, i;
      84             :     AVPacket pkt;
      85             : 
      86           3 :     av_init_packet(&pkt);
      87             : 
      88             : 
      89           3 :     ret = avformat_write_header(oc, opts);
      90           3 :     if (ret) {
      91           0 :         fprintf(stderr, "Unexpected write_header failure: %s\n",
      92           0 :                 av_err2str(ret));
      93           0 :         goto fail;
      94             :     }
      95             : 
      96          48 :     for (i = 0; i < 15; i++ ) {
      97          45 :         ret = prepare_packet(&pkt, pkt_data, i);
      98          45 :         if (ret < 0) {
      99           0 :             fprintf(stderr, "Failed to prepare test packet: %s\n",
     100           0 :                     av_err2str(ret));
     101           0 :             goto write_trailer_and_fail;
     102             :         }
     103          45 :         ret = av_write_frame(oc, &pkt);
     104          45 :         av_packet_unref(&pkt);
     105          45 :         if (ret < 0) {
     106           0 :             fprintf(stderr, "Unexpected write_frame error: %s\n",
     107           0 :                     av_err2str(ret));
     108           0 :             goto write_trailer_and_fail;
     109             :         }
     110             :     }
     111             : 
     112           3 :     ret = av_write_frame(oc, NULL);
     113           3 :     if (ret < 0) {
     114           0 :         fprintf(stderr, "Unexpected write_frame error during flushing: %s\n",
     115           0 :                 av_err2str(ret));
     116           0 :         goto write_trailer_and_fail;
     117             :     }
     118             : 
     119           3 :     ret = av_write_trailer(oc);
     120           3 :     if (ret < 0) {
     121           0 :         fprintf(stderr, "Unexpected write_trailer error during flushing: %s\n",
     122           0 :                 av_err2str(ret));
     123           0 :         goto fail;
     124             :     }
     125             : 
     126           3 :     return ret;
     127           0 : write_trailer_and_fail:
     128           0 :     av_write_trailer(oc);
     129           0 : fail:
     130           0 :     return ret;
     131             : }
     132             : 
     133           1 : static int fifo_overflow_drop_test(AVFormatContext *oc, AVDictionary **opts,
     134             :                                    const FailingMuxerPacketData *data)
     135             : {
     136           1 :     int ret = 0, i;
     137             :     int64_t write_pkt_start, write_pkt_end, duration;
     138             :     AVPacket pkt;
     139             : 
     140           1 :     av_init_packet(&pkt);
     141             : 
     142           1 :     ret = avformat_write_header(oc, opts);
     143           1 :     if (ret) {
     144           0 :         fprintf(stderr, "Unexpected write_header failure: %s\n",
     145           0 :                 av_err2str(ret));
     146           0 :         return ret;
     147             :     }
     148             : 
     149           1 :     write_pkt_start = av_gettime_relative();
     150           7 :     for (i = 0; i < 6; i++ ) {
     151           6 :         ret = prepare_packet(&pkt, data, i);
     152           6 :         if (ret < 0) {
     153           0 :             fprintf(stderr, "Failed to prepare test packet: %s\n",
     154           0 :                     av_err2str(ret));
     155           0 :             goto fail;
     156             :         }
     157           6 :         ret = av_write_frame(oc, &pkt);
     158           6 :         av_packet_unref(&pkt);
     159           6 :         if (ret < 0) {
     160           0 :             break;
     161             :         }
     162             :     }
     163           1 :     write_pkt_end = av_gettime_relative();
     164           1 :     duration = write_pkt_end - write_pkt_start;
     165           1 :     if (duration > (SLEEPTIME_50_MS*6)/2) {
     166           0 :         fprintf(stderr, "Writing packets to fifo muxer took too much time while testing"
     167             :                         "buffer overflow with drop_pkts_on_overflow was on.\n");
     168           0 :         ret = AVERROR_BUG;
     169           0 :         goto fail;
     170             :     }
     171             : 
     172           1 :     if (ret) {
     173           0 :         fprintf(stderr, "Unexpected write_packet error: %s\n", av_err2str(ret));
     174           0 :         goto fail;
     175             :     }
     176             : 
     177           1 :     ret = av_write_trailer(oc);
     178           1 :     if (ret < 0)
     179           0 :         fprintf(stderr, "Unexpected write_trailer error: %s\n", av_err2str(ret));
     180             : 
     181           1 :     return ret;
     182           0 : fail:
     183           0 :     av_write_trailer(oc);
     184           0 :     return ret;
     185             : }
     186             : 
     187             : typedef struct TestCase {
     188             :     int (*test_func)(AVFormatContext *, AVDictionary **,const FailingMuxerPacketData *pkt_data);
     189             :     const char *test_name;
     190             :     const char *options;
     191             : 
     192             :     uint8_t print_summary_on_deinit;
     193             :     int write_header_ret;
     194             :     int write_trailer_ret;
     195             : 
     196             :     FailingMuxerPacketData pkt_data;
     197             : } TestCase;
     198             : 
     199             : 
     200             : #define BUFFER_SIZE 64
     201             : 
     202           4 : static int run_test(const TestCase *test)
     203             : {
     204           4 :     AVDictionary *opts = NULL;
     205           4 :     AVFormatContext *oc = NULL;
     206             :     char buffer[BUFFER_SIZE];
     207             :     int ret, ret1;
     208             : 
     209           4 :     ret = initialize_fifo_tst_muxer_chain(&oc);
     210           4 :     if (ret < 0) {
     211           0 :         fprintf(stderr, "Muxer initialization failed: %s\n", av_err2str(ret));
     212           0 :         goto end;
     213             :     }
     214             : 
     215           4 :     if (test->options) {
     216           3 :         ret = av_dict_parse_string(&opts, test->options, "=", ":", 0);
     217           3 :         if (ret < 0) {
     218           0 :             fprintf(stderr, "Failed to parse options: %s\n", av_err2str(ret));
     219           0 :             goto end;
     220             :         }
     221             :     }
     222             : 
     223           8 :     snprintf(buffer, BUFFER_SIZE,
     224             :              "print_deinit_summary=%d:write_header_ret=%d:write_trailer_ret=%d",
     225           4 :              (int)test->print_summary_on_deinit, test->write_header_ret,
     226             :              test->write_trailer_ret);
     227           4 :     ret = av_dict_set(&opts, "format_opts", buffer, 0);
     228           4 :     ret1 = av_dict_set(&opts, "fifo_format", "fifo_test", 0);
     229           4 :     if (ret < 0 || ret1 < 0) {
     230           0 :         fprintf(stderr, "Failed to set options for test muxer: %s\n",
     231           0 :                 av_err2str(ret));
     232           0 :         goto end;
     233             :     }
     234             : 
     235           4 :     ret = test->test_func(oc, &opts, &test->pkt_data);
     236             : 
     237           4 : end:
     238           4 :     printf("%s: %s\n", test->test_name, ret < 0 ? "fail" : "ok");
     239           4 :     avformat_free_context(oc);
     240           4 :     av_dict_free(&opts);
     241           4 :     return ret;
     242             : }
     243             : 
     244             : 
     245             : const TestCase tests[] = {
     246             :         /* Simple test in packet-non-dropping mode, we expect to get on the output
     247             :          * exactly what was on input */
     248             :         {fifo_basic_test, "nonfail test", NULL,1, 0, 0, {0, 0, 0}},
     249             : 
     250             :         /* Each write_packet will fail 3 times before operation is successful. If recovery
     251             :          * Since recovery is on, fifo muxer should not return any errors. */
     252             :         {fifo_basic_test, "recovery test", "attempt_recovery=1:recovery_wait_time=0",
     253             :          0, 0, 0, {AVERROR(ETIMEDOUT), 3, 0}},
     254             : 
     255             :         /* By setting low queue_size and sending packets with longer processing time,
     256             :          * this test will cause queue to overflow, since drop_pkts_on_overflow is off
     257             :          * by default, all packets should be processed and fifo should block on full
     258             :          * queue. */
     259             :         {fifo_basic_test, "overflow without packet dropping","queue_size=3",
     260             :          1, 0, 0, {0, 0, SLEEPTIME_10_MS}},
     261             : 
     262             :         /* The test as the upper one, except that drop_on_overflow is turned on. In this case
     263             :          * fifo should not block when the queue is full and slow down producer, so the test
     264             :          * measures time producer spends on write_packet calls which should be significantly
     265             :          * less than number_of_pkts * 50 MS.
     266             :          */
     267             :         {fifo_overflow_drop_test, "overflow with packet dropping", "queue_size=3:drop_pkts_on_overflow=1",
     268             :          0, 0, 0, {0, 0, SLEEPTIME_50_MS}},
     269             : 
     270             :         {NULL}
     271             : };
     272             : 
     273           1 : int main(int argc, char *argv[])
     274             : {
     275           1 :     int i, ret, ret_all = 0;
     276             : 
     277           5 :     for (i = 0; tests[i].test_func; i++) {
     278           4 :         ret = run_test(&tests[i]);
     279           4 :         if (!ret_all && ret < 0)
     280           0 :             ret_all = ret;
     281             :     }
     282             : 
     283           1 :     return ret;
     284             : }

Generated by: LCOV version 1.13