LCOV - code coverage report
Current view: top level - libavformat - voc_packet.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 62 87 71.3 %
Date: 2017-12-13 02:34:56 Functions: 1 1 100.0 %

          Line data    Source code
       1             : /*
       2             :  * Copyright (c) 2006  Aurelien Jacobs <aurel@gnuage.org>
       3             :  *
       4             :  * This file is part of FFmpeg.
       5             :  *
       6             :  * FFmpeg is free software; you can redistribute it and/or
       7             :  * modify it under the terms of the GNU Lesser General Public
       8             :  * License as published by the Free Software Foundation; either
       9             :  * version 2.1 of the License, or (at your option) any later version.
      10             :  *
      11             :  * FFmpeg is distributed in the hope that it will be useful,
      12             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      13             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      14             :  * Lesser General Public License for more details.
      15             :  *
      16             :  * You should have received a copy of the GNU Lesser General Public
      17             :  * License along with FFmpeg; if not, write to the Free Software
      18             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      19             :  */
      20             : 
      21             : #include "libavutil/intreadwrite.h"
      22             : #include "avformat.h"
      23             : #include "internal.h"
      24             : #include "voc.h"
      25             : 
      26             : int
      27         315 : ff_voc_get_packet(AVFormatContext *s, AVPacket *pkt, AVStream *st, int max_size)
      28             : {
      29         315 :     VocDecContext *voc = s->priv_data;
      30         315 :     AVCodecParameters *par = st->codecpar;
      31         315 :     AVIOContext *pb = s->pb;
      32             :     VocType type;
      33         315 :     int size, tmp_codec=-1;
      34         315 :     int sample_rate = 0;
      35         315 :     int channels = 1;
      36             :     int64_t duration;
      37             :     int ret;
      38             : 
      39         315 :     av_add_index_entry(st,
      40             :                        avio_tell(pb),
      41             :                        voc->pts,
      42         315 :                        voc->remaining_size,
      43             :                        0,
      44             :                        AVINDEX_KEYFRAME);
      45             : 
      46         792 :     while (!voc->remaining_size) {
      47         193 :         type = avio_r8(pb);
      48         193 :         if (type == VOC_TYPE_EOF)
      49          31 :             return AVERROR_EOF;
      50         162 :         voc->remaining_size = avio_rl24(pb);
      51         162 :         if (!voc->remaining_size) {
      52           0 :             if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
      53           0 :                 return AVERROR(EIO);
      54           0 :             voc->remaining_size = avio_size(pb) - avio_tell(pb);
      55             :         }
      56         162 :         max_size -= 4;
      57             : 
      58         162 :         switch (type) {
      59          26 :         case VOC_TYPE_VOICE_DATA:
      60          26 :             if (!par->sample_rate) {
      61           7 :                 par->sample_rate = 1000000 / (256 - avio_r8(pb));
      62           7 :                 if (sample_rate)
      63           0 :                     par->sample_rate = sample_rate;
      64           7 :                 avpriv_set_pts_info(st, 64, 1, par->sample_rate);
      65           7 :                 par->channels = channels;
      66           7 :                 par->bits_per_coded_sample = av_get_bits_per_sample(par->codec_id);
      67             :             } else
      68          19 :                 avio_skip(pb, 1);
      69          26 :             tmp_codec = avio_r8(pb);
      70          26 :             voc->remaining_size -= 2;
      71          26 :             max_size -= 2;
      72          26 :             channels = 1;
      73          26 :             break;
      74             : 
      75         135 :         case VOC_TYPE_VOICE_DATA_CONT:
      76         135 :             break;
      77             : 
      78           0 :         case VOC_TYPE_EXTENDED:
      79           0 :             sample_rate = avio_rl16(pb);
      80           0 :             avio_r8(pb);
      81           0 :             channels = avio_r8(pb) + 1;
      82           0 :             sample_rate = 256000000 / (channels * (65536 - sample_rate));
      83           0 :             voc->remaining_size = 0;
      84           0 :             max_size -= 4;
      85           0 :             break;
      86             : 
      87           1 :         case VOC_TYPE_NEW_VOICE_DATA:
      88           1 :             if (!par->sample_rate) {
      89           1 :                 par->sample_rate = avio_rl32(pb);
      90           1 :                 avpriv_set_pts_info(st, 64, 1, par->sample_rate);
      91           1 :                 par->bits_per_coded_sample = avio_r8(pb);
      92           1 :                 par->channels = avio_r8(pb);
      93             :             } else
      94           0 :                 avio_skip(pb, 6);
      95           1 :             tmp_codec = avio_rl16(pb);
      96           1 :             avio_skip(pb, 4);
      97           1 :             voc->remaining_size -= 12;
      98           1 :             max_size -= 12;
      99           1 :             break;
     100             : 
     101           0 :         default:
     102           0 :             avio_skip(pb, voc->remaining_size);
     103           0 :             max_size -= voc->remaining_size;
     104           0 :             voc->remaining_size = 0;
     105           0 :             break;
     106             :         }
     107             :     }
     108             : 
     109         284 :     if (par->sample_rate <= 0) {
     110           0 :         av_log(s, AV_LOG_ERROR, "Invalid sample rate %d\n", par->sample_rate);
     111           0 :         return AVERROR_INVALIDDATA;
     112             :     }
     113             : 
     114         284 :     if (tmp_codec >= 0) {
     115          27 :         tmp_codec = ff_codec_get_id(ff_voc_codec_tags, tmp_codec);
     116          27 :         if (par->codec_id == AV_CODEC_ID_NONE)
     117           8 :             par->codec_id = tmp_codec;
     118          19 :         else if (par->codec_id != tmp_codec)
     119           0 :             av_log(s, AV_LOG_WARNING, "Ignoring mid-stream change in audio codec\n");
     120          27 :         if (par->codec_id == AV_CODEC_ID_NONE) {
     121           0 :             if (s->audio_codec_id == AV_CODEC_ID_NONE) {
     122           0 :                 av_log(s, AV_LOG_ERROR, "unknown codec tag\n");
     123           0 :                 return AVERROR(EINVAL);
     124             :             }
     125           0 :             av_log(s, AV_LOG_WARNING, "unknown codec tag\n");
     126             :         }
     127             :     }
     128             : 
     129         284 :     par->bit_rate = (int64_t)par->sample_rate * par->channels * par->bits_per_coded_sample;
     130             : 
     131         284 :     if (max_size <= 0)
     132         242 :         max_size = 2048;
     133         284 :     size = FFMIN(voc->remaining_size, max_size);
     134         284 :     voc->remaining_size -= size;
     135             : 
     136         284 :     ret = av_get_packet(pb, pkt, size);
     137         284 :     pkt->dts = pkt->pts = voc->pts;
     138             : 
     139         284 :     duration = av_get_audio_frame_duration2(st->codecpar, size);
     140         284 :     if (duration > 0 && voc->pts != AV_NOPTS_VALUE)
     141         227 :         voc->pts += duration;
     142             :     else
     143          57 :         voc->pts = AV_NOPTS_VALUE;
     144             : 
     145         284 :     return ret;
     146             : }

Generated by: LCOV version 1.13