LCOV - code coverage report
Current view: top level - src/libavcodec - audio_frame_queue.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 57 62 91.9 %
Date: 2017-03-25 17:02:41 Functions: 4 4 100.0 %

          Line data    Source code
       1             : /*
       2             :  * Audio Frame Queue
       3             :  * Copyright (c) 2012 Justin Ruggles
       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
       9             :  * License 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 GNU
      15             :  * Lesser General Public License for more details.
      16             :  *
      17             :  * You should have received a copy of the GNU Lesser General Public
      18             :  * License along with FFmpeg; if not, write to the Free Software
      19             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      20             :  */
      21             : 
      22             : #include "libavutil/attributes.h"
      23             : #include "libavutil/common.h"
      24             : #include "audio_frame_queue.h"
      25             : #include "internal.h"
      26             : #include "libavutil/avassert.h"
      27             : 
      28          14 : av_cold void ff_af_queue_init(AVCodecContext *avctx, AudioFrameQueue *afq)
      29             : {
      30          14 :     afq->avctx = avctx;
      31          14 :     afq->remaining_delay   = avctx->initial_padding;
      32          14 :     afq->remaining_samples = avctx->initial_padding;
      33          14 :     afq->frame_count       = 0;
      34          14 : }
      35             : 
      36          14 : void ff_af_queue_close(AudioFrameQueue *afq)
      37             : {
      38          14 :     if(afq->frame_count)
      39           0 :         av_log(afq->avctx, AV_LOG_WARNING, "%d frames left in the queue on closing\n", afq->frame_count);
      40          14 :     av_freep(&afq->frames);
      41          14 :     memset(afq, 0, sizeof(*afq));
      42          14 : }
      43             : 
      44        4879 : int ff_af_queue_add(AudioFrameQueue *afq, const AVFrame *f)
      45             : {
      46        4879 :     AudioFrame *new = av_fast_realloc(afq->frames, &afq->frame_alloc, sizeof(*afq->frames)*(afq->frame_count+1));
      47        4879 :     if(!new)
      48           0 :         return AVERROR(ENOMEM);
      49        4879 :     afq->frames = new;
      50        4879 :     new += afq->frame_count;
      51             : 
      52             :     /* get frame parameters */
      53        4879 :     new->duration = f->nb_samples;
      54        4879 :     new->duration += afq->remaining_delay;
      55        4879 :     if (f->pts != AV_NOPTS_VALUE) {
      56        4879 :         new->pts = av_rescale_q(f->pts,
      57        4879 :                                       afq->avctx->time_base,
      58        4879 :                                       (AVRational){ 1, afq->avctx->sample_rate });
      59        4879 :         new->pts -= afq->remaining_delay;
      60        4879 :         if(afq->frame_count && new[-1].pts >= new->pts)
      61           0 :             av_log(afq->avctx, AV_LOG_WARNING, "Queue input is backward in time\n");
      62             :     } else {
      63           0 :         new->pts = AV_NOPTS_VALUE;
      64             :     }
      65        4879 :     afq->remaining_delay = 0;
      66             : 
      67             :     /* add frame sample count */
      68        4879 :     afq->remaining_samples += f->nb_samples;
      69             : 
      70        4879 :     afq->frame_count++;
      71             : 
      72        4879 :     return 0;
      73             : }
      74             : 
      75        4893 : void ff_af_queue_remove(AudioFrameQueue *afq, int nb_samples, int64_t *pts,
      76             :                         int64_t *duration)
      77             : {
      78        4893 :     int64_t out_pts = AV_NOPTS_VALUE;
      79        4893 :     int removed_samples = 0;
      80             :     int i;
      81             : 
      82        4893 :     if (afq->frame_count || afq->frame_alloc) {
      83        4893 :         if (afq->frames->pts != AV_NOPTS_VALUE)
      84        4893 :             out_pts = afq->frames->pts;
      85             :     }
      86        4893 :     if(!afq->frame_count)
      87           0 :         av_log(afq->avctx, AV_LOG_WARNING, "Trying to remove %d samples, but the queue is empty\n", nb_samples);
      88        4893 :     if (pts)
      89        4893 :         *pts = ff_samples_to_time_base(afq->avctx, out_pts);
      90             : 
      91       10160 :     for(i=0; nb_samples && i<afq->frame_count; i++){
      92        5267 :         int n= FFMIN(afq->frames[i].duration, nb_samples);
      93        5267 :         afq->frames[i].duration -= n;
      94        5267 :         nb_samples              -= n;
      95        5267 :         removed_samples         += n;
      96        5267 :         if(afq->frames[i].pts != AV_NOPTS_VALUE)
      97        5267 :             afq->frames[i].pts      += n;
      98             :     }
      99        4893 :     afq->remaining_samples -= removed_samples;
     100        4893 :     i -= i && afq->frames[i-1].duration;
     101        4893 :     memmove(afq->frames, afq->frames + i, sizeof(*afq->frames) * (afq->frame_count - i));
     102        4893 :     afq->frame_count -= i;
     103             : 
     104        4893 :     if(nb_samples){
     105          13 :         av_assert0(!afq->frame_count);
     106          13 :         av_assert0(afq->remaining_samples == afq->remaining_delay);
     107          13 :         if(afq->frames && afq->frames[0].pts != AV_NOPTS_VALUE)
     108          13 :             afq->frames[0].pts += nb_samples;
     109          13 :         av_log(afq->avctx, AV_LOG_DEBUG, "Trying to remove %d more samples than there are in the queue\n", nb_samples);
     110             :     }
     111        4893 :     if (duration)
     112        4893 :         *duration = ff_samples_to_time_base(afq->avctx, removed_samples);
     113        4893 : }

Generated by: LCOV version 1.13