LCOV - code coverage report
Current view: top level - libavformat - pcmdec.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 19 40 47.5 %
Date: 2017-12-13 10:57:33 Functions: 1 1 100.0 %

          Line data    Source code
       1             : /*
       2             :  * RAW PCM demuxers
       3             :  * Copyright (c) 2002 Fabrice Bellard
       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 "avformat.h"
      23             : #include "internal.h"
      24             : #include "pcm.h"
      25             : #include "libavutil/log.h"
      26             : #include "libavutil/opt.h"
      27             : #include "libavutil/avassert.h"
      28             : 
      29             : typedef struct PCMAudioDemuxerContext {
      30             :     AVClass *class;
      31             :     int sample_rate;
      32             :     int channels;
      33             : } PCMAudioDemuxerContext;
      34             : 
      35          67 : static int pcm_read_header(AVFormatContext *s)
      36             : {
      37          67 :     PCMAudioDemuxerContext *s1 = s->priv_data;
      38             :     AVStream *st;
      39          67 :     uint8_t *mime_type = NULL;
      40             : 
      41          67 :     st = avformat_new_stream(s, NULL);
      42          67 :     if (!st)
      43           0 :         return AVERROR(ENOMEM);
      44             : 
      45             : 
      46          67 :     st->codecpar->codec_type  = AVMEDIA_TYPE_AUDIO;
      47          67 :     st->codecpar->codec_id    = s->iformat->raw_codec_id;
      48          67 :     st->codecpar->sample_rate = s1->sample_rate;
      49          67 :     st->codecpar->channels    = s1->channels;
      50             : 
      51          67 :     av_opt_get(s->pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type);
      52          67 :     if (mime_type && s->iformat->mime_type) {
      53           0 :         int rate = 0, channels = 0;
      54           0 :         size_t len = strlen(s->iformat->mime_type);
      55           0 :         if (!strncmp(s->iformat->mime_type, mime_type, len)) {
      56           0 :             uint8_t *options = mime_type + len;
      57           0 :             len = strlen(mime_type);
      58           0 :             while (options < mime_type + len) {
      59           0 :                 options = strstr(options, ";");
      60           0 :                 if (!options++)
      61           0 :                     break;
      62           0 :                 if (!rate)
      63           0 :                     sscanf(options, " rate=%d",     &rate);
      64           0 :                 if (!channels)
      65           0 :                     sscanf(options, " channels=%d", &channels);
      66             :             }
      67           0 :             if (rate <= 0) {
      68           0 :                 av_log(s, AV_LOG_ERROR,
      69             :                        "Invalid sample_rate found in mime_type \"%s\"\n",
      70             :                        mime_type);
      71           0 :                 av_freep(&mime_type);
      72           0 :                 return AVERROR_INVALIDDATA;
      73             :             }
      74           0 :             st->codecpar->sample_rate = rate;
      75           0 :             if (channels > 0)
      76           0 :                 st->codecpar->channels = channels;
      77             :         }
      78             :     }
      79          67 :     av_freep(&mime_type);
      80             : 
      81         134 :     st->codecpar->bits_per_coded_sample =
      82         134 :         av_get_bits_per_sample(st->codecpar->codec_id);
      83             : 
      84          67 :     av_assert0(st->codecpar->bits_per_coded_sample > 0);
      85             : 
      86         134 :     st->codecpar->block_align =
      87         134 :         st->codecpar->bits_per_coded_sample * st->codecpar->channels / 8;
      88             : 
      89          67 :     avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
      90          67 :     return 0;
      91             : }
      92             : 
      93             : static const AVOption pcm_options[] = {
      94             :     { "sample_rate", "", offsetof(PCMAudioDemuxerContext, sample_rate), AV_OPT_TYPE_INT, {.i64 = 44100}, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },
      95             :     { "channels",    "", offsetof(PCMAudioDemuxerContext, channels),    AV_OPT_TYPE_INT, {.i64 = 1}, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },
      96             :     { NULL },
      97             : };
      98             : 
      99             : #define PCMDEF(name_, long_name_, ext, codec, ...)          \
     100             : static const AVClass name_ ## _demuxer_class = {            \
     101             :     .class_name = #name_ " demuxer",                        \
     102             :     .item_name  = av_default_item_name,                     \
     103             :     .option     = pcm_options,                              \
     104             :     .version    = LIBAVUTIL_VERSION_INT,                    \
     105             : };                                                          \
     106             : AVInputFormat ff_pcm_ ## name_ ## _demuxer = {              \
     107             :     .name           = #name_,                               \
     108             :     .long_name      = NULL_IF_CONFIG_SMALL(long_name_),     \
     109             :     .priv_data_size = sizeof(PCMAudioDemuxerContext),       \
     110             :     .read_header    = pcm_read_header,                      \
     111             :     .read_packet    = ff_pcm_read_packet,                   \
     112             :     .read_seek      = ff_pcm_read_seek,                     \
     113             :     .flags          = AVFMT_GENERIC_INDEX,                  \
     114             :     .extensions     = ext,                                  \
     115             :     .raw_codec_id   = codec,                                \
     116             :     .priv_class     = &name_ ## _demuxer_class,             \
     117             :     __VA_ARGS__                                             \
     118             : };
     119             : 
     120             : PCMDEF(f64be, "PCM 64-bit floating-point big-endian",
     121             :        NULL, AV_CODEC_ID_PCM_F64BE)
     122             : 
     123             : PCMDEF(f64le, "PCM 64-bit floating-point little-endian",
     124             :        NULL, AV_CODEC_ID_PCM_F64LE)
     125             : 
     126             : PCMDEF(f32be, "PCM 32-bit floating-point big-endian",
     127             :        NULL, AV_CODEC_ID_PCM_F32BE)
     128             : 
     129             : PCMDEF(f32le, "PCM 32-bit floating-point little-endian",
     130             :        NULL, AV_CODEC_ID_PCM_F32LE)
     131             : 
     132             : PCMDEF(s32be, "PCM signed 32-bit big-endian",
     133             :        NULL, AV_CODEC_ID_PCM_S32BE)
     134             : 
     135             : PCMDEF(s32le, "PCM signed 32-bit little-endian",
     136             :        NULL, AV_CODEC_ID_PCM_S32LE)
     137             : 
     138             : PCMDEF(s24be, "PCM signed 24-bit big-endian",
     139             :        NULL, AV_CODEC_ID_PCM_S24BE)
     140             : 
     141             : PCMDEF(s24le, "PCM signed 24-bit little-endian",
     142             :        NULL, AV_CODEC_ID_PCM_S24LE)
     143             : 
     144             : PCMDEF(s16be, "PCM signed 16-bit big-endian",
     145             :        AV_NE("sw", NULL), AV_CODEC_ID_PCM_S16BE)
     146             : 
     147             : PCMDEF(s16le, "PCM signed 16-bit little-endian",
     148             :        AV_NE(NULL, "sw"), AV_CODEC_ID_PCM_S16LE, .mime_type = "audio/L16",)
     149             : 
     150             : PCMDEF(s8, "PCM signed 8-bit",
     151             :        "sb", AV_CODEC_ID_PCM_S8)
     152             : 
     153             : PCMDEF(u32be, "PCM unsigned 32-bit big-endian",
     154             :        NULL, AV_CODEC_ID_PCM_U32BE)
     155             : 
     156             : PCMDEF(u32le, "PCM unsigned 32-bit little-endian",
     157             :        NULL, AV_CODEC_ID_PCM_U32LE)
     158             : 
     159             : PCMDEF(u24be, "PCM unsigned 24-bit big-endian",
     160             :        NULL, AV_CODEC_ID_PCM_U24BE)
     161             : 
     162             : PCMDEF(u24le, "PCM unsigned 24-bit little-endian",
     163             :        NULL, AV_CODEC_ID_PCM_U24LE)
     164             : 
     165             : PCMDEF(u16be, "PCM unsigned 16-bit big-endian",
     166             :        AV_NE("uw", NULL), AV_CODEC_ID_PCM_U16BE)
     167             : 
     168             : PCMDEF(u16le, "PCM unsigned 16-bit little-endian",
     169             :        AV_NE(NULL, "uw"), AV_CODEC_ID_PCM_U16LE)
     170             : 
     171             : PCMDEF(u8, "PCM unsigned 8-bit",
     172             :        "ub", AV_CODEC_ID_PCM_U8)
     173             : 
     174             : PCMDEF(alaw, "PCM A-law",
     175             :        "al", AV_CODEC_ID_PCM_ALAW)
     176             : 
     177             : PCMDEF(mulaw, "PCM mu-law",
     178             :        "ul", AV_CODEC_ID_PCM_MULAW)
     179             : 
     180             : static const AVOption sln_options[] = {
     181             :     { "sample_rate", "", offsetof(PCMAudioDemuxerContext, sample_rate), AV_OPT_TYPE_INT, {.i64 = 8000}, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },
     182             :     { "channels",    "", offsetof(PCMAudioDemuxerContext, channels),    AV_OPT_TYPE_INT, {.i64 = 1}, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },
     183             :     { NULL },
     184             : };
     185             : 
     186             : static const AVClass sln_demuxer_class = {
     187             :     .class_name = "sln demuxer",
     188             :     .item_name  = av_default_item_name,
     189             :     .option     = sln_options,
     190             :     .version    = LIBAVUTIL_VERSION_INT,
     191             : };
     192             : 
     193             : AVInputFormat ff_sln_demuxer = {
     194             :     .name           = "sln",
     195             :     .long_name      = NULL_IF_CONFIG_SMALL("Asterisk raw pcm"),
     196             :     .priv_data_size = sizeof(PCMAudioDemuxerContext),
     197             :     .read_header    = pcm_read_header,
     198             :     .read_packet    = ff_pcm_read_packet,
     199             :     .read_seek      = ff_pcm_read_seek,
     200             :     .flags          = AVFMT_GENERIC_INDEX,
     201             :     .extensions     = "sln",
     202             :     .raw_codec_id   = AV_CODEC_ID_PCM_S16LE,
     203             :     .priv_class     = &sln_demuxer_class,
     204             : };

Generated by: LCOV version 1.13