LCOV - code coverage report
Current view: top level - libavcodec - mpeg4audio.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 69 77 89.6 %
Date: 2017-12-16 13:57:32 Functions: 5 5 100.0 %

          Line data    Source code
       1             : /*
       2             :  * MPEG-4 Audio common code
       3             :  * Copyright (c) 2008 Baptiste Coudurier <baptiste.coudurier@free.fr>
       4             :  * Copyright (c) 2009 Alex Converse <alex.converse@gmail.com>
       5             :  *
       6             :  * This file is part of FFmpeg.
       7             :  *
       8             :  * FFmpeg is free software; you can redistribute it and/or
       9             :  * modify it under the terms of the GNU Lesser General Public
      10             :  * License as published by the Free Software Foundation; either
      11             :  * version 2.1 of the License, or (at your option) any later version.
      12             :  *
      13             :  * FFmpeg is distributed in the hope that it will be useful,
      14             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      15             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      16             :  * Lesser General Public License for more details.
      17             :  *
      18             :  * You should have received a copy of the GNU Lesser General Public
      19             :  * License along with FFmpeg; if not, write to the Free Software
      20             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      21             :  */
      22             : 
      23             : #include "get_bits.h"
      24             : #include "put_bits.h"
      25             : #include "mpeg4audio.h"
      26             : 
      27             : /**
      28             :  * Parse MPEG-4 audio configuration for ALS object type.
      29             :  * @param[in] gb       bit reader context
      30             :  * @param[in] c        MPEG4AudioConfig structure to fill
      31             :  * @return on success 0 is returned, otherwise a value < 0
      32             :  */
      33          18 : static int parse_config_ALS(GetBitContext *gb, MPEG4AudioConfig *c)
      34             : {
      35          18 :     if (get_bits_left(gb) < 112)
      36           0 :         return AVERROR_INVALIDDATA;
      37             : 
      38          18 :     if (get_bits_long(gb, 32) != MKBETAG('A','L','S','\0'))
      39           0 :         return AVERROR_INVALIDDATA;
      40             : 
      41             :     // override AudioSpecificConfig channel configuration and sample rate
      42             :     // which are buggy in old ALS conformance files
      43          18 :     c->sample_rate = get_bits_long(gb, 32);
      44             : 
      45          18 :     if (c->sample_rate <= 0) {
      46           0 :         av_log(NULL, AV_LOG_ERROR, "Invalid sample rate %d\n", c->sample_rate);
      47           0 :         return AVERROR_INVALIDDATA;
      48             :     }
      49             : 
      50             :     // skip number of samples
      51          18 :     skip_bits_long(gb, 32);
      52             : 
      53             :     // read number of channels
      54          18 :     c->chan_config = 0;
      55          18 :     c->channels    = get_bits(gb, 16) + 1;
      56             : 
      57          18 :     return 0;
      58             : }
      59             : 
      60             : /* XXX: make sure to update the copies in the different encoders if you change
      61             :  * this table */
      62             : const int avpriv_mpeg4audio_sample_rates[16] = {
      63             :     96000, 88200, 64000, 48000, 44100, 32000,
      64             :     24000, 22050, 16000, 12000, 11025, 8000, 7350
      65             : };
      66             : 
      67             : const uint8_t ff_mpeg4audio_channels[8] = {
      68             :     0, 1, 2, 3, 4, 5, 6, 8
      69             : };
      70             : 
      71         814 : static inline int get_object_type(GetBitContext *gb)
      72             : {
      73         814 :     int object_type = get_bits(gb, 5);
      74         814 :     if (object_type == AOT_ESCAPE)
      75          33 :         object_type = 32 + get_bits(gb, 6);
      76         814 :     return object_type;
      77             : }
      78             : 
      79         750 : static inline int get_sample_rate(GetBitContext *gb, int *index)
      80             : {
      81         750 :     *index = get_bits(gb, 4);
      82        1482 :     return *index == 0x0f ? get_bits(gb, 24) :
      83         732 :         avpriv_mpeg4audio_sample_rates[*index];
      84             : }
      85             : 
      86         666 : int ff_mpeg4audio_get_config_gb(MPEG4AudioConfig *c, GetBitContext *gb,
      87             :                                 int sync_extension)
      88             : {
      89             :     int specific_config_bitindex, ret;
      90         666 :     int start_bit_index = get_bits_count(gb);
      91         666 :     c->object_type = get_object_type(gb);
      92         666 :     c->sample_rate = get_sample_rate(gb, &c->sampling_index);
      93         666 :     c->chan_config = get_bits(gb, 4);
      94         666 :     if (c->chan_config < FF_ARRAY_ELEMS(ff_mpeg4audio_channels))
      95         666 :         c->channels = ff_mpeg4audio_channels[c->chan_config];
      96         666 :     c->sbr = -1;
      97         666 :     c->ps  = -1;
      98         669 :     if (c->object_type == AOT_SBR || (c->object_type == AOT_PS &&
      99             :         // check for W6132 Annex YYYY draft MP3onMP4
     100           6 :         !(show_bits(gb, 3) & 0x03 && !(show_bits(gb, 9) & 0x3F)))) {
     101           6 :         if (c->object_type == AOT_PS)
     102           3 :             c->ps = 1;
     103           6 :         c->ext_object_type = AOT_SBR;
     104           6 :         c->sbr = 1;
     105           6 :         c->ext_sample_rate = get_sample_rate(gb, &c->ext_sampling_index);
     106           6 :         c->object_type = get_object_type(gb);
     107          12 :         if (c->object_type == AOT_ER_BSAC)
     108           0 :             c->ext_chan_config = get_bits(gb, 4);
     109             :     } else {
     110         660 :         c->ext_object_type = AOT_NULL;
     111         660 :         c->ext_sample_rate = 0;
     112             :     }
     113         666 :     specific_config_bitindex = get_bits_count(gb);
     114             : 
     115         666 :     if (c->object_type == AOT_ALS) {
     116          18 :         skip_bits(gb, 5);
     117          18 :         if (show_bits_long(gb, 24) != MKBETAG('\0','A','L','S'))
     118           0 :             skip_bits_long(gb, 24);
     119             : 
     120          18 :         specific_config_bitindex = get_bits_count(gb);
     121             : 
     122          18 :         ret = parse_config_ALS(gb, c);
     123          18 :         if (ret < 0)
     124           0 :             return ret;
     125             :     }
     126             : 
     127         666 :     if (c->ext_object_type != AOT_SBR && sync_extension) {
     128       13336 :         while (get_bits_left(gb) > 15) {
     129       12798 :             if (show_bits(gb, 11) == 0x2b7) { // sync extension
     130         142 :                 get_bits(gb, 11);
     131         142 :                 c->ext_object_type = get_object_type(gb);
     132         142 :                 if (c->ext_object_type == AOT_SBR && (c->sbr = get_bits1(gb)) == 1) {
     133          78 :                     c->ext_sample_rate = get_sample_rate(gb, &c->ext_sampling_index);
     134          78 :                     if (c->ext_sample_rate == c->sample_rate)
     135           6 :                         c->sbr = -1;
     136             :                 }
     137         142 :                 if (get_bits_left(gb) > 11 && get_bits(gb, 11) == 0x548)
     138          27 :                     c->ps = get_bits1(gb);
     139         142 :                 break;
     140             :             } else
     141       12656 :                 get_bits1(gb); // skip 1 bit
     142             :         }
     143             :     }
     144             : 
     145             :     //PS requires SBR
     146         666 :     if (!c->sbr)
     147          55 :         c->ps = 0;
     148             :     //Limit implicit PS to the HE-AACv2 Profile
     149         666 :     if ((c->ps == -1 && c->object_type != AOT_AAC_LC) || c->channels & ~0x01)
     150         500 :         c->ps = 0;
     151             : 
     152         666 :     return specific_config_bitindex - start_bit_index;
     153             : }
     154             : 
     155         137 : int avpriv_mpeg4audio_get_config(MPEG4AudioConfig *c, const uint8_t *buf,
     156             :                                  int bit_size, int sync_extension)
     157             : {
     158             :     GetBitContext gb;
     159             :     int ret;
     160             : 
     161         137 :     if (bit_size <= 0)
     162           1 :         return AVERROR_INVALIDDATA;
     163             : 
     164         136 :     ret = init_get_bits(&gb, buf, bit_size);
     165         136 :     if (ret < 0)
     166           0 :         return ret;
     167             : 
     168         136 :     return ff_mpeg4audio_get_config_gb(c, &gb, sync_extension);
     169             : }

Generated by: LCOV version 1.13